summaryrefslogtreecommitdiff
path: root/vendor/golang.org/x/text/language/display/display_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/golang.org/x/text/language/display/display_test.go')
-rw-r--r--vendor/golang.org/x/text/language/display/display_test.go714
1 files changed, 0 insertions, 714 deletions
diff --git a/vendor/golang.org/x/text/language/display/display_test.go b/vendor/golang.org/x/text/language/display/display_test.go
deleted file mode 100644
index 4f5b48e..0000000
--- a/vendor/golang.org/x/text/language/display/display_test.go
+++ /dev/null
@@ -1,714 +0,0 @@
-// Copyright 2014 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 display
-
-import (
- "fmt"
- "reflect"
- "strings"
- "testing"
- "unicode"
-
- "golang.org/x/text/internal/testtext"
- "golang.org/x/text/language"
- "golang.org/x/text/message"
-)
-
-// TODO: test that tables are properly dropped by the linker for various use
-// cases.
-
-var (
- firstLang2aa = language.MustParseBase("aa")
- lastLang2zu = language.MustParseBase("zu")
- firstLang3ace = language.MustParseBase("ace")
- lastLang3zza = language.MustParseBase("zza")
- firstTagAr001 = language.MustParse("ar-001")
- lastTagZhHant = language.MustParse("zh-Hant")
-)
-
-// TestValues tests that for all languages, regions, and scripts in Values, at
-// least one language has a name defined for it by checking it exists in
-// English, which is assumed to be the most comprehensive. It is also tested
-// that a Namer returns "" for unsupported values.
-func TestValues(t *testing.T) {
- type testcase struct {
- kind string
- n Namer
- }
- // checkDefined checks that a value exists in a Namer.
- checkDefined := func(x interface{}, namers []testcase) {
- for _, n := range namers {
- testtext.Run(t, fmt.Sprintf("%s.Name(%s)", n.kind, x), func(t *testing.T) {
- if n.n.Name(x) == "" {
- // As of version 28 there is no data for az-Arab in English,
- // although there is useful data in other languages.
- if x.(fmt.Stringer).String() == "az-Arab" {
- return
- }
- t.Errorf("supported but no result")
- }
- })
- }
- }
- // checkUnsupported checks that a value does not exist in a Namer.
- checkUnsupported := func(x interface{}, namers []testcase) {
- for _, n := range namers {
- if got := n.n.Name(x); got != "" {
- t.Fatalf("%s.Name(%s): unsupported tag gave non-empty result: %q", n.kind, x, got)
- }
- }
- }
-
- tags := map[language.Tag]bool{}
- namers := []testcase{
- {"Languages(en)", Languages(language.English)},
- {"Tags(en)", Tags(language.English)},
- {"English.Languages()", English.Languages()},
- {"English.Tags()", English.Tags()},
- }
- for _, tag := range Values.Tags() {
- checkDefined(tag, namers)
- tags[tag] = true
- }
- for _, base := range language.Supported.BaseLanguages() {
- tag, _ := language.All.Compose(base)
- if !tags[tag] {
- checkUnsupported(tag, namers)
- }
- }
-
- regions := map[language.Region]bool{}
- namers = []testcase{
- {"Regions(en)", Regions(language.English)},
- {"English.Regions()", English.Regions()},
- }
- for _, r := range Values.Regions() {
- checkDefined(r, namers)
- regions[r] = true
- }
- for _, r := range language.Supported.Regions() {
- if r = r.Canonicalize(); !regions[r] {
- checkUnsupported(r, namers)
- }
- }
-
- scripts := map[language.Script]bool{}
- namers = []testcase{
- {"Scripts(en)", Scripts(language.English)},
- {"English.Scripts()", English.Scripts()},
- }
- for _, s := range Values.Scripts() {
- checkDefined(s, namers)
- scripts[s] = true
- }
- for _, s := range language.Supported.Scripts() {
- // Canonicalize the script.
- tag, _ := language.DeprecatedScript.Compose(s)
- if _, s, _ = tag.Raw(); !scripts[s] {
- checkUnsupported(s, namers)
- }
- }
-}
-
-// TestSupported tests that we have at least some Namers for languages that we
-// claim to support. To test the claims in the documentation, it also verifies
-// that if a Namer is returned, it will have at least some data.
-func TestSupported(t *testing.T) {
- supportedTags := Supported.Tags()
- if len(supportedTags) != numSupported {
- t.Errorf("number of supported was %d; want %d", len(supportedTags), numSupported)
- }
-
- namerFuncs := []struct {
- kind string
- fn func(language.Tag) Namer
- }{
- {"Tags", Tags},
- {"Languages", Languages},
- {"Regions", Regions},
- {"Scripts", Scripts},
- }
-
- // Verify that we have at least one Namer for all tags we claim to support.
- tags := make(map[language.Tag]bool)
- for _, tag := range supportedTags {
- // Test we have at least one Namer for this supported Tag.
- found := false
- for _, kind := range namerFuncs {
- if defined(t, kind.kind, kind.fn(tag), tag) {
- found = true
- }
- }
- if !found {
- t.Errorf("%s: supported, but no data available", tag)
- }
- if tags[tag] {
- t.Errorf("%s: included in Supported.Tags more than once", tag)
- }
- tags[tag] = true
- }
-
- // Verify that we have no Namers for tags we don't claim to support.
- for _, base := range language.Supported.BaseLanguages() {
- tag, _ := language.All.Compose(base)
- // Skip tags that are supported after matching.
- if _, _, conf := matcher.Match(tag); conf != language.No {
- continue
- }
- // Test there are no Namers for this tag.
- for _, kind := range namerFuncs {
- if defined(t, kind.kind, kind.fn(tag), tag) {
- t.Errorf("%[1]s(%[2]s) returns a Namer, but %[2]s is not in the set of supported Tags.", kind.kind, tag)
- }
- }
- }
-}
-
-// defined reports whether n is a proper Namer, which means it is non-nil and
-// must have at least one non-empty value.
-func defined(t *testing.T, kind string, n Namer, tag language.Tag) bool {
- if n == nil {
- return false
- }
- switch kind {
- case "Tags":
- for _, t := range Values.Tags() {
- if n.Name(t) != "" {
- return true
- }
- }
- case "Languages":
- for _, t := range Values.BaseLanguages() {
- if n.Name(t) != "" {
- return true
- }
- }
- case "Regions":
- for _, t := range Values.Regions() {
- if n.Name(t) != "" {
- return true
- }
- }
- case "Scripts":
- for _, t := range Values.Scripts() {
- if n.Name(t) != "" {
- return true
- }
- }
- }
- t.Errorf("%s(%s) returns non-nil Namer without content", kind, tag)
- return false
-}
-
-func TestCoverage(t *testing.T) {
- en := language.English
- tests := []struct {
- n Namer
- x interface{}
- }{
- {Languages(en), Values.Tags()},
- {Scripts(en), Values.Scripts()},
- {Regions(en), Values.Regions()},
- }
- for i, tt := range tests {
- uniq := make(map[string]interface{})
-
- v := reflect.ValueOf(tt.x)
- for j := 0; j < v.Len(); j++ {
- x := v.Index(j).Interface()
- // As of version 28 there is no data for az-Arab in English,
- // although there is useful data in other languages.
- if x.(fmt.Stringer).String() == "az-Arab" {
- continue
- }
- s := tt.n.Name(x)
- if s == "" {
- t.Errorf("%d:%d:%s: missing content", i, j, x)
- } else if uniq[s] != nil {
- t.Errorf("%d:%d:%s: identical return value %q for %v and %v", i, j, x, s, x, uniq[s])
- }
- uniq[s] = x
- }
- }
-}
-
-// TestUpdate tests whether dictionary entries for certain languages need to be
-// updated. For some languages, some of the headers may be empty or they may be
-// identical to the parent. This code detects if such entries need to be updated
-// after a table update.
-func TestUpdate(t *testing.T) {
- tests := []struct {
- d *Dictionary
- tag string
- }{
- {ModernStandardArabic, "ar-001"},
- {AmericanEnglish, "en-US"},
- {EuropeanSpanish, "es-ES"},
- {BrazilianPortuguese, "pt-BR"},
- {SimplifiedChinese, "zh-Hans"},
- }
-
- for _, tt := range tests {
- _, i, _ := matcher.Match(language.MustParse(tt.tag))
- if !reflect.DeepEqual(tt.d.lang, langHeaders[i]) {
- t.Errorf("%s: lang table update needed", tt.tag)
- }
- if !reflect.DeepEqual(tt.d.script, scriptHeaders[i]) {
- t.Errorf("%s: script table update needed", tt.tag)
- }
- if !reflect.DeepEqual(tt.d.region, regionHeaders[i]) {
- t.Errorf("%s: region table update needed", tt.tag)
- }
- }
-}
-
-func TestIndex(t *testing.T) {
- notIn := []string{"aa", "xx", "zz", "aaa", "xxx", "zzz", "Aaaa", "Xxxx", "Zzzz"}
- tests := []tagIndex{
- {
- "",
- "",
- "",
- },
- {
- "bb",
- "",
- "",
- },
- {
- "",
- "bbb",
- "",
- },
- {
- "",
- "",
- "Bbbb",
- },
- {
- "bb",
- "bbb",
- "Bbbb",
- },
- {
- "bbccddyy",
- "bbbcccdddyyy",
- "BbbbCcccDdddYyyy",
- },
- }
- for i, tt := range tests {
- // Create the test set from the tagIndex.
- cnt := 0
- for sz := 2; sz <= 4; sz++ {
- a := tt[sz-2]
- for j := 0; j < len(a); j += sz {
- s := a[j : j+sz]
- if idx := tt.index(s); idx != cnt {
- t.Errorf("%d:%s: index was %d; want %d", i, s, idx, cnt)
- }
- cnt++
- }
- }
- if n := tt.len(); n != cnt {
- t.Errorf("%d: len was %d; want %d", i, n, cnt)
- }
- for _, x := range notIn {
- if idx := tt.index(x); idx != -1 {
- t.Errorf("%d:%s: index was %d; want -1", i, x, idx)
- }
- }
- }
-}
-
-func TestTag(t *testing.T) {
- tests := []struct {
- dict string
- tag string
- name string
- }{
- // sr is in Value.Languages(), but is not supported by agq.
- {"agq", "sr", "|[language: sr]"},
- {"nl", "nl", "Nederlands"},
- // CLDR 30 dropped Vlaams as the word for nl-BE. It is still called
- // Flemish in English, though. TODO: check if this is a CLDR bug.
- // {"nl", "nl-BE", "Vlaams"},
- {"nl", "nl-BE", "Nederlands (België)"},
- {"nl", "vls", "West-Vlaams"},
- {"en", "nl-BE", "Flemish"},
- {"en", "en", "English"},
- {"en", "en-GB", "British English"},
- {"en", "en-US", "American English"}, // American English in CLDR 24+
- {"ru", "ru", "русский"},
- {"ru", "ru-RU", "русский (Россия)"},
- {"ru", "ru-Cyrl", "русский (кириллица)"},
- {"en", lastLang2zu.String(), "Zulu"},
- {"en", firstLang2aa.String(), "Afar"},
- {"en", lastLang3zza.String(), "Zaza"},
- {"en", firstLang3ace.String(), "Achinese"},
- {"en", firstTagAr001.String(), "Modern Standard Arabic"},
- {"en", lastTagZhHant.String(), "Traditional Chinese"},
- {"en", "aaa", "|Unknown language (aaa)"},
- {"en", "zzj", "|Unknown language (zzj)"},
- // If full tag doesn't match, try without script or region.
- {"en", "aa-Hans", "Afar (Simplified Han)"},
- {"en", "af-Arab", "Afrikaans (Arabic)"},
- {"en", "zu-Cyrl", "Zulu (Cyrillic)"},
- {"en", "aa-GB", "Afar (United Kingdom)"},
- {"en", "af-NA", "Afrikaans (Namibia)"},
- {"en", "zu-BR", "Zulu (Brazil)"},
- // Correct inheritance and language selection.
- {"zh", "zh-TW", "中文 (台湾)"},
- {"zh", "zh-Hant-TW", "繁体中文 (台湾)"},
- {"zh-Hant", "zh-TW", "中文 (台灣)"},
- {"zh-Hant", "zh-Hant-TW", "繁體中文 (台灣)"},
- // Some rather arbitrary interpretations for Serbian. This is arguably
- // correct and consistent with the way zh-[Hant-]TW is handled. It will
- // also give results more in line with the expectations if users
- // explicitly use "sh".
- {"sr-Latn", "sr-ME", "srpski (Crna Gora)"},
- {"sr-Latn", "sr-Latn-ME", "srpskohrvatski (Crna Gora)"},
- // Double script and region
- {"nl", "en-Cyrl-BE", "Engels (Cyrillisch, België)"},
- }
- for _, tt := range tests {
- t.Run(tt.dict+"/"+tt.tag, func(t *testing.T) {
- name, fmtName := splitName(tt.name)
- dict := language.MustParse(tt.dict)
- tag := language.Raw.MustParse(tt.tag)
- d := Tags(dict)
- if n := d.Name(tag); n != name {
- // There are inconsistencies w.r.t. capitalization in the tests
- // due to CLDR's update procedure which treats modern and other
- // languages differently.
- // See http://unicode.org/cldr/trac/ticket/8051.
- // TODO: use language capitalization to sanitize the strings.
- t.Errorf("Name(%s) = %q; want %q", tag, n, name)
- }
-
- p := message.NewPrinter(dict)
- if n := p.Sprint(Tag(tag)); n != fmtName {
- t.Errorf("Tag(%s) = %q; want %q", tag, n, fmtName)
- }
- })
- }
-}
-
-func splitName(names string) (name, formatName string) {
- split := strings.Split(names, "|")
- name, formatName = split[0], split[0]
- if len(split) > 1 {
- formatName = split[1]
- }
- return name, formatName
-}
-
-func TestLanguage(t *testing.T) {
- tests := []struct {
- dict string
- tag string
- name string
- }{
- // sr is in Value.Languages(), but is not supported by agq.
- {"agq", "sr", "|[language: sr]"},
- // CLDR 30 dropped Vlaams as the word for nl-BE. It is still called
- // Flemish in English, though. TODO: this is probably incorrect.
- // West-Vlaams (vls) is not Vlaams. West-Vlaams could be considered its
- // own language, whereas Vlaams is generally Dutch. So expect to have
- // to change these tests back.
- {"nl", "nl", "Nederlands"},
- {"nl", "vls", "West-Vlaams"},
- {"nl", "nl-BE", "Nederlands"},
- {"en", "pt", "Portuguese"},
- {"en", "pt-PT", "European Portuguese"},
- {"en", "pt-BR", "Brazilian Portuguese"},
- {"en", "en", "English"},
- {"en", "en-GB", "British English"},
- {"en", "en-US", "American English"}, // American English in CLDR 24+
- {"en", lastLang2zu.String(), "Zulu"},
- {"en", firstLang2aa.String(), "Afar"},
- {"en", lastLang3zza.String(), "Zaza"},
- {"en", firstLang3ace.String(), "Achinese"},
- {"en", firstTagAr001.String(), "Modern Standard Arabic"},
- {"en", lastTagZhHant.String(), "Traditional Chinese"},
- {"en", "aaa", "|Unknown language (aaa)"},
- {"en", "zzj", "|Unknown language (zzj)"},
- // If full tag doesn't match, try without script or region.
- {"en", "aa-Hans", "Afar"},
- {"en", "af-Arab", "Afrikaans"},
- {"en", "zu-Cyrl", "Zulu"},
- {"en", "aa-GB", "Afar"},
- {"en", "af-NA", "Afrikaans"},
- {"en", "zu-BR", "Zulu"},
- {"agq", "zh-Hant", "|[language: zh-Hant]"},
- {"en", "sh", "Serbo-Croatian"},
- {"en", "sr-Latn", "Serbo-Croatian"},
- {"en", "sr", "Serbian"},
- {"en", "sr-ME", "Serbian"},
- {"en", "sr-Latn-ME", "Serbo-Croatian"}, // See comments in TestTag.
- }
- for _, tt := range tests {
- testtext.Run(t, tt.dict+"/"+tt.tag, func(t *testing.T) {
- name, fmtName := splitName(tt.name)
- dict := language.MustParse(tt.dict)
- tag := language.Raw.MustParse(tt.tag)
- p := message.NewPrinter(dict)
- d := Languages(dict)
- if n := d.Name(tag); n != name {
- t.Errorf("Name(%v) = %q; want %q", tag, n, name)
- }
- if n := p.Sprint(Language(tag)); n != fmtName {
- t.Errorf("Language(%v) = %q; want %q", tag, n, fmtName)
- }
- if len(tt.tag) <= 3 {
- base := language.MustParseBase(tt.tag)
- if n := d.Name(base); n != name {
- t.Errorf("Name(%v) = %q; want %q", base, n, name)
- }
- if n := p.Sprint(Language(base)); n != fmtName {
- t.Errorf("Language(%v) = %q; want %q", base, n, fmtName)
- }
- }
- })
- }
-}
-
-func TestScript(t *testing.T) {
- tests := []struct {
- dict string
- scr string
- name string
- }{
- {"nl", "Arab", "Arabisch"},
- {"en", "Arab", "Arabic"},
- {"en", "Zzzz", "Unknown Script"},
- {"zh-Hant", "Hang", "韓文字"},
- {"zh-Hant-HK", "Hang", "韓文字"},
- {"zh", "Arab", "阿拉伯文"},
- {"zh-Hans-HK", "Arab", "阿拉伯文"}, // same as zh
- {"zh-Hant", "Arab", "阿拉伯文"},
- {"zh-Hant-HK", "Arab", "阿拉伯文"}, // same as zh
- // Canonicalized form
- {"en", "Qaai", "Inherited"}, // deprecated script, now is Zinh
- {"en", "sh", "Unknown Script"}, // sh canonicalizes to sr-Latn
- {"en", "en", "Unknown Script"},
- // Don't introduce scripts with canonicalization.
- {"en", "sh", "Unknown Script"}, // sh canonicalizes to sr-Latn
- }
- for _, tt := range tests {
- t.Run(tt.dict+"/"+tt.scr, func(t *testing.T) {
- name, fmtName := splitName(tt.name)
- dict := language.MustParse(tt.dict)
- p := message.NewPrinter(dict)
- d := Scripts(dict)
- var tag language.Tag
- if unicode.IsUpper(rune(tt.scr[0])) {
- x := language.MustParseScript(tt.scr)
- if n := d.Name(x); n != name {
- t.Errorf("Name(%v) = %q; want %q", x, n, name)
- }
- if n := p.Sprint(Script(x)); n != fmtName {
- t.Errorf("Script(%v) = %q; want %q", x, n, fmtName)
- }
- tag, _ = language.Raw.Compose(x)
- } else {
- tag = language.Raw.MustParse(tt.scr)
- }
- if n := d.Name(tag); n != name {
- t.Errorf("Name(%v) = %q; want %q", tag, n, name)
- }
- if n := p.Sprint(Script(tag)); n != fmtName {
- t.Errorf("Script(%v) = %q; want %q", tag, n, fmtName)
- }
- })
- }
-}
-
-func TestRegion(t *testing.T) {
- tests := []struct {
- dict string
- reg string
- name string
- }{
- {"nl", "NL", "Nederland"},
- {"en", "US", "United States"},
- {"en", "ZZ", "Unknown Region"},
- {"en-GB", "NL", "Netherlands"},
- // Canonical equivalents
- {"en", "UK", "United Kingdom"},
- // No region
- {"en", "pt", "Unknown Region"},
- {"en", "und", "Unknown Region"},
- // Don't introduce regions with canonicalization.
- {"en", "mo", "Unknown Region"},
- }
- for _, tt := range tests {
- t.Run(tt.dict+"/"+tt.reg, func(t *testing.T) {
- dict := language.MustParse(tt.dict)
- p := message.NewPrinter(dict)
- d := Regions(dict)
- var tag language.Tag
- if unicode.IsUpper(rune(tt.reg[0])) {
- // Region
- x := language.MustParseRegion(tt.reg)
- if n := d.Name(x); n != tt.name {
- t.Errorf("Name(%v) = %q; want %q", x, n, tt.name)
- }
- if n := p.Sprint(Region(x)); n != tt.name {
- t.Errorf("Region(%v) = %q; want %q", x, n, tt.name)
- }
- tag, _ = language.Raw.Compose(x)
- } else {
- tag = language.Raw.MustParse(tt.reg)
- }
- if n := d.Name(tag); n != tt.name {
- t.Errorf("Name(%v) = %q; want %q", tag, n, tt.name)
- }
- if n := p.Sprint(Region(tag)); n != tt.name {
- t.Errorf("Region(%v) = %q; want %q", tag, n, tt.name)
- }
- })
- }
-}
-
-func TestSelf(t *testing.T) {
- tests := []struct {
- tag string
- name string
- }{
- {"nl", "Nederlands"},
- // CLDR 30 dropped Vlaams as the word for nl-BE. It is still called
- // Flemish in English, though. TODO: check if this is a CLDR bug.
- // {"nl-BE", "Vlaams"},
- {"nl-BE", "Nederlands"},
- {"en-GB", "British English"},
- {lastLang2zu.String(), "isiZulu"},
- {firstLang2aa.String(), ""}, // not defined
- {lastLang3zza.String(), ""}, // not defined
- {firstLang3ace.String(), ""}, // not defined
- {firstTagAr001.String(), "العربية الرسمية الحديثة"},
- {"ar", "العربية"},
- {lastTagZhHant.String(), "繁體中文"},
- {"aaa", ""},
- {"zzj", ""},
- // Drop entries that are not in the requested script, even if there is
- // an entry for the language.
- {"aa-Hans", ""},
- {"af-Arab", ""},
- {"zu-Cyrl", ""},
- // Append the country name in the language of the matching language.
- {"af-NA", "Afrikaans"},
- {"zh", "中文"},
- // zh-TW should match zh-Hant instead of zh!
- {"zh-TW", "繁體中文"},
- {"zh-Hant", "繁體中文"},
- {"zh-Hans", "简体中文"},
- {"zh-Hant-TW", "繁體中文"},
- {"zh-Hans-TW", "简体中文"},
- // Take the entry for sr which has the matching script.
- // TODO: Capitalization changed as of CLDR 26, but change seems
- // arbitrary. Revisit capitalization with revision 27. See
- // http://unicode.org/cldr/trac/ticket/8051.
- {"sr", "српски"},
- // TODO: sr-ME should show up as Serbian or Montenegrin, not Serbo-
- // Croatian. This is an artifact of the current algorithm, which is the
- // way it is to have the preferred behavior for other languages such as
- // Chinese. We can hardwire this case in the table generator or package
- // code, but we first check if CLDR can be updated.
- // {"sr-ME", "Srpski"}, // Is Srpskohrvatski
- {"sr-Latn-ME", "srpskohrvatski"},
- {"sr-Cyrl-ME", "српски"},
- {"sr-NL", "српски"},
- // NOTE: kk is defined, but in Cyrillic script. For China, Arab is the
- // dominant script. We do not have data for kk-Arab and we chose to not
- // fall back in such cases.
- {"kk-CN", ""},
- }
- for i, tt := range tests {
- d := Self
- if n := d.Name(language.Raw.MustParse(tt.tag)); n != tt.name {
- t.Errorf("%d:%s: was %q; want %q", i, tt.tag, n, tt.name)
- }
- }
-}
-
-func TestEquivalence(t *testing.T) {
- testCases := []struct {
- desc string
- namer Namer
- }{
- {"Self", Self},
- {"Tags", Tags(language.Romanian)},
- {"Languages", Languages(language.Romanian)},
- {"Scripts", Scripts(language.Romanian)},
- }
- for _, tc := range testCases {
- t.Run(tc.desc, func(t *testing.T) {
- ro := tc.namer.Name(language.Raw.MustParse("ro-MD"))
- mo := tc.namer.Name(language.Raw.MustParse("mo"))
- if ro != mo {
- t.Errorf("%q != %q", ro, mo)
- }
- })
- }
-}
-
-func TestDictionaryLang(t *testing.T) {
- tests := []struct {
- d *Dictionary
- tag string
- name string
- }{
- {English, "en", "English"},
- {Portuguese, "af", "africâner"},
- {EuropeanPortuguese, "af", "africanês"},
- {English, "nl-BE", "Flemish"},
- }
- for i, test := range tests {
- tag := language.MustParse(test.tag)
- if got := test.d.Tags().Name(tag); got != test.name {
- t.Errorf("%d:%v: got %s; want %s", i, tag, got, test.name)
- }
- if base, _ := language.Compose(tag.Base()); base == tag {
- if got := test.d.Languages().Name(base); got != test.name {
- t.Errorf("%d:%v: got %s; want %s", i, tag, got, test.name)
- }
- }
- }
-}
-
-func TestDictionaryRegion(t *testing.T) {
- tests := []struct {
- d *Dictionary
- region string
- name string
- }{
- {English, "FR", "France"},
- {Portuguese, "009", "Oceania"},
- {EuropeanPortuguese, "009", "Oceânia"},
- }
- for i, test := range tests {
- tag := language.MustParseRegion(test.region)
- if got := test.d.Regions().Name(tag); got != test.name {
- t.Errorf("%d:%v: got %s; want %s", i, tag, got, test.name)
- }
- }
-}
-
-func TestDictionaryScript(t *testing.T) {
- tests := []struct {
- d *Dictionary
- script string
- name string
- }{
- {English, "Cyrl", "Cyrillic"},
- {EuropeanPortuguese, "Gujr", "guzerate"},
- }
- for i, test := range tests {
- tag := language.MustParseScript(test.script)
- if got := test.d.Scripts().Name(tag); got != test.name {
- t.Errorf("%d:%v: got %s; want %s", i, tag, got, test.name)
- }
- }
-}