go.mod: switch to modules for dependency management

Godep is long deprecated and modules is the future.
Updating dependencies with godep is painful and non-transparent.
This will hopefully help to create custom golangci-lint linters.
The change was created with:

go mod init
rm -rf vendor
go mod vendor

Fixes #1247

8 files changed, 9 insertions, 882 deletions

diff --git a/vendor/github.com/google/go-cmp/cmp/internal/testprotos/protos.go b/vendor/github.com/google/go-cmp/cmp/internal/testprotos/protos.go
deleted file mode 100644
index 120c8b0e8..000000000
--- a/vendor/github.com/google/go-cmp/cmp/internal/testprotos/protos.go
+++ /dev/null
@@ -1,116 +0,0 @@
-// Copyright 2017, 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.md file.
-
-package testprotos
-
-func Equal(x, y Message) bool {
-	if x == nil || y == nil {
-		return x == nil && y == nil
-	}
-	return x.String() == y.String()
-}
-
-type Message interface {
-	Proto()
-	String() string
-}
-
-type proto interface {
-	Proto()
-}
-
-type notComparable struct {
-	unexportedField func()
-}
-
-type Stringer struct{ X string }
-
-func (s *Stringer) String() string { return s.X }
-
-// Project1 protocol buffers
-type (
-	Eagle_States         int
-	Eagle_MissingCalls   int
-	Dreamer_States       int
-	Dreamer_MissingCalls int
-	Slap_States          int
-	Goat_States          int
-	Donkey_States        int
-	SummerType           int
-
-	Eagle struct {
-		proto
-		notComparable
-		Stringer
-	}
-	Dreamer struct {
-		proto
-		notComparable
-		Stringer
-	}
-	Slap struct {
-		proto
-		notComparable
-		Stringer
-	}
-	Goat struct {
-		proto
-		notComparable
-		Stringer
-	}
-	Donkey struct {
-		proto
-		notComparable
-		Stringer
-	}
-)
-
-// Project2 protocol buffers
-type (
-	Germ struct {
-		proto
-		notComparable
-		Stringer
-	}
-	Dish struct {
-		proto
-		notComparable
-		Stringer
-	}
-)
-
-// Project3 protocol buffers
-type (
-	Dirt struct {
-		proto
-		notComparable
-		Stringer
-	}
-	Wizard struct {
-		proto
-		notComparable
-		Stringer
-	}
-	Sadistic struct {
-		proto
-		notComparable
-		Stringer
-	}
-)
-
-// Project4 protocol buffers
-type (
-	HoneyStatus int
-	PoisonType  int
-	MetaData    struct {
-		proto
-		notComparable
-		Stringer
-	}
-	Restrictions struct {
-		proto
-		notComparable
-		Stringer
-	}
-)
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/teststructs/project1.go b/vendor/github.com/google/go-cmp/cmp/internal/teststructs/project1.go
deleted file mode 100644
index 1999e38fd..000000000
--- a/vendor/github.com/google/go-cmp/cmp/internal/teststructs/project1.go
+++ /dev/null
@@ -1,267 +0,0 @@
-// Copyright 2017, 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.md file.
-
-package teststructs
-
-import (
-	"time"
-
-	pb "github.com/google/go-cmp/cmp/internal/testprotos"
-)
-
-// This is an sanitized example of equality from a real use-case.
-// The original equality function was as follows:
-/*
-func equalEagle(x, y Eagle) bool {
-	if x.Name != y.Name &&
-		!reflect.DeepEqual(x.Hounds, y.Hounds) &&
-		x.Desc != y.Desc &&
-		x.DescLong != y.DescLong &&
-		x.Prong != y.Prong &&
-		x.StateGoverner != y.StateGoverner &&
-		x.PrankRating != y.PrankRating &&
-		x.FunnyPrank != y.FunnyPrank &&
-		!pb.Equal(x.Immutable.Proto(), y.Immutable.Proto()) {
-		return false
-	}
-
-	if len(x.Dreamers) != len(y.Dreamers) {
-		return false
-	}
-	for i := range x.Dreamers {
-		if !equalDreamer(x.Dreamers[i], y.Dreamers[i]) {
-			return false
-		}
-	}
-	if len(x.Slaps) != len(y.Slaps) {
-		return false
-	}
-	for i := range x.Slaps {
-		if !equalSlap(x.Slaps[i], y.Slaps[i]) {
-			return false
-		}
-	}
-	return true
-}
-func equalDreamer(x, y Dreamer) bool {
-	if x.Name != y.Name ||
-		x.Desc != y.Desc ||
-		x.DescLong != y.DescLong ||
-		x.ContSlapsInterval != y.ContSlapsInterval ||
-		x.Ornamental != y.Ornamental ||
-		x.Amoeba != y.Amoeba ||
-		x.Heroes != y.Heroes ||
-		x.FloppyDisk != y.FloppyDisk ||
-		x.MightiestDuck != y.MightiestDuck ||
-		x.FunnyPrank != y.FunnyPrank ||
-		!pb.Equal(x.Immutable.Proto(), y.Immutable.Proto()) {
-
-		return false
-	}
-	if len(x.Animal) != len(y.Animal) {
-		return false
-	}
-	for i := range x.Animal {
-		vx := x.Animal[i]
-		vy := y.Animal[i]
-		if reflect.TypeOf(x.Animal) != reflect.TypeOf(y.Animal) {
-			return false
-		}
-		switch vx.(type) {
-		case Goat:
-			if !equalGoat(vx.(Goat), vy.(Goat)) {
-				return false
-			}
-		case Donkey:
-			if !equalDonkey(vx.(Donkey), vy.(Donkey)) {
-				return false
-			}
-		default:
-			panic(fmt.Sprintf("unknown type: %T", vx))
-		}
-	}
-	if len(x.PreSlaps) != len(y.PreSlaps) {
-		return false
-	}
-	for i := range x.PreSlaps {
-		if !equalSlap(x.PreSlaps[i], y.PreSlaps[i]) {
-			return false
-		}
-	}
-	if len(x.ContSlaps) != len(y.ContSlaps) {
-		return false
-	}
-	for i := range x.ContSlaps {
-		if !equalSlap(x.ContSlaps[i], y.ContSlaps[i]) {
-			return false
-		}
-	}
-	return true
-}
-func equalSlap(x, y Slap) bool {
-	return x.Name == y.Name &&
-		x.Desc == y.Desc &&
-		x.DescLong == y.DescLong &&
-		pb.Equal(x.Args, y.Args) &&
-		x.Tense == y.Tense &&
-		x.Interval == y.Interval &&
-		x.Homeland == y.Homeland &&
-		x.FunnyPrank == y.FunnyPrank &&
-		pb.Equal(x.Immutable.Proto(), y.Immutable.Proto())
-}
-func equalGoat(x, y Goat) bool {
-	if x.Target != y.Target ||
-		x.FunnyPrank != y.FunnyPrank ||
-		!pb.Equal(x.Immutable.Proto(), y.Immutable.Proto()) {
-		return false
-	}
-	if len(x.Slaps) != len(y.Slaps) {
-		return false
-	}
-	for i := range x.Slaps {
-		if !equalSlap(x.Slaps[i], y.Slaps[i]) {
-			return false
-		}
-	}
-	return true
-}
-func equalDonkey(x, y Donkey) bool {
-	return x.Pause == y.Pause &&
-		x.Sleep == y.Sleep &&
-		x.FunnyPrank == y.FunnyPrank &&
-		pb.Equal(x.Immutable.Proto(), y.Immutable.Proto())
-}
-*/
-
-type Eagle struct {
-	Name          string
-	Hounds        []string
-	Desc          string
-	DescLong      string
-	Dreamers      []Dreamer
-	Prong         int64
-	Slaps         []Slap
-	StateGoverner string
-	PrankRating   string
-	FunnyPrank    string
-	Immutable     *EagleImmutable
-}
-
-type EagleImmutable struct {
-	ID          string
-	State       *pb.Eagle_States
-	MissingCall *pb.Eagle_MissingCalls
-	Birthday    time.Time
-	Death       time.Time
-	Started     time.Time
-	LastUpdate  time.Time
-	Creator     string
-	empty       bool
-}
-
-type Dreamer struct {
-	Name              string
-	Desc              string
-	DescLong          string
-	PreSlaps          []Slap
-	ContSlaps         []Slap
-	ContSlapsInterval int32
-	Animal            []interface{} // Could be either Goat or Donkey
-	Ornamental        bool
-	Amoeba            int64
-	Heroes            int32
-	FloppyDisk        int32
-	MightiestDuck     bool
-	FunnyPrank        string
-	Immutable         *DreamerImmutable
-}
-
-type DreamerImmutable struct {
-	ID          string
-	State       *pb.Dreamer_States
-	MissingCall *pb.Dreamer_MissingCalls
-	Calls       int32
-	Started     time.Time
-	Stopped     time.Time
-	LastUpdate  time.Time
-	empty       bool
-}
-
-type Slap struct {
-	Name       string
-	Desc       string
-	DescLong   string
-	Args       pb.Message
-	Tense      int32
-	Interval   int32
-	Homeland   uint32
-	FunnyPrank string
-	Immutable  *SlapImmutable
-}
-
-type SlapImmutable struct {
-	ID          string
-	Out         pb.Message
-	MildSlap    bool
-	PrettyPrint string
-	State       *pb.Slap_States
-	Started     time.Time
-	Stopped     time.Time
-	LastUpdate  time.Time
-	LoveRadius  *LoveRadius
-	empty       bool
-}
-
-type Goat struct {
-	Target     string
-	Slaps      []Slap
-	FunnyPrank string
-	Immutable  *GoatImmutable
-}
-
-type GoatImmutable struct {
-	ID         string
-	State      *pb.Goat_States
-	Started    time.Time
-	Stopped    time.Time
-	LastUpdate time.Time
-	empty      bool
-}
-type Donkey struct {
-	Pause      bool
-	Sleep      int32
-	FunnyPrank string
-	Immutable  *DonkeyImmutable
-}
-
-type DonkeyImmutable struct {
-	ID         string
-	State      *pb.Donkey_States
-	Started    time.Time
-	Stopped    time.Time
-	LastUpdate time.Time
-	empty      bool
-}
-
-type LoveRadius struct {
-	Summer *SummerLove
-	empty  bool
-}
-
-type SummerLove struct {
-	Summary *SummerLoveSummary
-	empty   bool
-}
-
-type SummerLoveSummary struct {
-	Devices    []string
-	ChangeType []pb.SummerType
-	empty      bool
-}
-
-func (EagleImmutable) Proto() *pb.Eagle     { return nil }
-func (DreamerImmutable) Proto() *pb.Dreamer { return nil }
-func (SlapImmutable) Proto() *pb.Slap       { return nil }
-func (GoatImmutable) Proto() *pb.Goat       { return nil }
-func (DonkeyImmutable) Proto() *pb.Donkey   { return nil }
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/teststructs/project2.go b/vendor/github.com/google/go-cmp/cmp/internal/teststructs/project2.go
deleted file mode 100644
index 536592bbe..000000000
--- a/vendor/github.com/google/go-cmp/cmp/internal/teststructs/project2.go
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright 2017, 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.md file.
-
-package teststructs
-
-import (
-	"time"
-
-	pb "github.com/google/go-cmp/cmp/internal/testprotos"
-)
-
-// This is an sanitized example of equality from a real use-case.
-// The original equality function was as follows:
-/*
-func equalBatch(b1, b2 *GermBatch) bool {
-	for _, b := range []*GermBatch{b1, b2} {
-		for _, l := range b.DirtyGerms {
-			sort.Slice(l, func(i, j int) bool { return l[i].String() < l[j].String() })
-		}
-		for _, l := range b.CleanGerms {
-			sort.Slice(l, func(i, j int) bool { return l[i].String() < l[j].String() })
-		}
-	}
-	if !pb.DeepEqual(b1.DirtyGerms, b2.DirtyGerms) ||
-		!pb.DeepEqual(b1.CleanGerms, b2.CleanGerms) ||
-		!pb.DeepEqual(b1.GermMap, b2.GermMap) {
-		return false
-	}
-	if len(b1.DishMap) != len(b2.DishMap) {
-		return false
-	}
-	for id := range b1.DishMap {
-		kpb1, err1 := b1.DishMap[id].Proto()
-		kpb2, err2 := b2.DishMap[id].Proto()
-		if !pb.Equal(kpb1, kpb2) || !reflect.DeepEqual(err1, err2) {
-			return false
-		}
-	}
-	return b1.HasPreviousResult == b2.HasPreviousResult &&
-		b1.DirtyID == b2.DirtyID &&
-		b1.CleanID == b2.CleanID &&
-		b1.GermStrain == b2.GermStrain &&
-		b1.TotalDirtyGerms == b2.TotalDirtyGerms &&
-		b1.InfectedAt.Equal(b2.InfectedAt)
-}
-*/
-
-type GermBatch struct {
-	DirtyGerms, CleanGerms map[int32][]*pb.Germ
-	GermMap                map[int32]*pb.Germ
-	DishMap                map[int32]*Dish
-	HasPreviousResult      bool
-	DirtyID, CleanID       int32
-	GermStrain             int32
-	TotalDirtyGerms        int
-	InfectedAt             time.Time
-}
-
-type Dish struct {
-	pb  *pb.Dish
-	err error
-}
-
-func CreateDish(m *pb.Dish, err error) *Dish {
-	return &Dish{pb: m, err: err}
-}
-
-func (d *Dish) Proto() (*pb.Dish, error) {
-	if d.err != nil {
-		return nil, d.err
-	}
-	return d.pb, nil
-}
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/teststructs/project3.go b/vendor/github.com/google/go-cmp/cmp/internal/teststructs/project3.go
deleted file mode 100644
index 957d093c7..000000000
--- a/vendor/github.com/google/go-cmp/cmp/internal/teststructs/project3.go
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright 2017, 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.md file.
-
-package teststructs
-
-import (
-	"sync"
-
-	pb "github.com/google/go-cmp/cmp/internal/testprotos"
-)
-
-// This is an sanitized example of equality from a real use-case.
-// The original equality function was as follows:
-/*
-func equalDirt(x, y *Dirt) bool {
-	if !reflect.DeepEqual(x.table, y.table) ||
-		!reflect.DeepEqual(x.ts, y.ts) ||
-		x.Discord != y.Discord ||
-		!pb.Equal(&x.Proto, &y.Proto) ||
-		len(x.wizard) != len(y.wizard) ||
-		len(x.sadistic) != len(y.sadistic) ||
-		x.lastTime != y.lastTime {
-		return false
-	}
-	for k, vx := range x.wizard {
-		vy, ok := y.wizard[k]
-		if !ok || !pb.Equal(vx, vy) {
-			return false
-		}
-	}
-	for k, vx := range x.sadistic {
-		vy, ok := y.sadistic[k]
-		if !ok || !pb.Equal(vx, vy) {
-			return false
-		}
-	}
-	return true
-}
-*/
-
-type FakeMutex struct {
-	sync.Locker
-	x struct{}
-}
-
-type Dirt struct {
-	table    Table // Always concrete type of MockTable
-	ts       Timestamp
-	Discord  DiscordState
-	Proto    pb.Dirt
-	wizard   map[string]*pb.Wizard
-	sadistic map[string]*pb.Sadistic
-	lastTime int64
-	mu       FakeMutex
-}
-
-type DiscordState int
-
-type Timestamp int64
-
-func (d *Dirt) SetTable(t Table)                      { d.table = t }
-func (d *Dirt) SetTimestamp(t Timestamp)              { d.ts = t }
-func (d *Dirt) SetWizard(m map[string]*pb.Wizard)     { d.wizard = m }
-func (d *Dirt) SetSadistic(m map[string]*pb.Sadistic) { d.sadistic = m }
-func (d *Dirt) SetLastTime(t int64)                   { d.lastTime = t }
-
-type Table interface {
-	Operation1() error
-	Operation2() error
-	Operation3() error
-}
-
-type MockTable struct {
-	state []string
-}
-
-func CreateMockTable(s []string) *MockTable { return &MockTable{s} }
-func (mt *MockTable) Operation1() error     { return nil }
-func (mt *MockTable) Operation2() error     { return nil }
-func (mt *MockTable) Operation3() error     { return nil }
-func (mt *MockTable) State() []string       { return mt.state }
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/teststructs/project4.go b/vendor/github.com/google/go-cmp/cmp/internal/teststructs/project4.go
deleted file mode 100644
index 49920f237..000000000
--- a/vendor/github.com/google/go-cmp/cmp/internal/teststructs/project4.go
+++ /dev/null
@@ -1,142 +0,0 @@
-// Copyright 2017, 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.md file.
-
-package teststructs
-
-import (
-	"time"
-
-	pb "github.com/google/go-cmp/cmp/internal/testprotos"
-)
-
-// This is an sanitized example of equality from a real use-case.
-// The original equality function was as follows:
-/*
-func equalCartel(x, y Cartel) bool {
-	if !(equalHeadquarter(x.Headquarter, y.Headquarter) &&
-		x.Source() == y.Source() &&
-		x.CreationDate().Equal(y.CreationDate()) &&
-		x.Boss() == y.Boss() &&
-		x.LastCrimeDate().Equal(y.LastCrimeDate())) {
-		return false
-	}
-	if len(x.Poisons()) != len(y.Poisons()) {
-		return false
-	}
-	for i := range x.Poisons() {
-		if !equalPoison(*x.Poisons()[i], *y.Poisons()[i]) {
-			return false
-		}
-	}
-	return true
-}
-func equalHeadquarter(x, y Headquarter) bool {
-	xr, yr := x.Restrictions(), y.Restrictions()
-	return x.ID() == y.ID() &&
-		x.Location() == y.Location() &&
-		reflect.DeepEqual(x.SubDivisions(), y.SubDivisions()) &&
-		x.IncorporatedDate().Equal(y.IncorporatedDate()) &&
-		pb.Equal(x.MetaData(), y.MetaData()) &&
-		bytes.Equal(x.PrivateMessage(), y.PrivateMessage()) &&
-		bytes.Equal(x.PublicMessage(), y.PublicMessage()) &&
-		x.HorseBack() == y.HorseBack() &&
-		x.Rattle() == y.Rattle() &&
-		x.Convulsion() == y.Convulsion() &&
-		x.Expansion() == y.Expansion() &&
-		x.Status() == y.Status() &&
-		pb.Equal(&xr, &yr) &&
-		x.CreationTime().Equal(y.CreationTime())
-}
-func equalPoison(x, y Poison) bool {
-	return x.PoisonType() == y.PoisonType() &&
-		x.Expiration().Equal(y.Expiration()) &&
-		x.Manufacturer() == y.Manufacturer() &&
-		x.Potency() == y.Potency()
-}
-*/
-
-type Cartel struct {
-	Headquarter
-	source        string
-	creationDate  time.Time
-	boss          string
-	lastCrimeDate time.Time
-	poisons       []*Poison
-}
-
-func (p Cartel) Source() string           { return p.source }
-func (p Cartel) CreationDate() time.Time  { return p.creationDate }
-func (p Cartel) Boss() string             { return p.boss }
-func (p Cartel) LastCrimeDate() time.Time { return p.lastCrimeDate }
-func (p Cartel) Poisons() []*Poison       { return p.poisons }
-
-func (p *Cartel) SetSource(x string)           { p.source = x }
-func (p *Cartel) SetCreationDate(x time.Time)  { p.creationDate = x }
-func (p *Cartel) SetBoss(x string)             { p.boss = x }
-func (p *Cartel) SetLastCrimeDate(x time.Time) { p.lastCrimeDate = x }
-func (p *Cartel) SetPoisons(x []*Poison)       { p.poisons = x }
-
-type Headquarter struct {
-	id               uint64
-	location         string
-	subDivisions     []string
-	incorporatedDate time.Time
-	metaData         *pb.MetaData
-	privateMessage   []byte
-	publicMessage    []byte
-	horseBack        string
-	rattle           string
-	convulsion       bool
-	expansion        uint64
-	status           pb.HoneyStatus
-	restrictions     pb.Restrictions
-	creationTime     time.Time
-}
-
-func (hq Headquarter) ID() uint64                    { return hq.id }
-func (hq Headquarter) Location() string              { return hq.location }
-func (hq Headquarter) SubDivisions() []string        { return hq.subDivisions }
-func (hq Headquarter) IncorporatedDate() time.Time   { return hq.incorporatedDate }
-func (hq Headquarter) MetaData() *pb.MetaData        { return hq.metaData }
-func (hq Headquarter) PrivateMessage() []byte        { return hq.privateMessage }
-func (hq Headquarter) PublicMessage() []byte         { return hq.publicMessage }
-func (hq Headquarter) HorseBack() string             { return hq.horseBack }
-func (hq Headquarter) Rattle() string                { return hq.rattle }
-func (hq Headquarter) Convulsion() bool              { return hq.convulsion }
-func (hq Headquarter) Expansion() uint64             { return hq.expansion }
-func (hq Headquarter) Status() pb.HoneyStatus        { return hq.status }
-func (hq Headquarter) Restrictions() pb.Restrictions { return hq.restrictions }
-func (hq Headquarter) CreationTime() time.Time       { return hq.creationTime }
-
-func (hq *Headquarter) SetID(x uint64)                    { hq.id = x }
-func (hq *Headquarter) SetLocation(x string)              { hq.location = x }
-func (hq *Headquarter) SetSubDivisions(x []string)        { hq.subDivisions = x }
-func (hq *Headquarter) SetIncorporatedDate(x time.Time)   { hq.incorporatedDate = x }
-func (hq *Headquarter) SetMetaData(x *pb.MetaData)        { hq.metaData = x }
-func (hq *Headquarter) SetPrivateMessage(x []byte)        { hq.privateMessage = x }
-func (hq *Headquarter) SetPublicMessage(x []byte)         { hq.publicMessage = x }
-func (hq *Headquarter) SetHorseBack(x string)             { hq.horseBack = x }
-func (hq *Headquarter) SetRattle(x string)                { hq.rattle = x }
-func (hq *Headquarter) SetConvulsion(x bool)              { hq.convulsion = x }
-func (hq *Headquarter) SetExpansion(x uint64)             { hq.expansion = x }
-func (hq *Headquarter) SetStatus(x pb.HoneyStatus)        { hq.status = x }
-func (hq *Headquarter) SetRestrictions(x pb.Restrictions) { hq.restrictions = x }
-func (hq *Headquarter) SetCreationTime(x time.Time)       { hq.creationTime = x }
-
-type Poison struct {
-	poisonType   pb.PoisonType
-	expiration   time.Time
-	manufacturer string
-	potency      int
-}
-
-func (p Poison) PoisonType() pb.PoisonType { return p.poisonType }
-func (p Poison) Expiration() time.Time     { return p.expiration }
-func (p Poison) Manufacturer() string      { return p.manufacturer }
-func (p Poison) Potency() int              { return p.potency }
-
-func (p *Poison) SetPoisonType(x pb.PoisonType) { p.poisonType = x }
-func (p *Poison) SetExpiration(x time.Time)     { p.expiration = x }
-func (p *Poison) SetManufacturer(x string)      { p.manufacturer = x }
-func (p *Poison) SetPotency(x int)              { p.potency = x }
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/teststructs/structs.go b/vendor/github.com/google/go-cmp/cmp/internal/teststructs/structs.go
deleted file mode 100644
index 6b4d2a725..000000000
--- a/vendor/github.com/google/go-cmp/cmp/internal/teststructs/structs.go
+++ /dev/null
@@ -1,197 +0,0 @@
-// Copyright 2017, 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.md file.
-
-package teststructs
-
-type InterfaceA interface {
-	InterfaceA()
-}
-
-type (
-	StructA struct{ X string } // Equal method on value receiver
-	StructB struct{ X string } // Equal method on pointer receiver
-	StructC struct{ X string } // Equal method (with interface argument) on value receiver
-	StructD struct{ X string } // Equal method (with interface argument) on pointer receiver
-	StructE struct{ X string } // Equal method (with interface argument on value receiver) on pointer receiver
-	StructF struct{ X string } // Equal method (with interface argument on pointer receiver) on value receiver
-
-	// These embed the above types as a value.
-	StructA1 struct {
-		StructA
-		X string
-	}
-	StructB1 struct {
-		StructB
-		X string
-	}
-	StructC1 struct {
-		StructC
-		X string
-	}
-	StructD1 struct {
-		StructD
-		X string
-	}
-	StructE1 struct {
-		StructE
-		X string
-	}
-	StructF1 struct {
-		StructF
-		X string
-	}
-
-	// These embed the above types as a pointer.
-	StructA2 struct {
-		*StructA
-		X string
-	}
-	StructB2 struct {
-		*StructB
-		X string
-	}
-	StructC2 struct {
-		*StructC
-		X string
-	}
-	StructD2 struct {
-		*StructD
-		X string
-	}
-	StructE2 struct {
-		*StructE
-		X string
-	}
-	StructF2 struct {
-		*StructF
-		X string
-	}
-
-	StructNo struct{ X string } // Equal method (with interface argument) on non-satisfying receiver
-
-	AssignA func() int
-	AssignB struct{ A int }
-	AssignC chan bool
-	AssignD <-chan bool
-)
-
-func (x StructA) Equal(y StructA) bool     { return true }
-func (x *StructB) Equal(y *StructB) bool   { return true }
-func (x StructC) Equal(y InterfaceA) bool  { return true }
-func (x StructC) InterfaceA()              {}
-func (x *StructD) Equal(y InterfaceA) bool { return true }
-func (x *StructD) InterfaceA()             {}
-func (x *StructE) Equal(y InterfaceA) bool { return true }
-func (x StructE) InterfaceA()              {}
-func (x StructF) Equal(y InterfaceA) bool  { return true }
-func (x *StructF) InterfaceA()             {}
-func (x StructNo) Equal(y InterfaceA) bool { return true }
-
-func (x AssignA) Equal(y func() int) bool      { return true }
-func (x AssignB) Equal(y struct{ A int }) bool { return true }
-func (x AssignC) Equal(y chan bool) bool       { return true }
-func (x AssignD) Equal(y <-chan bool) bool     { return true }
-
-var _ = func(
-	a StructA, b StructB, c StructC, d StructD, e StructE, f StructF,
-	ap *StructA, bp *StructB, cp *StructC, dp *StructD, ep *StructE, fp *StructF,
-	a1 StructA1, b1 StructB1, c1 StructC1, d1 StructD1, e1 StructE1, f1 StructF1,
-	a2 StructA2, b2 StructB2, c2 StructC2, d2 StructD2, e2 StructE2, f2 StructF1,
-) {
-	a.Equal(a)
-	b.Equal(&b)
-	c.Equal(c)
-	d.Equal(&d)
-	e.Equal(e)
-	f.Equal(&f)
-
-	ap.Equal(*ap)
-	bp.Equal(bp)
-	cp.Equal(*cp)
-	dp.Equal(dp)
-	ep.Equal(*ep)
-	fp.Equal(fp)
-
-	a1.Equal(a1.StructA)
-	b1.Equal(&b1.StructB)
-	c1.Equal(c1)
-	d1.Equal(&d1)
-	e1.Equal(e1)
-	f1.Equal(&f1)
-
-	a2.Equal(*a2.StructA)
-	b2.Equal(b2.StructB)
-	c2.Equal(c2)
-	d2.Equal(&d2)
-	e2.Equal(e2)
-	f2.Equal(&f2)
-}
-
-type (
-	privateStruct struct{ Public, private int }
-	PublicStruct  struct{ Public, private int }
-	ParentStructA struct{ privateStruct }
-	ParentStructB struct{ PublicStruct }
-	ParentStructC struct {
-		privateStruct
-		Public, private int
-	}
-	ParentStructD struct {
-		PublicStruct
-		Public, private int
-	}
-	ParentStructE struct {
-		privateStruct
-		PublicStruct
-	}
-	ParentStructF struct {
-		privateStruct
-		PublicStruct
-		Public, private int
-	}
-	ParentStructG struct {
-		*privateStruct
-	}
-	ParentStructH struct {
-		*PublicStruct
-	}
-	ParentStructI struct {
-		*privateStruct
-		*PublicStruct
-	}
-	ParentStructJ struct {
-		*privateStruct
-		*PublicStruct
-		Public  PublicStruct
-		private privateStruct
-	}
-)
-
-func NewParentStructG() *ParentStructG {
-	return &ParentStructG{new(privateStruct)}
-}
-func NewParentStructH() *ParentStructH {
-	return &ParentStructH{new(PublicStruct)}
-}
-func NewParentStructI() *ParentStructI {
-	return &ParentStructI{new(privateStruct), new(PublicStruct)}
-}
-func NewParentStructJ() *ParentStructJ {
-	return &ParentStructJ{
-		privateStruct: new(privateStruct), PublicStruct: new(PublicStruct),
-	}
-}
-func (s *privateStruct) SetPrivate(i int)              { s.private = i }
-func (s *PublicStruct) SetPrivate(i int)               { s.private = i }
-func (s *ParentStructC) SetPrivate(i int)              { s.private = i }
-func (s *ParentStructD) SetPrivate(i int)              { s.private = i }
-func (s *ParentStructF) SetPrivate(i int)              { s.private = i }
-func (s *ParentStructA) PrivateStruct() *privateStruct { return &s.privateStruct }
-func (s *ParentStructC) PrivateStruct() *privateStruct { return &s.privateStruct }
-func (s *ParentStructE) PrivateStruct() *privateStruct { return &s.privateStruct }
-func (s *ParentStructF) PrivateStruct() *privateStruct { return &s.privateStruct }
-func (s *ParentStructG) PrivateStruct() *privateStruct { return s.privateStruct }
-func (s *ParentStructI) PrivateStruct() *privateStruct { return s.privateStruct }
-func (s *ParentStructJ) PrivateStruct() *privateStruct { return s.privateStruct }
-func (s *ParentStructJ) Private() *privateStruct       { return &s.private }
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/value/sort.go b/vendor/github.com/google/go-cmp/cmp/internal/value/sort.go
index 938f646f0..24fbae6e3 100644
--- a/vendor/github.com/google/go-cmp/cmp/internal/value/sort.go
+++ b/vendor/github.com/google/go-cmp/cmp/internal/value/sort.go
@@ -19,7 +19,7 @@ func SortKeys(vs []reflect.Value) []reflect.Value {
 	}
 
 	// Sort the map keys.
