From 54d3d47daf9190275bbdaf8703b84969a4593451 Mon Sep 17 00:00:00 2001 From: Corey Hulen Date: Fri, 24 Mar 2017 23:31:34 -0700 Subject: PLT-6076 Adding viper libs for config file changes (#5871) * Adding viper libs for config file changes * Removing the old fsnotify lib * updating some missing libs --- vendor/golang.org/x/text/language/lookup_test.go | 457 +++++++++++++++++++++++ 1 file changed, 457 insertions(+) create mode 100644 vendor/golang.org/x/text/language/lookup_test.go (limited to 'vendor/golang.org/x/text/language/lookup_test.go') diff --git a/vendor/golang.org/x/text/language/lookup_test.go b/vendor/golang.org/x/text/language/lookup_test.go new file mode 100644 index 000000000..9833830c4 --- /dev/null +++ b/vendor/golang.org/x/text/language/lookup_test.go @@ -0,0 +1,457 @@ +// 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) + } + } +} -- cgit v1.2.3-1-g7c22