@@ -7,7 +7,7 @@ import (

 	"github.com/docker/libnetwork/options"

 	_ "github.com/docker/libnetwork/testutils"

-	"gotest.tools/assert"

+	"gotest.tools/v3/assert"

 )

 var dummyKey = "dummy"

@@ -11,8 +11,8 @@ import (

 	"github.com/docker/libnetwork/netlabel"

 	_ "github.com/docker/libnetwork/testutils"

 	"github.com/docker/libnetwork/types"

-	"gotest.tools/assert"

-	is "gotest.tools/assert/cmp"

+	"gotest.tools/v3/assert"

+	is "gotest.tools/v3/assert/cmp"

 )

 func newDriver(t *testing.T) *driver {

@@ -11,8 +11,8 @@ import (

 	builtinIpam "github.com/docker/libnetwork/ipams/builtin"

 	nullIpam "github.com/docker/libnetwork/ipams/null"

 	remoteIpam "github.com/docker/libnetwork/ipams/remote"

-	"gotest.tools/assert"

-	is "gotest.tools/assert/cmp"

+	"gotest.tools/v3/assert"

+	is "gotest.tools/v3/assert/cmp"

 	// this takes care of the incontainer flag

 	_ "github.com/docker/libnetwork/testutils"

@@ -8,7 +8,7 @@ import (

 	"github.com/docker/libnetwork/iptables"

 	"github.com/docker/libnetwork/netlabel"

 	"github.com/docker/libnetwork/options"

-	"gotest.tools/assert"

+	"gotest.tools/v3/assert"

 )

 const (

@@ -19,8 +19,8 @@ import (

 	"github.com/docker/libnetwork/ipamapi"

 	_ "github.com/docker/libnetwork/testutils"

 	"github.com/docker/libnetwork/types"

-	"gotest.tools/assert"

-	is "gotest.tools/assert/cmp"

+	"gotest.tools/v3/assert"

+	is "gotest.tools/v3/assert/cmp"

 )

 const (

@@ -13,8 +13,8 @@ import (

 	"github.com/docker/libnetwork/ipamapi"

 	"golang.org/x/sync/semaphore"

-	"gotest.tools/assert"

-	is "gotest.tools/assert/cmp"

+	"gotest.tools/v3/assert"

+	is "gotest.tools/v3/assert/cmp"

 )

 const (

@@ -5,8 +5,8 @@ import (

 	"testing"

 	_ "github.com/docker/libnetwork/testutils"

-	"gotest.tools/assert"

-	is "gotest.tools/assert/cmp"

+	"gotest.tools/v3/assert"

+	is "gotest.tools/v3/assert/cmp"

 )

 func initBroadPredefinedNetworks() []*net.IPNet {

@@ -15,9 +15,9 @@ import (

 	"github.com/docker/go-events"

 	"github.com/hashicorp/memberlist"

 	"github.com/sirupsen/logrus"

-	"gotest.tools/assert"

-	is "gotest.tools/assert/cmp"

-	"gotest.tools/poll"

+	"gotest.tools/v3/assert"

+	is "gotest.tools/v3/assert/cmp"

+	"gotest.tools/v3/poll"

 	// this takes care of the incontainer flag

 	_ "github.com/docker/libnetwork/testutils"

@@ -4,8 +4,8 @@ import (

 	"testing"

 	"github.com/sirupsen/logrus"

-	"gotest.tools/assert"

-	is "gotest.tools/assert/cmp"

+	"gotest.tools/v3/assert"

+	is "gotest.tools/v3/assert/cmp"

 	_ "github.com/docker/libnetwork/testutils"

 )

@@ -5,8 +5,8 @@ import (

 	"testing"

 	"github.com/docker/libnetwork/resolvconf"

-	"gotest.tools/assert"

-	is "gotest.tools/assert/cmp"

+	"gotest.tools/v3/assert"

+	is "gotest.tools/v3/assert/cmp"

 )

 func TestCleanupServiceDiscovery(t *testing.T) {

@@ -5,8 +5,8 @@ import (

 	"testing"

 	_ "github.com/docker/libnetwork/testutils"

-	"gotest.tools/assert"

-	is "gotest.tools/assert/cmp"

+	"gotest.tools/v3/assert"

+	is "gotest.tools/v3/assert/cmp"

 )

 func TestTransportPortConv(t *testing.T) {

@@ -50,7 +50,7 @@ github.com/pkg/errors                               614d223910a179a466c1767a9854

 github.com/ishidawataru/sctp                        6e2cb1366111dcf547c13531e3a263a067715847

 go.opencensus.io                                    9c377598961b706d1542bd2d84d538b5094d596e # v0.22.0

-gotest.tools                                        1083505acf35a0bd8a696b26837e1fb3187a7a83 # v2.3.0

+gotest.tools/v3                                     bb0d8a963040ea5048dcef1a14d8f8b58a33d4b3 # v3.0.2

 github.com/google/go-cmp                            3af367b6b30c263d47e8895973edcca9a49cf029 # v0.2.0

 github.com/moby/ipvs                                4566ccea0e08d68e9614c3e7a64a23b850c4bb35 # v1.0.1

deleted file mode 100644

@@ -1,13 +0,0 @@

-Copyright 2018 gotest.tools authors

-

-Licensed under the Apache License, Version 2.0 (the "License");

-you may not use this file except in compliance with the License.

-You may obtain a copy of the License at

-

-    http://www.apache.org/licenses/LICENSE-2.0

-

-Unless required by applicable law or agreed to in writing, software

-distributed under the License is distributed on an "AS IS" BASIS,

-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

-See the License for the specific language governing permissions and

-limitations under the License.

deleted file mode 100644

@@ -1,35 +0,0 @@

-# gotest.tools

-

-A collection of packages to augment `testing` and support common patterns.

-

-[![GoDoc](https://godoc.org/gotest.tools?status.svg)](https://godoc.org/gotest.tools)

-[![CircleCI](https://circleci.com/gh/gotestyourself/gotest.tools/tree/master.svg?style=shield)](https://circleci.com/gh/gotestyourself/gotest.tools/tree/master)

-[![Go Reportcard](https://goreportcard.com/badge/gotest.tools)](https://goreportcard.com/report/gotest.tools)

-

-

-## Packages

-

-* [assert](http://godoc.org/gotest.tools/assert) -

-  compare values and fail the test when a comparison fails

-* [env](http://godoc.org/gotest.tools/env) -

-  test code which uses environment variables

-* [fs](http://godoc.org/gotest.tools/fs) -

-  create temporary files and compare a filesystem tree to an expected value

-* [golden](http://godoc.org/gotest.tools/golden) -

-  compare large multi-line strings against values frozen in golden files

-* [icmd](http://godoc.org/gotest.tools/icmd) -

-  execute binaries and test the output

-* [poll](http://godoc.org/gotest.tools/poll) -

-  test asynchronous code by polling until a desired state is reached

-* [skip](http://godoc.org/gotest.tools/skip) -

-  skip a test and print the source code of the condition used to skip the test

-

-## Related

-

-* [gotest.tools/gotestsum](https://github.com/gotestyourself/gotestsum) - go test runner with custom output

-* [maxbrunsfeld/counterfeiter](https://github.com/maxbrunsfeld/counterfeiter) - generate fakes for interfaces

-* [jonboulle/clockwork](https://github.com/jonboulle/clockwork) - a fake clock for testing code that uses `time`

-

-## Contributing

-

-See [CONTRIBUTING.md](CONTRIBUTING.md).

deleted file mode 100644

@@ -1,311 +0,0 @@

-/*Package assert provides assertions for comparing expected values to actual

-values. When an assertion fails a helpful error message is printed.

-

-Assert and Check

-

-Assert() and Check() both accept a Comparison, and fail the test when the

-comparison fails. The one difference is that Assert() will end the test execution

-immediately (using t.FailNow()) whereas Check() will fail the test (using t.Fail()),

-return the value of the comparison, then proceed with the rest of the test case.

-

-Example usage

-

-The example below shows assert used with some common types.

-

-

-	import (

-	    "testing"

-

-	    "gotest.tools/assert"

-	    is "gotest.tools/assert/cmp"

-	)

-

-	func TestEverything(t *testing.T) {

-	    // booleans

-	    assert.Assert(t, ok)

-	    assert.Assert(t, !missing)

-

-	    // primitives

-	    assert.Equal(t, count, 1)

-	    assert.Equal(t, msg, "the message")

-	    assert.Assert(t, total != 10) // NotEqual

-

-	    // errors

-	    assert.NilError(t, closer.Close())

-	    assert.Error(t, err, "the exact error message")

-	    assert.ErrorContains(t, err, "includes this")

-	    assert.ErrorType(t, err, os.IsNotExist)

-

-	    // complex types

-	    assert.DeepEqual(t, result, myStruct{Name: "title"})

-	    assert.Assert(t, is.Len(items, 3))

-	    assert.Assert(t, len(sequence) != 0) // NotEmpty

-	    assert.Assert(t, is.Contains(mapping, "key"))

-

-	    // pointers and interface

-	    assert.Assert(t, is.Nil(ref))

-	    assert.Assert(t, ref != nil) // NotNil

-	}

-

-Comparisons

-

-Package https://godoc.org/gotest.tools/assert/cmp provides

-many common comparisons. Additional comparisons can be written to compare

-values in other ways. See the example Assert (CustomComparison).

-

-Automated migration from testify

-

-gty-migrate-from-testify is a binary which can update source code which uses

-testify assertions to use the assertions provided by this package.

-

-See http://bit.do/cmd-gty-migrate-from-testify.

-

-

-*/

-package assert // import "gotest.tools/assert"

-

-import (

-	"fmt"

-	"go/ast"

-	"go/token"

-

-	gocmp "github.com/google/go-cmp/cmp"

-	"gotest.tools/assert/cmp"

-	"gotest.tools/internal/format"

-	"gotest.tools/internal/source"

-)

-

-// BoolOrComparison can be a bool, or cmp.Comparison. See Assert() for usage.

-type BoolOrComparison interface{}

-

-// TestingT is the subset of testing.T used by the assert package.

-type TestingT interface {

-	FailNow()

-	Fail()

-	Log(args ...interface{})

-}

-

-type helperT interface {

-	Helper()

-}

-

-const failureMessage = "assertion failed: "

-

-// nolint: gocyclo

-func assert(

-	t TestingT,

-	failer func(),

-	argSelector argSelector,

-	comparison BoolOrComparison,

-	msgAndArgs ...interface{},

-) bool {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	var success bool

-	switch check := comparison.(type) {

-	case bool:

-		if check {

-			return true

-		}

-		logFailureFromBool(t, msgAndArgs...)

-

-	// Undocumented legacy comparison without Result type

-	case func() (success bool, message string):

-		success = runCompareFunc(t, check, msgAndArgs...)

-

-	case nil:

-		return true

-

-	case error:

-		msg := "error is not nil: "

-		t.Log(format.WithCustomMessage(failureMessage+msg+check.Error(), msgAndArgs...))

-

-	case cmp.Comparison:

-		success = runComparison(t, argSelector, check, msgAndArgs...)

-

-	case func() cmp.Result:

-		success = runComparison(t, argSelector, check, msgAndArgs...)

-

-	default:

-		t.Log(fmt.Sprintf("invalid Comparison: %v (%T)", check, check))

-	}

-

-	if success {

-		return true

-	}

-	failer()

-	return false

-}

-

-func runCompareFunc(

-	t TestingT,

-	f func() (success bool, message string),

-	msgAndArgs ...interface{},

-) bool {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	if success, message := f(); !success {

-		t.Log(format.WithCustomMessage(failureMessage+message, msgAndArgs...))

-		return false

-	}

-	return true

-}

-

-func logFailureFromBool(t TestingT, msgAndArgs ...interface{}) {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	const stackIndex = 3 // Assert()/Check(), assert(), formatFailureFromBool()

-	const comparisonArgPos = 1

-	args, err := source.CallExprArgs(stackIndex)

-	if err != nil {

-		t.Log(err.Error())

-		return

-	}

-

-	msg, err := boolFailureMessage(args[comparisonArgPos])

-	if err != nil {

-		t.Log(err.Error())

-		msg = "expression is false"

-	}

-

-	t.Log(format.WithCustomMessage(failureMessage+msg, msgAndArgs...))

-}

-

-func boolFailureMessage(expr ast.Expr) (string, error) {

-	if binaryExpr, ok := expr.(*ast.BinaryExpr); ok && binaryExpr.Op == token.NEQ {

-		x, err := source.FormatNode(binaryExpr.X)

-		if err != nil {

-			return "", err

-		}

-		y, err := source.FormatNode(binaryExpr.Y)

-		if err != nil {

-			return "", err

-		}

-		return x + " is " + y, nil

-	}

-

-	if unaryExpr, ok := expr.(*ast.UnaryExpr); ok && unaryExpr.Op == token.NOT {

-		x, err := source.FormatNode(unaryExpr.X)

-		if err != nil {

-			return "", err

-		}

-		return x + " is true", nil

-	}

-

-	formatted, err := source.FormatNode(expr)

-	if err != nil {

-		return "", err

-	}

-	return "expression is false: " + formatted, nil

-}

-

-// Assert performs a comparison. If the comparison fails the test is marked as

-// failed, a failure message is logged, and execution is stopped immediately.

-//

-// The comparison argument may be one of three types: bool, cmp.Comparison or

-// error.

-// When called with a bool the failure message will contain the literal source

-// code of the expression.

-// When called with a cmp.Comparison the comparison is responsible for producing

-// a helpful failure message.

-// When called with an error a nil value is considered success. A non-nil error

-// is a failure, and Error() is used as the failure message.

-func Assert(t TestingT, comparison BoolOrComparison, msgAndArgs ...interface{}) {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	assert(t, t.FailNow, argsFromComparisonCall, comparison, msgAndArgs...)

-}

-

-// Check performs a comparison. If the comparison fails the test is marked as

-// failed, a failure message is logged, and Check returns false. Otherwise returns

-// true.

-//

-// See Assert for details about the comparison arg and failure messages.

-func Check(t TestingT, comparison BoolOrComparison, msgAndArgs ...interface{}) bool {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	return assert(t, t.Fail, argsFromComparisonCall, comparison, msgAndArgs...)

-}

-

-// NilError fails the test immediately if err is not nil.

-// This is equivalent to Assert(t, err)

-func NilError(t TestingT, err error, msgAndArgs ...interface{}) {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	assert(t, t.FailNow, argsAfterT, err, msgAndArgs...)

-}

-

-// Equal uses the == operator to assert two values are equal and fails the test

-// if they are not equal.

-//

-// If the comparison fails Equal will use the variable names for x and y as part

-// of the failure message to identify the actual and expected values.

-//

-// If either x or y are a multi-line string the failure message will include a

-// unified diff of the two values. If the values only differ by whitespace

-// the unified diff will be augmented by replacing whitespace characters with

-// visible characters to identify the whitespace difference.

-//

-// This is equivalent to Assert(t, cmp.Equal(x, y)).

-func Equal(t TestingT, x, y interface{}, msgAndArgs ...interface{}) {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	assert(t, t.FailNow, argsAfterT, cmp.Equal(x, y), msgAndArgs...)

-}

-

-// DeepEqual uses google/go-cmp (http://bit.do/go-cmp) to assert two values are

-// equal and fails the test if they are not equal.

-//

-// Package https://godoc.org/gotest.tools/assert/opt provides some additional

-// commonly used Options.

-//

-// This is equivalent to Assert(t, cmp.DeepEqual(x, y)).

-func DeepEqual(t TestingT, x, y interface{}, opts ...gocmp.Option) {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	assert(t, t.FailNow, argsAfterT, cmp.DeepEqual(x, y, opts...))

-}

-

-// Error fails the test if err is nil, or the error message is not the expected

-// message.

-// Equivalent to Assert(t, cmp.Error(err, message)).

-func Error(t TestingT, err error, message string, msgAndArgs ...interface{}) {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	assert(t, t.FailNow, argsAfterT, cmp.Error(err, message), msgAndArgs...)

-}

-

-// ErrorContains fails the test if err is nil, or the error message does not

-// contain the expected substring.

-// Equivalent to Assert(t, cmp.ErrorContains(err, substring)).

-func ErrorContains(t TestingT, err error, substring string, msgAndArgs ...interface{}) {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	assert(t, t.FailNow, argsAfterT, cmp.ErrorContains(err, substring), msgAndArgs...)

-}

-

-// ErrorType fails the test if err is nil, or err is not the expected type.

-//

-// Expected can be one of:

-// a func(error) bool which returns true if the error is the expected type,

-// an instance of (or a pointer to) a struct of the expected type,

-// a pointer to an interface the error is expected to implement,

-// a reflect.Type of the expected struct or interface.

-//

-// Equivalent to Assert(t, cmp.ErrorType(err, expected)).

-func ErrorType(t TestingT, err error, expected interface{}, msgAndArgs ...interface{}) {

-	if ht, ok := t.(helperT); ok {

-		ht.Helper()

-	}

-	assert(t, t.FailNow, argsAfterT, cmp.ErrorType(err, expected), msgAndArgs...)

-}

deleted file mode 100644

@@ -1,356 +0,0 @@

-/*Package cmp provides Comparisons for Assert and Check*/

-package cmp // import "gotest.tools/assert/cmp"

-

-import (

-	"fmt"

-	"reflect"

-	"regexp"

-	"strings"

-

-	"github.com/google/go-cmp/cmp"

-	"gotest.tools/internal/format"

-)

-

-// Comparison is a function which compares values and returns ResultSuccess if

-// the actual value matches the expected value. If the values do not match the

-// Result will contain a message about why it failed.

-type Comparison func() Result

-

-// DeepEqual compares two values using google/go-cmp (http://bit.do/go-cmp)

-// and succeeds if the values are equal.

-//

-// The comparison can be customized using comparison Options.

-// Package https://godoc.org/gotest.tools/assert/opt provides some additional

-// commonly used Options.

-func DeepEqual(x, y interface{}, opts ...cmp.Option) Comparison {

-	return func() (result Result) {

-		defer func() {

-			if panicmsg, handled := handleCmpPanic(recover()); handled {

-				result = ResultFailure(panicmsg)

-			}

-		}()

-		diff := cmp.Diff(x, y, opts...)

-		if diff == "" {

-			return ResultSuccess

-		}

-		return multiLineDiffResult(diff)

-	}

-}

-

-func handleCmpPanic(r interface{}) (string, bool) {

-	if r == nil {

-		return "", false

-	}

-	panicmsg, ok := r.(string)

-	if !ok {

-		panic(r)

-	}

-	switch {

-	case strings.HasPrefix(panicmsg, "cannot handle unexported field"):

-		return panicmsg, true

-	}

-	panic(r)

-}

-

-func toResult(success bool, msg string) Result {

-	if success {

-		return ResultSuccess

-	}

-	return ResultFailure(msg)

-}

-

-// RegexOrPattern may be either a *regexp.Regexp or a string that is a valid

-// regexp pattern.

-type RegexOrPattern interface{}

-

-// Regexp succeeds if value v matches regular expression re.

-//

-// Example:

-//   assert.Assert(t, cmp.Regexp("^[0-9a-f]{32}$", str))

-//   r := regexp.MustCompile("^[0-9a-f]{32}$")

-//   assert.Assert(t, cmp.Regexp(r, str))

-func Regexp(re RegexOrPattern, v string) Comparison {

-	match := func(re *regexp.Regexp) Result {

-		return toResult(

-			re.MatchString(v),

-			fmt.Sprintf("value %q does not match regexp %q", v, re.String()))

-	}

-

-	return func() Result {

-		switch regex := re.(type) {

-		case *regexp.Regexp:

-			return match(regex)

-		case string:

-			re, err := regexp.Compile(regex)

-			if err != nil {

-				return ResultFailure(err.Error())

-			}

-			return match(re)

-		default:

-			return ResultFailure(fmt.Sprintf("invalid type %T for regex pattern", regex))

-		}

-	}

-}

-

-// Equal succeeds if x == y. See assert.Equal for full documentation.

-func Equal(x, y interface{}) Comparison {

-	return func() Result {

-		switch {

-		case x == y:

-			return ResultSuccess

-		case isMultiLineStringCompare(x, y):

-			diff := format.UnifiedDiff(format.DiffConfig{A: x.(string), B: y.(string)})

-			return multiLineDiffResult(diff)

-		}

-		return ResultFailureTemplate(`

-			{{- .Data.x}} (

-				{{- with callArg 0 }}{{ formatNode . }} {{end -}}

-				{{- printf "%T" .Data.x -}}

-			) != {{ .Data.y}} (

-				{{- with callArg 1 }}{{ formatNode . }} {{end -}}

-				{{- printf "%T" .Data.y -}}

-			)`,

-			map[string]interface{}{"x": x, "y": y})

-	}

-}

-

-func isMultiLineStringCompare(x, y interface{}) bool {

-	strX, ok := x.(string)

-	if !ok {

-		return false

-	}

-	strY, ok := y.(string)

-	if !ok {

-		return false

-	}

-	return strings.Contains(strX, "\n") || strings.Contains(strY, "\n")

-}

-

-func multiLineDiffResult(diff string) Result {

-	return ResultFailureTemplate(`

-+++ {{ with callArg 1 }}{{ formatNode . }}{{else}}→{{end}}

-{{ .Data.diff }}`,

-		map[string]interface{}{"diff": diff})

-}

-

-// Len succeeds if the sequence has the expected length.

-func Len(seq interface{}, expected int) Comparison {

-	return func() (result Result) {

-		defer func() {

-			if e := recover(); e != nil {

-				result = ResultFailure(fmt.Sprintf("type %T does not have a length", seq))

-			}

-		}()

-		value := reflect.ValueOf(seq)

-		length := value.Len()

-		if length == expected {

-			return ResultSuccess

-		}

-		msg := fmt.Sprintf("expected %s (length %d) to have length %d", seq, length, expected)

-		return ResultFailure(msg)

-	}

-}

-

-// Contains succeeds if item is in collection. Collection may be a string, map,

-// slice, or array.

-//

-// If collection is a string, item must also be a string, and is compared using

-// strings.Contains().

-// If collection is a Map, contains will succeed if item is a key in the map.

-// If collection is a slice or array, item is compared to each item in the

-// sequence using reflect.DeepEqual().

-func Contains(collection interface{}, item interface{}) Comparison {

-	return func() Result {

-		colValue := reflect.ValueOf(collection)

-		if !colValue.IsValid() {

-			return ResultFailure(fmt.Sprintf("nil does not contain items"))

-		}

-		msg := fmt.Sprintf("%v does not contain %v", collection, item)

-

-		itemValue := reflect.ValueOf(item)

-		switch colValue.Type().Kind() {

-		case reflect.String:

-			if itemValue.Type().Kind() != reflect.String {

-				return ResultFailure("string may only contain strings")

-			}

-			return toResult(

-				strings.Contains(colValue.String(), itemValue.String()),

-				fmt.Sprintf("string %q does not contain %q", collection, item))

-

-		case reflect.Map:

-			if itemValue.Type() != colValue.Type().Key() {

-				return ResultFailure(fmt.Sprintf(

-					"%v can not contain a %v key", colValue.Type(), itemValue.Type()))

-			}

-			return toResult(colValue.MapIndex(itemValue).IsValid(), msg)

-

-		case reflect.Slice, reflect.Array:

-			for i := 0; i < colValue.Len(); i++ {

-				if reflect.DeepEqual(colValue.Index(i).Interface(), item) {

-					return ResultSuccess

-				}

-			}

-			return ResultFailure(msg)

-		default:

-			return ResultFailure(fmt.Sprintf("type %T does not contain items", collection))

-		}

-	}

-}

-

-// Panics succeeds if f() panics.

-func Panics(f func()) Comparison {

-	return func() (result Result) {

-		defer func() {

-			if err := recover(); err != nil {

-				result = ResultSuccess

-			}

-		}()

-		f()

-		return ResultFailure("did not panic")

-	}

-}

-

-// Error succeeds if err is a non-nil error, and the error message equals the

-// expected message.

-func Error(err error, message string) Comparison {

-	return func() Result {

-		switch {

-		case err == nil:

-			return ResultFailure("expected an error, got nil")

-		case err.Error() != message:

-			return ResultFailure(fmt.Sprintf(

-				"expected error %q, got %s", message, formatErrorMessage(err)))

-		}

-		return ResultSuccess

-	}

-}

-

-// ErrorContains succeeds if err is a non-nil error, and the error message contains

-// the expected substring.

-func ErrorContains(err error, substring string) Comparison {

-	return func() Result {

-		switch {

-		case err == nil:

-			return ResultFailure("expected an error, got nil")

-		case !strings.Contains(err.Error(), substring):

-			return ResultFailure(fmt.Sprintf(

-				"expected error to contain %q, got %s", substring, formatErrorMessage(err)))

-		}

-		return ResultSuccess

-	}

-}

-

-func formatErrorMessage(err error) string {

-	if _, ok := err.(interface {

-		Cause() error

-	}); ok {

-		return fmt.Sprintf("%q\n%+v", err, err)

-	}

-	// This error was not wrapped with github.com/pkg/errors

-	return fmt.Sprintf("%q", err)

-}

-

-// Nil succeeds if obj is a nil interface, pointer, or function.

-//

-// Use NilError() for comparing errors. Use Len(obj, 0) for comparing slices,

-// maps, and channels.

-func Nil(obj interface{}) Comparison {

-	msgFunc := func(value reflect.Value) string {

-		return fmt.Sprintf("%v (type %s) is not nil", reflect.Indirect(value), value.Type())

-	}

-	return isNil(obj, msgFunc)

-}

-

-func isNil(obj interface{}, msgFunc func(reflect.Value) string) Comparison {

-	return func() Result {

-		if obj == nil {

-			return ResultSuccess

-		}

-		value := reflect.ValueOf(obj)

-		kind := value.Type().Kind()

-		if kind >= reflect.Chan && kind <= reflect.Slice {

-			if value.IsNil() {

-				return ResultSuccess

-			}

-			return ResultFailure(msgFunc(value))

-		}

-

-		return ResultFailure(fmt.Sprintf("%v (type %s) can not be nil", value, value.Type()))

-	}

-}

-

-// ErrorType succeeds if err is not nil and is of the expected type.

-//

-// Expected can be one of:

-// a func(error) bool which returns true if the error is the expected type,

-// an instance of (or a pointer to) a struct of the expected type,

-// a pointer to an interface the error is expected to implement,

-// a reflect.Type of the expected struct or interface.

-func ErrorType(err error, expected interface{}) Comparison {

-	return func() Result {

-		switch expectedType := expected.(type) {

-		case func(error) bool:

-			return cmpErrorTypeFunc(err, expectedType)

-		case reflect.Type:

-			if expectedType.Kind() == reflect.Interface {

-				return cmpErrorTypeImplementsType(err, expectedType)

-			}

-			return cmpErrorTypeEqualType(err, expectedType)

-		case nil:

-			return ResultFailure(fmt.Sprintf("invalid type for expected: nil"))

-		}

-

-		expectedType := reflect.TypeOf(expected)

-		switch {

-		case expectedType.Kind() == reflect.Struct, isPtrToStruct(expectedType):

-			return cmpErrorTypeEqualType(err, expectedType)

-		case isPtrToInterface(expectedType):

-			return cmpErrorTypeImplementsType(err, expectedType.Elem())

-		}

-		return ResultFailure(fmt.Sprintf("invalid type for expected: %T", expected))

-	}

-}

-

-func cmpErrorTypeFunc(err error, f func(error) bool) Result {

-	if f(err) {

-		return ResultSuccess

-	}

-	actual := "nil"

-	if err != nil {

-		actual = fmt.Sprintf("%s (%T)", err, err)

-	}

-	return ResultFailureTemplate(`error is {{ .Data.actual }}

-		{{- with callArg 1 }}, not {{ formatNode . }}{{end -}}`,

-		map[string]interface{}{"actual": actual})

-}

-

-func cmpErrorTypeEqualType(err error, expectedType reflect.Type) Result {

-	if err == nil {

-		return ResultFailure(fmt.Sprintf("error is nil, not %s", expectedType))

-	}

-	errValue := reflect.ValueOf(err)

-	if errValue.Type() == expectedType {

-		return ResultSuccess

-	}

-	return ResultFailure(fmt.Sprintf("error is %s (%T), not %s", err, err, expectedType))

-}

-

-func cmpErrorTypeImplementsType(err error, expectedType reflect.Type) Result {

-	if err == nil {

-		return ResultFailure(fmt.Sprintf("error is nil, not %s", expectedType))

-	}

-	errValue := reflect.ValueOf(err)

-	if errValue.Type().Implements(expectedType) {

-		return ResultSuccess

-	}

-	return ResultFailure(fmt.Sprintf("error is %s (%T), not %s", err, err, expectedType))

-}

-

-func isPtrToInterface(typ reflect.Type) bool {

-	return typ.Kind() == reflect.Ptr && typ.Elem().Kind() == reflect.Interface

-}

-

-func isPtrToStruct(typ reflect.Type) bool {