-	sort.Slice(vs, func(i, j int) bool { return isLess(vs[i], vs[j]) })
+	sort.SliceStable(vs, func(i, j int) bool { return isLess(vs[i], vs[j]) })
 
 	// Deduplicate keys (fails for NaNs).
 	vs2 := vs[:1]
@@ -42,6 +42,8 @@ func isLess(x, y reflect.Value) bool {
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
 		return x.Uint() < y.Uint()
 	case reflect.Float32, reflect.Float64:
+		// NOTE: This does not sort -0 as less than +0
+		// since Go maps treat -0 and +0 as equal keys.
 		fx, fy := x.Float(), y.Float()
 		return fx < fy || math.IsNaN(fx) && !math.IsNaN(fy)
 	case reflect.Complex64, reflect.Complex128:
diff --git a/vendor/github.com/google/go-cmp/cmp/internal/value/zero.go b/vendor/github.com/google/go-cmp/cmp/internal/value/zero.go
index d13a12ccf..06a8ffd03 100644
--- a/vendor/github.com/google/go-cmp/cmp/internal/value/zero.go
+++ b/vendor/github.com/google/go-cmp/cmp/internal/value/zero.go
@@ -4,7 +4,10 @@
 
 package value
 
-import "reflect"
+import (
+	"math"
+	"reflect"
+)
 
 // IsZero reports whether v is the zero value.
 // This does not rely on Interface and so can be used on unexported fields.
@@ -17,9 +20,9 @@ func IsZero(v reflect.Value) bool {
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
 		return v.Uint() == 0
 	case reflect.Float32, reflect.Float64:
-		return v.Float() == 0
+		return math.Float64bits(v.Float()) == 0
 	case reflect.Complex64, reflect.Complex128:
-		return v.Complex() == 0
+		return math.Float64bits(real(v.Complex())) == 0 && math.Float64bits(imag(v.Complex())) == 0
 	case reflect.String:
 		return v.String() == ""
 	case reflect.UnsafePointer: