github.com/graybobo/golang.org-package-offline-cache@v0.0.0-20200626051047-6608995c132f/x/text/language/coverage_test.go (about) 1 // Copyright 2014 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 language 6 7 import ( 8 "fmt" 9 "reflect" 10 "testing" 11 ) 12 13 func TestSupported(t *testing.T) { 14 // To prove the results are correct for a type, we test that the number of 15 // results is identical to the number of results on record, that all results 16 // are distinct and that all results are valid. 17 tests := map[string]int{ 18 "BaseLanguages": numLanguages, 19 "Scripts": numScripts, 20 "Regions": numRegions, 21 "Tags": 0, 22 } 23 sup := reflect.ValueOf(Supported) 24 for name, num := range tests { 25 v := sup.MethodByName(name).Call(nil)[0] 26 if n := v.Len(); n != num { 27 t.Errorf("len(%s()) was %d; want %d", name, n, num) 28 } 29 dup := make(map[string]bool) 30 for i := 0; i < v.Len(); i++ { 31 x := v.Index(i).Interface() 32 // An invalid value will either cause a crash or result in a 33 // duplicate when passed to Sprint. 34 s := fmt.Sprint(x) 35 if dup[s] { 36 t.Errorf("%s: duplicate entry %q", name, s) 37 } 38 dup[s] = true 39 } 40 if len(dup) != v.Len() { 41 t.Errorf("%s: # unique entries was %d; want %d", name, len(dup), v.Len()) 42 } 43 } 44 } 45 46 func TestNewCoverage(t *testing.T) { 47 bases := []Base{Base{0}, Base{3}, Base{7}} 48 scripts := []Script{Script{11}, Script{17}, Script{23}} 49 regions := []Region{Region{101}, Region{103}, Region{107}} 50 tags := []Tag{Make("pt"), Make("en"), Make("en-GB"), Make("en-US"), Make("pt-PT")} 51 fbases := func() []Base { return bases } 52 fscripts := func() []Script { return scripts } 53 fregions := func() []Region { return regions } 54 ftags := func() []Tag { return tags } 55 56 tests := []struct { 57 desc string 58 list []interface{} 59 bases []Base 60 scripts []Script 61 regions []Region 62 tags []Tag 63 }{ 64 { 65 desc: "empty", 66 }, 67 { 68 desc: "bases", 69 list: []interface{}{bases}, 70 bases: bases, 71 }, 72 { 73 desc: "scripts", 74 list: []interface{}{scripts}, 75 scripts: scripts, 76 }, 77 { 78 desc: "regions", 79 list: []interface{}{regions}, 80 regions: regions, 81 }, 82 { 83 desc: "bases derives from tags", 84 list: []interface{}{tags}, 85 bases: []Base{Base{_en}, Base{_pt}}, 86 tags: tags, 87 }, 88 { 89 desc: "tags and bases", 90 list: []interface{}{tags, bases}, 91 bases: bases, 92 tags: tags, 93 }, 94 { 95 desc: "fully specified", 96 list: []interface{}{tags, bases, scripts, regions}, 97 bases: bases, 98 scripts: scripts, 99 regions: regions, 100 tags: tags, 101 }, 102 { 103 desc: "bases func", 104 list: []interface{}{fbases}, 105 bases: bases, 106 }, 107 { 108 desc: "scripts func", 109 list: []interface{}{fscripts}, 110 scripts: scripts, 111 }, 112 { 113 desc: "regions func", 114 list: []interface{}{fregions}, 115 regions: regions, 116 }, 117 { 118 desc: "tags func", 119 list: []interface{}{ftags}, 120 bases: []Base{Base{_en}, Base{_pt}}, 121 tags: tags, 122 }, 123 { 124 desc: "tags and bases", 125 list: []interface{}{ftags, fbases}, 126 bases: bases, 127 tags: tags, 128 }, 129 { 130 desc: "fully specified", 131 list: []interface{}{ftags, fbases, fscripts, fregions}, 132 bases: bases, 133 scripts: scripts, 134 regions: regions, 135 tags: tags, 136 }, 137 } 138 139 for i, tt := range tests { 140 l := NewCoverage(tt.list...) 141 if a := l.BaseLanguages(); !reflect.DeepEqual(a, tt.bases) { 142 t.Errorf("%d:%s: BaseLanguages was %v; want %v", i, tt.desc, a, tt.bases) 143 } 144 if a := l.Scripts(); !reflect.DeepEqual(a, tt.scripts) { 145 t.Errorf("%d:%s: Scripts was %v; want %v", i, tt.desc, a, tt.scripts) 146 } 147 if a := l.Regions(); !reflect.DeepEqual(a, tt.regions) { 148 t.Errorf("%d:%s: Regions was %v; want %v", i, tt.desc, a, tt.regions) 149 } 150 if a := l.Tags(); !reflect.DeepEqual(a, tt.tags) { 151 t.Errorf("%d:%s: Tags was %v; want %v", i, tt.desc, a, tt.tags) 152 } 153 } 154 }