Depenancy upgrades and movign to dep. (#8630)

6 files changed, 0 insertions, 1052 deletions

diff --git a/vendor/golang.org/x/text/unicode/cldr/cldr_test.go b/vendor/golang.org/x/text/unicode/cldr/cldr_test.go
deleted file mode 100644
index 951028d7e..000000000
--- a/vendor/golang.org/x/text/unicode/cldr/cldr_test.go
+++ /dev/null
@@ -1,27 +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 cldr
-
-import "testing"
-
-func TestParseDraft(t *testing.T) {
-	tests := []struct {
-		in    string
-		draft Draft
-		err   bool
-	}{
-		{"unconfirmed", Unconfirmed, false},
-		{"provisional", Provisional, false},
-		{"contributed", Contributed, false},
-		{"approved", Approved, false},
-		{"", Approved, false},
-		{"foo", Approved, true},
-	}
-	for _, tt := range tests {
-		if d, err := ParseDraft(tt.in); d != tt.draft || (err != nil) != tt.err {
-			t.Errorf("%q: was %v, %v; want %v, %v", tt.in, d, err != nil, tt.draft, tt.err)
-		}
-	}
-}
diff --git a/vendor/golang.org/x/text/unicode/cldr/collate_test.go b/vendor/golang.org/x/text/unicode/cldr/collate_test.go
deleted file mode 100644
index f6721639a..000000000
--- a/vendor/golang.org/x/text/unicode/cldr/collate_test.go
+++ /dev/null
@@ -1,275 +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 cldr
-
-import (
-	"fmt"
-	"strings"
-	"testing"
-)
-
-// A recorder implements the RuleProcessor interface, whereby its methods
-// simply record the invocations.
-type recorder struct {
-	calls []string
-}
-
-func (r *recorder) Reset(anchor string, before int) error {
-	if before > 5 {
-		return fmt.Errorf("before %d > 5", before)
-	}
-	r.calls = append(r.calls, fmt.Sprintf("R:%s-%d", anchor, before))
-	return nil
-}
-
-func (r *recorder) Insert(level int, str, context, extend string) error {
-	s := fmt.Sprintf("O:%d:%s", level, str)
-	if context != "" {
-		s += "|" + context
-	}
-	if extend != "" {
-		s += "/" + extend
-	}
-	r.calls = append(r.calls, s)
-	return nil
-}
-
-func (r *recorder) Index(id string) {
-	r.calls = append(r.calls, fmt.Sprintf("I:%s", id))
-}
-
-func (r *recorder) Error(err error) {
-	r.calls = append(r.calls, fmt.Sprintf("E:%v", err))
-}
-
-func TestRuleProcessor(t *testing.T) {
-	for _, tt := range []struct {
-		desc string
-		in   string
-		out  string
-	}{
-		{desc: "empty"},
-		{desc: "whitespace and comments only",
-			in: `
-
-
-		  		# adsfads
-# adfadf
-		`,
-		},
-		{
-			desc: "reset anchor",
-			in: `
-			& a
-			&b    #
-			&  [    before 3  ]  c
-			& [before 4] d & ee
-			& [first tertiary ignorable]
-			&'g'
-			& 	'h''h'h'h'
-			&'\u0069'  # LATIN SMALL LETTER I
-			`,
-			out: `
-			R:a-0
-			R:b-0
-			R:c-3
-			R:d-4
-			R:ee-0
-			R:<first tertiary ignorable/>-0
-			R:g-0
-			R:hhhh-0
-			R:i-0
-			`,
-		},
-		{
-			desc: "ordering",
-			in: `
-			& 0
-			< 1 <<''2#
-<<<			3'3''33'3#
-			<<<<4
-			= 5 << 6 | s
-			<<<< 7 / z
-			<< 8'' | s / ch
-			`,
-			out: `
-			R:0-0
-			O:1:1
-			O:2:'2
-			O:3:33333
-			O:4:4
-			O:5:5
-			O:2:6|s
-			O:4:7/z
-			O:2:8'|s/ch
-			`,
-		},
-		{
-			desc: "index",
-			in:   "< '\ufdd0'A",
-			out:  "I:A",
-		},
-		{
-			desc: "sequence",
-			in: `
-			& 0
-			<<* 1234
-			<* a-cde-f
-			=* q-q
-			`,
-			out: `
-			R:0-0
-			O:2:1
-			O:2:2
-			O:2:3
-			O:2:4
-			O:1:a
-			O:1:b
-			O:1:c
-			O:1:d
-			O:1:e
-			O:1:f
-			O:5:q
-			`,
-		},
-		{
-			desc: "compact",
-			in:   "&B<t<<<T<s<<<S<e<<<E",
-			out: `
-			R:B-0
-			O:1:t
-			O:3:T
-			O:1:s
-			O:3:S
-			O:1:e
-			O:3:E
-			`,
-		},
-		{
-			desc: "err operator",
-			in:   "a",
-			out:  "E:1: illegal operator 'a'",
-		},
-		{
-			desc: "err line number",
-			in: `& a
-			<< b
-			a`,
-			out: `
-			R:a-0
-			O:2:b
-			E:3: illegal operator 'a'`,
-		},
-		{
-			desc: "err empty anchor",
-			in: " &			",
-			out: "E:1: missing string",
-		},
-		{
-			desc: "err anchor invalid special 1",
-			in: " &	[ foo ",
-			out: "E:1: unmatched bracket",
-		},
-		{
-			desc: "err anchor invalid special 2",
-			in:   "&[",
-			out:  "E:1: unmatched bracket",
-		},
-		{
-			desc: "err anchor invalid before 1",
-			in:   "&[before a]",
-			out:  `E:1: strconv.ParseUint: parsing "a": invalid syntax`,
-		},
-		{
-			desc: "err anchor invalid before 2",
-			in:   "&[before 12]",
-			out:  `E:1: strconv.ParseUint: parsing "12": value out of range`,
-		},
-		{
-			desc: "err anchor invalid before 3",
-			in:   "&[before 2]",
-			out:  "E:1: missing string",
-		},
-		{
-			desc: "err anchor invalid before 4",
-			in:   "&[before 6] a",
-			out:  "E:1: before 6 > 5",
-		},
-		{
-			desc: "err empty order",
-			in:   " < ",
-			out:  "E:1: missing string",
-		},
-		{
-			desc: "err empty identity",
-			in:   " = ",
-			out:  "E:1: missing string",
-		},
-		{
-			desc: "err empty context",
-			in:   " < a |  ",
-			out:  "E:1: missing string after context",
-		},
-		{
-			desc: "err empty extend",
-			in:   " < a /  ",
-			out:  "E:1: missing string after extension",
-		},
-		{
-			desc: "err empty sequence",
-			in:   " <* ",
-			out:  "E:1: empty sequence",
-		},
-		{
-			desc: "err sequence 1",
-			in:   " <* -a",
-			out:  "E:1: range without starter value",
-		},
-		{
-			desc: "err sequence 3",
-			in:   " <* a-a-b",
-			out: `O:1:a
-			E:1: range without starter value
-			`,
-		},
-		{
-			desc: "err sequence 3",
-			in:   " <* b-a",
-			out: `O:1:b
-			E:1: invalid range 'b'-'a'
-			`,
-		},
-		{
-			desc: "err unmatched quote",
-			in:   " < 'b",
-			out: ` E:1: unmatched single quote
-			`,
-		},
-	} {
-		rec := &recorder{}
-		err := Collation{
-			Cr: []*Common{
-				{hidden: hidden{CharData: tt.in}},
-			},
-		}.Process(rec)
-		if err != nil {
-			rec.Error(err)
-		}
-		got := rec.calls
-		want := strings.Split(strings.TrimSpace(tt.out), "\n")
-		if tt.out == "" {
-			want = nil
-		}
-		if len(got) != len(want) {
-			t.Errorf("%s: nResults: got %d; want %d", tt.desc, len(got), len(want))
-			continue
-		}
-		for i, g := range got {
-			if want := strings.TrimSpace(want[i]); g != want {
-				t.Errorf("%s:%d: got %q; want %q", tt.desc, i, g, want)
-			}
-		}
-	}
-}
diff --git a/vendor/golang.org/x/text/unicode/cldr/data_test.go b/vendor/golang.org/x/text/unicode/cldr/data_test.go
deleted file mode 100644
index 166218962..000000000
--- a/vendor/golang.org/x/text/unicode/cldr/data_test.go
+++ /dev/null
@@ -1,186 +0,0 @@
-// 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 cldr
-
-// This file contains test data.
-
-import (
-	"io"
-	"strings"
-)
-
-type testLoader struct {
-}
-
-func (t testLoader) Len() int {
-	return len(testFiles)
-}
-
-func (t testLoader) Path(i int) string {
-	return testPaths[i]
-}
-
-func (t testLoader) Reader(i int) (io.ReadCloser, error) {
-	return &reader{*strings.NewReader(testFiles[i])}, nil
-}
-
-// reader adds a dummy Close method to strings.Reader so that it
-// satisfies the io.ReadCloser interface.
-type reader struct {
-	strings.Reader
-}
-
-func (r reader) Close() error {
-	return nil
-}
-
-var (
-	testFiles = []string{de_xml, gsw_xml, root_xml}
-	testPaths = []string{
-		"common/main/de.xml",
-		"common/main/gsw.xml",
-		"common/main/root.xml",
-	}
-)
-
-var root_xml = `<?xml version="1.0" encoding="UTF-8" ?>
-<!DOCTYPE ldml SYSTEM "../../common/dtd/ldml.dtd">
-<ldml>
-	<identity>
-		<language type="root"/>
-		<generation date="now"/>
-	</identity>
-	<characters>
-		<exemplarCharacters>[]</exemplarCharacters>
-		<exemplarCharacters type="auxiliary">[]</exemplarCharacters>
-		<exemplarCharacters type="punctuation">[\- ‐ – — … ' ‘ ‚ &quot; “ „ \&amp; #]</exemplarCharacters>
-		<ellipsis type="final">{0}…</ellipsis>
-		<ellipsis type="initial">…{0}</ellipsis>
-		<moreInformation>?</moreInformation>
-	</characters>
-	<dates>
-		<calendars>
-			<default choice="gregorian"/>
-			<calendar type="buddhist">
-				<months>
-					<alias source="locale" path="../../calendar[@type='gregorian']/months"/>
-				</months>
-			</calendar>
-			<calendar type="chinese">
-				<months>
-					<alias source="locale" path="../../calendar[@type='gregorian']/months"/>
-				</months>
-			</calendar>
-			<calendar type="gregorian">
-				<months>
-					<default choice="format"/>
-					<monthContext type="format">
-						<default choice="wide"/>
-						<monthWidth type="narrow">
-							<alias source="locale" path="../../monthContext[@type='stand-alone']/monthWidth[@type='narrow']"/>
-						</monthWidth>
-						<monthWidth type="wide">
-							<month type="1">11</month>
-							<month type="2">22</month>
-							<month type="3">33</month>
-							<month type="4">44</month>
-						</monthWidth>
-					</monthContext>
-					<monthContext type="stand-alone">
-						<monthWidth type="narrow">
-							<month type="1">1</month>
-							<month type="2">2</month>
-							<month type="3">3</month>
-							<month type="4">4</month>
-						</monthWidth>
-						<monthWidth type="wide">
-							<alias source="locale" path="../../monthContext[@type='format']/monthWidth[@type='wide']"/>
-						</monthWidth>
-					</monthContext>
-				</months>
-			</calendar>
-		</calendars>
-	</dates>
-</ldml>
-`
-
-var de_xml = `<?xml version="1.0" encoding="UTF-8" ?>
-<!DOCTYPE ldml SYSTEM "../../common/dtd/ldml.dtd">
-<ldml>
-	<identity>
-		<language type="de"/>
-	</identity>
-	<characters>
-		<exemplarCharacters>[a ä b c d e ö p q r s ß t u ü v w x y z]</exemplarCharacters>
-		<exemplarCharacters type="auxiliary">[á à ă]</exemplarCharacters>
-		<exemplarCharacters type="index">[A B C D E F G H Z]</exemplarCharacters>
-		<ellipsis type="final">{0} …</ellipsis>
-		<ellipsis type="initial">… {0}</ellipsis>
-		<moreInformation>?</moreInformation>
-		<stopwords>
-			<stopwordList type="collation" draft="provisional">der die das</stopwordList>
-		</stopwords>
-	</characters>
-	<dates>
-		<calendars>
-			<calendar type="buddhist">
-				<months>
-					<monthContext type="format">
-						<monthWidth type="narrow">
-							<month type="3">BBB</month>
-						</monthWidth>
-						<monthWidth type="wide">
-							<month type="3">bbb</month>
-						</monthWidth>
-					</monthContext>
-				</months>
-			</calendar>
-			<calendar type="gregorian">
-				<months>
-					<monthContext type="format">
-						<monthWidth type="narrow">
-							<month type="3">M</month>
-							<month type="4">A</month>
-						</monthWidth>
-						<monthWidth type="wide">
-							<month type="3">Maerz</month>
-							<month type="4">April</month>
-							<month type="5">Mai</month>
-						</monthWidth>
-					</monthContext>
-					<monthContext type="stand-alone">
-						<monthWidth type="narrow">
-							<month type="3">m</month>
-							<month type="5">m</month>
-						</monthWidth>
-						<monthWidth type="wide">
-							<month type="4">april</month>
-							<month type="5">mai</month>
-						</monthWidth>
-					</monthContext>
-				</months>
-			</calendar>
-		</calendars>
-	</dates>
-	<posix>
-		<messages>
-			<yesstr>yes:y</yesstr>
-			<nostr>no:n</nostr>
-		</messages>
-	</posix>
-</ldml>
-`
-
-var gsw_xml = `<?xml version="1.0" encoding="UTF-8" ?>
-<!DOCTYPE ldml SYSTEM "../../common/dtd/ldml.dtd">
-<ldml>
-	<identity>
-		<language type="gsw"/>
-	</identity>
-	<posix>
-		<alias source="de" path="//ldml/posix"/>
-	</posix>
-</ldml>
-`
diff --git a/vendor/golang.org/x/text/unicode/cldr/examples_test.go b/vendor/golang.org/x/text/unicode/cldr/examples_test.go
deleted file mode 100644
index 1a69b0073..000000000
--- a/vendor/golang.org/x/text/unicode/cldr/examples_test.go
+++ /dev/null
@@ -1,21 +0,0 @@
-package cldr_test
-
-import (
-	"fmt"
-
-	"golang.org/x/text/unicode/cldr"
-)
-
-func ExampleSlice() {
-	var dr *cldr.CLDR // assume this is initialized
-
-	x, _ := dr.LDML("en")
-	cs := x.Collations.Collation
-	// remove all but the default
-	cldr.MakeSlice(&cs).Filter(func(e cldr.Elem) bool {
-		return e.GetCommon().Type != x.Collations.Default()
-	})
-	for i, c := range cs {
-		fmt.Println(i, c.Type)
-	}
-}
diff --git a/vendor/golang.org/x/text/unicode/cldr/resolve_test.go b/vendor/golang.org/x/text/unicode/cldr/resolve_test.go
deleted file mode 100644
index 3d8edaec8..000000000
--- a/vendor/golang.org/x/text/unicode/cldr/resolve_test.go
+++ /dev/null
@@ -1,368 +0,0 @@
-package cldr
-
-import (
-	"fmt"
-	"log"
-	"reflect"
-	"testing"
-)
-
-func failOnError(err error) {
-	if err != nil {
-		log.Panic(err)
-	}
-}
-
-func data() *CLDR {
-	d := Decoder{}
-	data, err := d.Decode(testLoader{})
-	failOnError(err)
-	return data
-}
-
-type h struct {
-	A string `xml:"ha,attr"`
-	E string `xml:"he"`
-	D string `xml:",chardata"`
-	X string
-}
-
-type fieldTest struct {
-	Common
-	To  string `xml:"to,attr"`
-	Key string `xml:"key,attr"`
-	E   string `xml:"e"`
-	D   string `xml:",chardata"`
-	X   string
-	h
-}
-
-var testStruct = fieldTest{
-	Common: Common{
-		name: "mapping", // exclude "type" as distinguishing attribute
-		Type: "foo",
-		Alt:  "foo",
-	},
-	To:  "nyc",
-	Key: "k",
-	E:   "E",
-	D:   "D",
-	h: h{
-		A: "A",
-		E: "E",
-		D: "D",
-	},
-}
-
-func TestIter(t *testing.T) {
-	tests := map[string]string{
-		"Type":  "foo",
-		"Alt":   "foo",
-		"To":    "nyc",
-		"A":     "A",
-		"Alias": "<nil>",
-	}
-	k := 0
-	for i := iter(reflect.ValueOf(testStruct)); !i.done(); i.next() {
-		v := i.value()
-		if v.Kind() == reflect.Ptr && v.Elem().Kind() == reflect.String {
-			v = v.Elem()
-		}
-		name := i.field().Name
-		if w, ok := tests[name]; ok {
-			s := fmt.Sprint(v.Interface())
-			if w != s {
-				t.Errorf("value: found %q; want %q", w, s)
-			}
-			delete(tests, name)
-		}
-		k++
-	}
-	if len(tests) != 0 {
-		t.Errorf("missing fields: %v", tests)
-	}
-}
-
-func TestFindField(t *testing.T) {
-	tests := []struct {
-		name, val string
-		exist     bool
-	}{
-		{"type", "foo", true},
-		{"alt", "foo", true},
-		{"to", "nyc", true},
-		{"he", "E", true},
-		{"q", "", false},
-	}
-	vf := reflect.ValueOf(testStruct)
-	for i, tt := range tests {
-		v, err := findField(vf, tt.name)
-		if (err == nil) != tt.exist {
-			t.Errorf("%d: field %q present is %v; want %v", i, tt.name, err == nil, tt.exist)
-		} else if tt.exist {
-			if v.Kind() == reflect.Ptr {
-				if v.IsNil() {
-					continue
-				}
-				v = v.Elem()
-			}
-			if v.String() != tt.val {
-				t.Errorf("%d: found value %q; want %q", i, v.String(), tt.val)
-			}
-		}
-	}
-}
-
-var keyTests = []struct {
-	exclude []string
-	key     string
-}{
-	{[]string{}, "alt=foo;key=k;to=nyc"},
-	{[]string{"type"}, "alt=foo;key=k;to=nyc"},
-	{[]string{"choice"}, "alt=foo;key=k;to=nyc"},
-	{[]string{"alt"}, "key=k;to=nyc"},
-	{[]string{"a"}, "alt=foo;key=k;to=nyc"},
-	{[]string{"to"}, "alt=foo;key=k"},
-	{[]string{"alt", "to"}, "key=k"},
-	{[]string{"alt", "to", "key"}, ""},
-}
-
-func TestAttrKey(t *testing.T) {
-	v := reflect.ValueOf(&testStruct)
-	for i, tt := range keyTests {
-		key := attrKey(v, tt.exclude...)
-		if key != tt.key {
-			t.Errorf("%d: found %q, want %q", i, key, tt.key)
-		}
-	}
-}
-
-func TestKey(t *testing.T) {
-	for i, tt := range keyTests {
-		key := Key(&testStruct, tt.exclude...)
-		if key != tt.key {
-			t.Errorf("%d: found %q, want %q", i, key, tt.key)
-		}
-	}
-}
-
-func testEnclosing(t *testing.T, x *LDML, name string) {
-	eq := func(a, b Elem, i int) {
-		for ; i > 0; i-- {
-			b = b.enclosing()
-		}
-		if a != b {
-			t.Errorf("%s: found path %q, want %q", name, getPath(a), getPath(b))
-		}
-	}
-	eq(x, x, 0)
-	eq(x, x.Identity, 1)
-	eq(x, x.Dates.Calendars, 2)
-	eq(x, x.Dates.Calendars.Calendar[0], 3)
-	eq(x, x.Dates.Calendars.Calendar[1], 3)
-	//eq(x, x.Dates.Calendars.Calendar[0].Months, 4)
-	eq(x, x.Dates.Calendars.Calendar[1].Months, 4)
-}
-
-func TestEnclosing(t *testing.T) {
-	testEnclosing(t, data().RawLDML("de"), "enclosing-raw")
-	de, _ := data().LDML("de")
-	testEnclosing(t, de, "enclosing")
-}
-
-func TestDeepCopy(t *testing.T) {
-	eq := func(have, want string) {
-		if have != want {
-			t.Errorf("found %q; want %q", have, want)
-		}
-	}
-	x, _ := data().LDML("de")
-	vc := deepCopy(reflect.ValueOf(x))
-	c := vc.Interface().(*LDML)
-	linkEnclosing(nil, c)
-	if x == c {
-		t.Errorf("did not copy")
-	}
-
-	eq(c.name, "ldml")
-	eq(c.Dates.name, "dates")
-	testEnclosing(t, c, "deepCopy")
-}
-
-type getTest struct {
-	loc     string
-	path    string
-	field   string // used in combination with length
-	data    string
-	altData string // used for buddhist calendar if value != ""
-	typ     string
-	length  int
-	missing bool
-}
-
-const (
-	budMon = "dates/calendars/calendar[@type='buddhist']/months/"
-	chnMon = "dates/calendars/calendar[@type='chinese']/months/"
-	greMon = "dates/calendars/calendar[@type='gregorian']/months/"
-)
-
-func monthVal(path, context, width string, month int) string {
-	const format = "%s/monthContext[@type='%s']/monthWidth[@type='%s']/month[@type='%d']"
-	return fmt.Sprintf(format, path, context, width, month)
-}
-
-var rootGetTests = []getTest{
-	{loc: "root", path: "identity/language", typ: "root"},
-	{loc: "root", path: "characters/moreInformation", data: "?"},
-	{loc: "root", path: "characters", field: "exemplarCharacters", length: 3},
-	{loc: "root", path: greMon, field: "monthContext", length: 2},
-	{loc: "root", path: greMon + "monthContext[@type='format']/monthWidth[@type='narrow']", field: "month", length: 4},
-	{loc: "root", path: greMon + "monthContext[@type='stand-alone']/monthWidth[@type='wide']", field: "month", length: 4},
-	// unescaping character data
-	{loc: "root", path: "characters/exemplarCharacters[@type='punctuation']", data: `[\- ‐ – — … ' ‘ ‚ " “ „ \& #]`},
-	// default resolution
-	{loc: "root", path: "dates/calendars/calendar", typ: "gregorian"},
-	// alias resolution
-	{loc: "root", path: budMon, field: "monthContext", length: 2},
-	// crossing but non-circular alias resolution
-	{loc: "root", path: budMon + "monthContext[@type='format']/monthWidth[@type='narrow']", field: "month", length: 4},
-	{loc: "root", path: budMon + "monthContext[@type='stand-alone']/monthWidth[@type='wide']", field: "month", length: 4},
-	{loc: "root", path: monthVal(greMon, "format", "wide", 1), data: "11"},
-	{loc: "root", path: monthVal(greMon, "format", "narrow", 2), data: "2"},
-	{loc: "root", path: monthVal(greMon, "stand-alone", "wide", 3), data: "33"},
-	{loc: "root", path: monthVal(greMon, "stand-alone", "narrow", 4), data: "4"},
-	{loc: "root", path: monthVal(budMon, "format", "wide", 1), data: "11"},
-	{loc: "root", path: monthVal(budMon, "format", "narrow", 2), data: "2"},
-	{loc: "root", path: monthVal(budMon, "stand-alone", "wide", 3), data: "33"},
-	{loc: "root", path: monthVal(budMon, "stand-alone", "narrow", 4), data: "4"},
-}
-
-// 19
-var deGetTests = []getTest{
-	{loc: "de", path: "identity/language", typ: "de"},
-	{loc: "de", path: "posix", length: 2},
-	{loc: "de", path: "characters", field: "exemplarCharacters", length: 4},
-	{loc: "de", path: "characters/exemplarCharacters[@type='auxiliary']", data: `[á à ă]`},
-	// identity is a blocking element, so de should not inherit generation from root.
-	{loc: "de", path: "identity/generation", missing: true},
-	// default resolution
-	{loc: "root", path: "dates/calendars/calendar", typ: "gregorian"},
-
-	// absolute path alias resolution
-	{loc: "gsw", path: "posix", field: "messages", length: 1},
-	{loc: "gsw", path: "posix/messages/yesstr", data: "yes:y"},
-}
-
-// 27(greMon) - 52(budMon) - 77(chnMon)
-func calGetTests(s string) []getTest {
-	tests := []getTest{
-		{loc: "de", path: s, length: 2},
-		{loc: "de", path: s + "monthContext[@type='format']/monthWidth[@type='wide']", field: "month", length: 5},
-		{loc: "de", path: monthVal(s, "format", "wide", 1), data: "11"},
-		{loc: "de", path: monthVal(s, "format", "wide", 2), data: "22"},
-		{loc: "de", path: monthVal(s, "format", "wide", 3), data: "Maerz", altData: "bbb"},
-		{loc: "de", path: monthVal(s, "format", "wide", 4), data: "April"},
-		{loc: "de", path: monthVal(s, "format", "wide", 5), data: "Mai"},
-
-		{loc: "de", path: s + "monthContext[@type='format']/monthWidth[@type='narrow']", field: "month", length: 5},
-		{loc: "de", path: monthVal(s, "format", "narrow", 1), data: "1"},
-		{loc: "de", path: monthVal(s, "format", "narrow", 2), data: "2"},
-		{loc: "de", path: monthVal(s, "format", "narrow", 3), data: "M", altData: "BBB"},
-		{loc: "de", path: monthVal(s, "format", "narrow", 4), data: "A"},
-		{loc: "de", path: monthVal(s, "format", "narrow", 5), data: "m"},
-
-		{loc: "de", path: s + "monthContext[@type='stand-alone']/monthWidth[@type='wide']", field: "month", length: 5},
-		{loc: "de", path: monthVal(s, "stand-alone", "wide", 1), data: "11"},
-		{loc: "de", path: monthVal(s, "stand-alone", "wide", 2), data: "22"},
-		{loc: "de", path: monthVal(s, "stand-alone", "wide", 3), data: "Maerz", altData: "bbb"},
-		{loc: "de", path: monthVal(s, "stand-alone", "wide", 4), data: "april"},
-		{loc: "de", path: monthVal(s, "stand-alone", "wide", 5), data: "mai"},
-
-		{loc: "de", path: s + "monthContext[@type='stand-alone']/monthWidth[@type='narrow']", field: "month", length: 5},
-		{loc: "de", path: monthVal(s, "stand-alone", "narrow", 1), data: "1"},
-		{loc: "de", path: monthVal(s, "stand-alone", "narrow", 2), data: "2"},
-		{loc: "de", path: monthVal(s, "stand-alone", "narrow", 3), data: "m"},
-		{loc: "de", path: monthVal(s, "stand-alone", "narrow", 4), data: "4"},
-		{loc: "de", path: monthVal(s, "stand-alone", "narrow", 5), data: "m"},
-	}
-	if s == budMon {
-		for i, t := range tests {
-			if t.altData != "" {
-				tests[i].data = t.altData
-			}
-		}
-	}
-	return tests
-}
-
-var getTests = append(rootGetTests,
-	append(deGetTests,
-		append(calGetTests(greMon),
-			append(calGetTests(budMon),
-				calGetTests(chnMon)...)...)...)...)
-
-func TestPath(t *testing.T) {
-	d := data()
-	for i, tt := range getTests {
-		x, _ := d.LDML(tt.loc)
-		e, err := walkXPath(x, tt.path)
-		if err != nil {
-			if !tt.missing {
-				t.Errorf("%d:error: %v %v", i, err, tt.missing)
-			}
-			continue
-		}
-		if tt.missing {
-			t.Errorf("%d: missing is %v; want %v", i, e == nil, tt.missing)
-			continue
-		}
-		if tt.data != "" && e.GetCommon().Data() != tt.data {
-			t.Errorf("%d: data is %v; want %v", i, e.GetCommon().Data(), tt.data)
-			continue
-		}
-		if tt.typ != "" && e.GetCommon().Type != tt.typ {
-			t.Errorf("%d: type is %v; want %v", i, e.GetCommon().Type, tt.typ)
-			continue
-		}
-		if tt.field != "" {
-			slice, _ := findField(reflect.ValueOf(e), tt.field)
-			if slice.Len() != tt.length {
-				t.Errorf("%d: length is %v; want %v", i, slice.Len(), tt.length)
-				continue
-			}
-		}
-	}
-}
-
-func TestGet(t *testing.T) {
-	d := data()
-	for i, tt := range getTests {
-		x, _ := d.LDML(tt.loc)
-		e, err := Get(x, tt.path)
-		if err != nil {
-			if !tt.missing {
-				t.Errorf("%d:error: %v %v", i, err, tt.missing)
-			}
-			continue
-		}
-		if tt.missing {
-			t.Errorf("%d: missing is %v; want %v", i, e == nil, tt.missing)
-			continue
-		}
-		if tt.data != "" && e.GetCommon().Data() != tt.data {
-			t.Errorf("%d: data is %v; want %v", i, e.GetCommon().Data(), tt.data)
-			continue
-		}
-		if tt.typ != "" && e.GetCommon().Type != tt.typ {
-			t.Errorf("%d: type is %v; want %v", i, e.GetCommon().Type, tt.typ)
-			continue
-		}
-		if tt.field != "" {
-			slice, _ := findField(reflect.ValueOf(e), tt.field)
-			if slice.Len() != tt.length {
-				t.Errorf("%d: length is %v; want %v", i, slice.Len(), tt.length)
-				continue
-			}
-		}
-	}
-}
diff --git a/vendor/golang.org/x/text/unicode/cldr/slice_test.go b/vendor/golang.org/x/text/unicode/cldr/slice_test.go
deleted file mode 100644
index 3d487d3bd..000000000
--- a/vendor/golang.org/x/text/unicode/cldr/slice_test.go
+++ /dev/null
@@ -1,175 +0,0 @@
-// 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 cldr
-
-import (
-	"reflect"
-	"testing"
-)
-
-type testSlice []*Common
-
-func mkElem(alt, typ, ref string) *Common {
-	return &Common{
-		Type:      typ,
-		Reference: ref,
-		Alt:       alt,
-	}
-}
-
-var (
-	testSlice1 = testSlice{
-		mkElem("1", "a", "i.a"),
-		mkElem("1", "b", "i.b"),
-		mkElem("1", "c", "i.c"),
-		mkElem("2", "b", "ii"),
-		mkElem("3", "c", "iii"),
-		mkElem("4", "a", "iv.a"),
-		mkElem("4", "d", "iv.d"),
-	}
-	testSliceE = testSlice{}
-)
-
-func panics(f func()) (panics bool) {
-	defer func() {
-		if err := recover(); err != nil {
-			panics = true
-		}
-	}()
-	f()
-	return panics
-}
-
-func TestMakeSlice(t *testing.T) {
-	foo := 1
-	bar := []int{}
-	tests := []struct {
-		i      interface{}
-		panics bool
-		err    string
-	}{
-		{&foo, true, "should panic when passed a pointer to the wrong type"},
-		{&bar, true, "should panic when slice element of the wrong type"},
-		{testSlice1, true, "should panic when passed a slice"},
-		{&testSlice1, false, "should not panic"},
-	}
-	for i, tt := range tests {
-		if panics(func() { MakeSlice(tt.i) }) != tt.panics {
-			t.Errorf("%d: %s", i, tt.err)
-		}
-	}
-}
-
-var anyOfTests = []struct {
-	sl     testSlice
-	values []string
-	n      int
-}{
-	{testSliceE, []string{}, 0},
-	{testSliceE, []string{"1", "2", "3"}, 0},
-	{testSlice1, []string{}, 0},
-	{testSlice1, []string{"1"}, 3},
-	{testSlice1, []string{"2"}, 1},
-	{testSlice1, []string{"5"}, 0},
-	{testSlice1, []string{"1", "2", "3"}, 5},
-}
-
-func TestSelectAnyOf(t *testing.T) {
-	for i, tt := range anyOfTests {
-		sl := tt.sl
-		s := MakeSlice(&sl)
-		s.SelectAnyOf("alt", tt.values...)
-		if len(sl) != tt.n {
-			t.Errorf("%d: found len == %d; want %d", i, len(sl), tt.n)
-		}
-	}
-	sl := testSlice1
-	s := MakeSlice(&sl)
-	if !panics(func() { s.SelectAnyOf("foo") }) {
-		t.Errorf("should panic on non-existing attribute")
-	}
-}
-
-func TestFilter(t *testing.T) {
-	for i, tt := range anyOfTests {
-		sl := tt.sl
-		s := MakeSlice(&sl)
-		s.Filter(func(e Elem) bool {
-			v, _ := findField(reflect.ValueOf(e), "alt")
-			return in(tt.values, v.String())
-		})
-		if len(sl) != tt.n {
-			t.Errorf("%d: found len == %d; want %d", i, len(sl), tt.n)
-		}
-	}
-}
-
-func TestGroup(t *testing.T) {
-	f := func(excl ...string) func(Elem) string {
-		return func(e Elem) string {
-			return Key(e, excl...)
-		}
-	}
-	tests := []struct {
-		sl   testSlice
-		f    func(Elem) string
-		lens []int
-	}{
-		{testSliceE, f(), []int{}},
-		{testSlice1, f(), []int{1, 1, 1, 1, 1, 1, 1}},
-		{testSlice1, f("type"), []int{3, 1, 1, 2}},
-		{testSlice1, f("alt"), []int{2, 2, 2, 1}},
-		{testSlice1, f("alt", "type"), []int{7}},
-		{testSlice1, f("alt", "type"), []int{7}},
-	}
-	for i, tt := range tests {
-		sl := tt.sl
-		s := MakeSlice(&sl)
-		g := s.Group(tt.f)
-		if len(tt.lens) != len(g) {
-			t.Errorf("%d: found %d; want %d", i, len(g), len(tt.lens))
-			continue
-		}
-		for j, v := range tt.lens {
-			if n := g[j].Value().Len(); n != v {
-				t.Errorf("%d: found %d for length of group %d; want %d", i, n, j, v)
-			}
-		}
-	}
-}
-
-func TestSelectOnePerGroup(t *testing.T) {
-	tests := []struct {
-		sl     testSlice
-		attr   string
-		values []string
-		refs   []string
-	}{
-		{testSliceE, "alt", []string{"1"}, []string{}},
-		{testSliceE, "type", []string{"a"}, []string{}},
-		{testSlice1, "alt", []string{"2", "3", "1"}, []string{"i.a", "ii", "iii"}},
-		{testSlice1, "alt", []string{"1", "4"}, []string{"i.a", "i.b", "i.c", "iv.d"}},
-		{testSlice1, "type", []string{"c", "d"}, []string{"i.c", "iii", "iv.d"}},
-	}
-	for i, tt := range tests {
-		sl := tt.sl
-		s := MakeSlice(&sl)
-		s.SelectOnePerGroup(tt.attr, tt.values)
-		if len(sl) != len(tt.refs) {
-			t.Errorf("%d: found result length %d; want %d", i, len(sl), len(tt.refs))
-			continue
-		}
-		for j, e := range sl {
-			if tt.refs[j] != e.Reference {
-				t.Errorf("%d:%d found %s; want %s", i, j, e.Reference, tt.refs[i])
-			}
-		}
-	}
-	sl := testSlice1
-	s := MakeSlice(&sl)
-	if !panics(func() { s.SelectOnePerGroup("foo", nil) }) {
-		t.Errorf("should panic on non-existing attribute")
-	}
-}