mirror of
https://github.com/restic/restic.git
synced 2024-08-22 04:13:23 +02:00
Among others, this updates minio-go, so that the new "eu-west-3" zone for AWS is supported.
155 lines
3.7 KiB
Go
155 lines
3.7 KiB
Go
// 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 language
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
func TestSupported(t *testing.T) {
|
|
// To prove the results are correct for a type, we test that the number of
|
|
// results is identical to the number of results on record, that all results
|
|
// are distinct and that all results are valid.
|
|
tests := map[string]int{
|
|
"BaseLanguages": numLanguages,
|
|
"Scripts": numScripts,
|
|
"Regions": numRegions,
|
|
"Tags": 0,
|
|
}
|
|
sup := reflect.ValueOf(Supported)
|
|
for name, num := range tests {
|
|
v := sup.MethodByName(name).Call(nil)[0]
|
|
if n := v.Len(); n != num {
|
|
t.Errorf("len(%s()) was %d; want %d", name, n, num)
|
|
}
|
|
dup := make(map[string]bool)
|
|
for i := 0; i < v.Len(); i++ {
|
|
x := v.Index(i).Interface()
|
|
// An invalid value will either cause a crash or result in a
|
|
// duplicate when passed to Sprint.
|
|
s := fmt.Sprint(x)
|
|
if dup[s] {
|
|
t.Errorf("%s: duplicate entry %q", name, s)
|
|
}
|
|
dup[s] = true
|
|
}
|
|
if len(dup) != v.Len() {
|
|
t.Errorf("%s: # unique entries was %d; want %d", name, len(dup), v.Len())
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestNewCoverage(t *testing.T) {
|
|
bases := []Base{Base{0}, Base{3}, Base{7}}
|
|
scripts := []Script{Script{11}, Script{17}, Script{23}}
|
|
regions := []Region{Region{101}, Region{103}, Region{107}}
|
|
tags := []Tag{Make("pt"), Make("en"), Make("en-GB"), Make("en-US"), Make("pt-PT")}
|
|
fbases := func() []Base { return bases }
|
|
fscripts := func() []Script { return scripts }
|
|
fregions := func() []Region { return regions }
|
|
ftags := func() []Tag { return tags }
|
|
|
|
tests := []struct {
|
|
desc string
|
|
list []interface{}
|
|
bases []Base
|
|
scripts []Script
|
|
regions []Region
|
|
tags []Tag
|
|
}{
|
|
{
|
|
desc: "empty",
|
|
},
|
|
{
|
|
desc: "bases",
|
|
list: []interface{}{bases},
|
|
bases: bases,
|
|
},
|
|
{
|
|
desc: "scripts",
|
|
list: []interface{}{scripts},
|
|
scripts: scripts,
|
|
},
|
|
{
|
|
desc: "regions",
|
|
list: []interface{}{regions},
|
|
regions: regions,
|
|
},
|
|
{
|
|
desc: "bases derives from tags",
|
|
list: []interface{}{tags},
|
|
bases: []Base{Base{_en}, Base{_pt}},
|
|
tags: tags,
|
|
},
|
|
{
|
|
desc: "tags and bases",
|
|
list: []interface{}{tags, bases},
|
|
bases: bases,
|
|
tags: tags,
|
|
},
|
|
{
|
|
desc: "fully specified",
|
|
list: []interface{}{tags, bases, scripts, regions},
|
|
bases: bases,
|
|
scripts: scripts,
|
|
regions: regions,
|
|
tags: tags,
|
|
},
|
|
{
|
|
desc: "bases func",
|
|
list: []interface{}{fbases},
|
|
bases: bases,
|
|
},
|
|
{
|
|
desc: "scripts func",
|
|
list: []interface{}{fscripts},
|
|
scripts: scripts,
|
|
},
|
|
{
|
|
desc: "regions func",
|
|
list: []interface{}{fregions},
|
|
regions: regions,
|
|
},
|
|
{
|
|
desc: "tags func",
|
|
list: []interface{}{ftags},
|
|
bases: []Base{Base{_en}, Base{_pt}},
|
|
tags: tags,
|
|
},
|
|
{
|
|
desc: "tags and bases",
|
|
list: []interface{}{ftags, fbases},
|
|
bases: bases,
|
|
tags: tags,
|
|
},
|
|
{
|
|
desc: "fully specified",
|
|
list: []interface{}{ftags, fbases, fscripts, fregions},
|
|
bases: bases,
|
|
scripts: scripts,
|
|
regions: regions,
|
|
tags: tags,
|
|
},
|
|
}
|
|
|
|
for i, tt := range tests {
|
|
l := NewCoverage(tt.list...)
|
|
if a := l.BaseLanguages(); !reflect.DeepEqual(a, tt.bases) {
|
|
t.Errorf("%d:%s: BaseLanguages was %v; want %v", i, tt.desc, a, tt.bases)
|
|
}
|
|
if a := l.Scripts(); !reflect.DeepEqual(a, tt.scripts) {
|
|
t.Errorf("%d:%s: Scripts was %v; want %v", i, tt.desc, a, tt.scripts)
|
|
}
|
|
if a := l.Regions(); !reflect.DeepEqual(a, tt.regions) {
|
|
t.Errorf("%d:%s: Regions was %v; want %v", i, tt.desc, a, tt.regions)
|
|
}
|
|
if a := l.Tags(); !reflect.DeepEqual(a, tt.tags) {
|
|
t.Errorf("%d:%s: Tags was %v; want %v", i, tt.desc, a, tt.tags)
|
|
}
|
|
}
|
|
}
|