diff --git a/builder/dockerfile/buildargs_test.go b/builder/dockerfile/buildargs_test.go
index 03df19b2a1..625a02b154 100644
--- a/builder/dockerfile/buildargs_test.go
+++ b/builder/dockerfile/buildargs_test.go
@@ -1,8 +1,9 @@
 package dockerfile
 
 import (
-	"github.com/docker/docker/pkg/testutil/assert"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func strPtr(source string) *string {
@@ -37,7 +38,7 @@ func TestGetAllAllowed(t *testing.T) {
 		"ArgFromMeta":                         "frommeta1",
 		"ArgFromMetaOverriden":                "fromdockerfile3",
 	}
-	assert.DeepEqual(t, all, expected)
+	assert.Equal(t, expected, all)
 }
 
 func TestGetAllMeta(t *testing.T) {
@@ -59,5 +60,5 @@ func TestGetAllMeta(t *testing.T) {
 		"ArgOverriddenByOptions":        "fromopt2",
 		"ArgNoDefaultInMetaFromOptions": "fromopt3",
 	}
-	assert.DeepEqual(t, all, expected)
+	assert.Equal(t, expected, all)
 }
diff --git a/builder/dockerfile/builder_test.go b/builder/dockerfile/builder_test.go
index 5c2fc326fe..5fedca0fdd 100644
--- a/builder/dockerfile/builder_test.go
+++ b/builder/dockerfile/builder_test.go
@@ -5,13 +5,13 @@ import (
 	"testing"
 
 	"github.com/docker/docker/builder/dockerfile/parser"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestAddNodesForLabelOption(t *testing.T) {
 	dockerfile := "FROM scratch"
 	result, err := parser.Parse(strings.NewReader(dockerfile))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	labels := map[string]string{
 		"org.e": "cli-e",
@@ -27,8 +27,8 @@ func TestAddNodesForLabelOption(t *testing.T) {
 		"FROM scratch",
 		`LABEL "org.a"='cli-a' "org.b"='cli-b' "org.c"='cli-c' "org.d"='cli-d' "org.e"='cli-e'`,
 	}
-	assert.Equal(t, len(nodes.Children), 2)
+	assert.Len(t, nodes.Children, 2)
 	for i, v := range nodes.Children {
-		assert.Equal(t, v.Original, expected[i])
+		assert.Equal(t, expected[i], v.Original)
 	}
 }
diff --git a/builder/dockerfile/dispatchers_test.go b/builder/dockerfile/dispatchers_test.go
index 644b610825..a504540e3d 100644
--- a/builder/dockerfile/dispatchers_test.go
+++ b/builder/dockerfile/dispatchers_test.go
@@ -10,8 +10,8 @@ import (
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/strslice"
 	"github.com/docker/docker/builder"
-	"github.com/docker/docker/pkg/testutil/assert"
 	"github.com/docker/go-connections/nat"
+	"github.com/stretchr/testify/assert"
 )
 
 type commandWithFunction struct {
@@ -137,13 +137,13 @@ func TestEnv2Variables(t *testing.T) {
 
 	args := []string{"var1", "val1", "var2", "val2"}
 	err := env(b, args, nil, "")
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	expected := []string{
 		fmt.Sprintf("%s=%s", args[0], args[1]),
 		fmt.Sprintf("%s=%s", args[2], args[3]),
 	}
-	assert.DeepEqual(t, b.runConfig.Env, expected)
+	assert.Equal(t, expected, b.runConfig.Env)
 }
 
 func TestEnvValueWithExistingRunConfigEnv(t *testing.T) {
@@ -153,13 +153,13 @@ func TestEnvValueWithExistingRunConfigEnv(t *testing.T) {
 
 	args := []string{"var1", "val1"}
 	err := env(b, args, nil, "")
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	expected := []string{
 		fmt.Sprintf("%s=%s", args[0], args[1]),
 		"var2=fromenv",
 	}
-	assert.DeepEqual(t, b.runConfig.Env, expected)
+	assert.Equal(t, expected, b.runConfig.Env)
 }
 
 func TestMaintainer(t *testing.T) {
@@ -215,40 +215,40 @@ func TestFromScratch(t *testing.T) {
 	err := from(b, []string{"scratch"}, nil, "")
 
 	if runtime.GOOS == "windows" {
-		assert.Error(t, err, "Windows does not support FROM scratch")
+		assert.EqualError(t, err, "Windows does not support FROM scratch")
 		return
 	}
 
-	assert.NilError(t, err)
-	assert.Equal(t, b.image, "")
-	assert.Equal(t, b.noBaseImage, true)
+	assert.NoError(t, err)
+	assert.Equal(t, "", b.image)
+	assert.Equal(t, true, b.noBaseImage)
 }
 
 func TestFromWithArg(t *testing.T) {
 	tag, expected := ":sometag", "expectedthisid"
 
 	getImage := func(name string) (builder.Image, error) {
-		assert.Equal(t, name, "alpine"+tag)
+		assert.Equal(t, "alpine"+tag, name)
 		return &mockImage{id: "expectedthisid"}, nil
 	}
 	b := newBuilderWithMockBackend()
 	b.docker.(*MockBackend).getImageOnBuildFunc = getImage
 
-	assert.NilError(t, arg(b, []string{"THETAG=" + tag}, nil, ""))
+	assert.NoError(t, arg(b, []string{"THETAG=" + tag}, nil, ""))
 	err := from(b, []string{"alpine${THETAG}"}, nil, "")
 
-	assert.NilError(t, err)
-	assert.Equal(t, b.image, expected)
-	assert.Equal(t, b.from.ImageID(), expected)
-	assert.Equal(t, len(b.buildArgs.GetAllAllowed()), 0)
-	assert.Equal(t, len(b.buildArgs.GetAllMeta()), 1)
+	assert.NoError(t, err)
+	assert.Equal(t, expected, b.image)
+	assert.Equal(t, expected, b.from.ImageID())
+	assert.Len(t, b.buildArgs.GetAllAllowed(), 0)
+	assert.Len(t, b.buildArgs.GetAllMeta(), 1)
 }
 
 func TestFromWithUndefinedArg(t *testing.T) {
 	tag, expected := "sometag", "expectedthisid"
 
 	getImage := func(name string) (builder.Image, error) {
-		assert.Equal(t, name, "alpine")
+		assert.Equal(t, "alpine", name)
 		return &mockImage{id: "expectedthisid"}, nil
 	}
 	b := newBuilderWithMockBackend()
@@ -256,8 +256,8 @@ func TestFromWithUndefinedArg(t *testing.T) {
 	b.options.BuildArgs = map[string]*string{"THETAG": &tag}
 
 	err := from(b, []string{"alpine${THETAG}"}, nil, "")
-	assert.NilError(t, err)
-	assert.Equal(t, b.image, expected)
+	assert.NoError(t, err)
+	assert.Equal(t, expected, b.image)
 }
 
 func TestOnbuildIllegalTriggers(t *testing.T) {
@@ -508,11 +508,11 @@ func TestArg(t *testing.T) {
 	argDef := fmt.Sprintf("%s=%s", argName, argVal)
 
 	err := arg(b, []string{argDef}, nil, "")
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	expected := map[string]string{argName: argVal}
 	allowed := b.buildArgs.GetAllAllowed()
-	assert.DeepEqual(t, allowed, expected)
+	assert.Equal(t, expected, allowed)
 }
 
 func TestShell(t *testing.T) {
diff --git a/builder/dockerfile/internals_test.go b/builder/dockerfile/internals_test.go
index 1bffecfa75..b979401467 100644
--- a/builder/dockerfile/internals_test.go
+++ b/builder/dockerfile/internals_test.go
@@ -7,7 +7,8 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/builder"
 	"github.com/docker/docker/pkg/archive"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestEmptyDockerfile(t *testing.T) {
@@ -38,7 +39,7 @@ func TestDockerfileOutsideTheBuildContext(t *testing.T) {
 	contextDir, cleanup := createTestTempDir(t, "", "builder-dockerfile-test")
 	defer cleanup()
 
-	expectedError := "Forbidden path outside the build context"
+	expectedError := "Forbidden path outside the build context: ../../Dockerfile ()"
 
 	readAndCheckDockerfile(t, "DockerfileOutsideTheBuildContext", contextDir, "../../Dockerfile", expectedError)
 }
@@ -54,7 +55,7 @@ func TestNonExistingDockerfile(t *testing.T) {
 
 func readAndCheckDockerfile(t *testing.T, testName, contextDir, dockerfilePath, expectedError string) {
 	tarStream, err := archive.Tar(contextDir, archive.Uncompressed)
-	assert.NilError(t, err)
+	require.NoError(t, err)
 
 	defer func() {
 		if err = tarStream.Close(); err != nil {
@@ -63,7 +64,7 @@ func readAndCheckDockerfile(t *testing.T, testName, contextDir, dockerfilePath,
 	}()
 
 	context, err := builder.MakeTarSumContext(tarStream)
-	assert.NilError(t, err)
+	require.NoError(t, err)
 
 	defer func() {
 		if err = context.Close(); err != nil {
@@ -78,5 +79,5 @@ func readAndCheckDockerfile(t *testing.T, testName, contextDir, dockerfilePath,
 	b := &Builder{options: options, context: context}
 
 	_, err = b.readAndParseDockerfile()
-	assert.Error(t, err, expectedError)
+	assert.EqualError(t, err, expectedError)
 }
diff --git a/builder/dockerfile/parser/line_parsers_test.go b/builder/dockerfile/parser/line_parsers_test.go
index 30b6bdd824..cd6d57af3a 100644
--- a/builder/dockerfile/parser/line_parsers_test.go
+++ b/builder/dockerfile/parser/line_parsers_test.go
@@ -1,26 +1,27 @@
 package parser
 
 import (
-	"github.com/docker/docker/pkg/testutil/assert"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestParseNameValOldFormat(t *testing.T) {
 	directive := Directive{}
 	node, err := parseNameVal("foo bar", "LABEL", &directive)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	expected := &Node{
 		Value: "foo",
 		Next:  &Node{Value: "bar"},
 	}
-	assert.DeepEqual(t, node, expected)
+	assert.Equal(t, expected, node)
 }
 
 func TestParseNameValNewFormat(t *testing.T) {
 	directive := Directive{}
 	node, err := parseNameVal("foo=bar thing=star", "LABEL", &directive)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	expected := &Node{
 		Value: "foo",
@@ -34,7 +35,7 @@ func TestParseNameValNewFormat(t *testing.T) {
 			},
 		},
 	}
-	assert.DeepEqual(t, node, expected)
+	assert.Equal(t, expected, node)
 }
 
 func TestNodeFromLabels(t *testing.T) {
@@ -60,6 +61,6 @@ func TestNodeFromLabels(t *testing.T) {
 	}
 
 	node := NodeFromLabels(labels)
-	assert.DeepEqual(t, node, expected)
+	assert.Equal(t, expected, node)
 
 }
diff --git a/builder/dockerfile/parser/parser_test.go b/builder/dockerfile/parser/parser_test.go
index 7f273002c7..99b614ba9f 100644
--- a/builder/dockerfile/parser/parser_test.go
+++ b/builder/dockerfile/parser/parser_test.go
@@ -9,7 +9,8 @@ import (
 	"runtime"
 	"testing"
 
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const testDir = "testfiles"
@@ -18,11 +19,11 @@ const testFileLineInfo = "testfile-line/Dockerfile"
 
 func getDirs(t *testing.T, dir string) []string {
 	f, err := os.Open(dir)
-	assert.NilError(t, err)
+	require.NoError(t, err)
 	defer f.Close()
 
 	dirs, err := f.Readdirnames(0)
-	assert.NilError(t, err)
+	require.NoError(t, err)
 	return dirs
 }
 
@@ -31,11 +32,11 @@ func TestTestNegative(t *testing.T) {
 		dockerfile := filepath.Join(negativeTestDir, dir, "Dockerfile")
 
 		df, err := os.Open(dockerfile)
-		assert.NilError(t, err)
+		require.NoError(t, err)
 		defer df.Close()
 
 		_, err = Parse(df)
-		assert.Error(t, err, "")
+		assert.Error(t, err)
 	}
 }
 
@@ -45,21 +46,21 @@ func TestTestData(t *testing.T) {
 		resultfile := filepath.Join(testDir, dir, "result")
 
 		df, err := os.Open(dockerfile)
-		assert.NilError(t, err)
+		require.NoError(t, err)
 		defer df.Close()
 
 		result, err := Parse(df)
-		assert.NilError(t, err)
+		require.NoError(t, err)
 
 		content, err := ioutil.ReadFile(resultfile)
-		assert.NilError(t, err)
+		require.NoError(t, err)
 
 		if runtime.GOOS == "windows" {
 			// CRLF --> CR to match Unix behavior
 			content = bytes.Replace(content, []byte{'\x0d', '\x0a'}, []byte{'\x0a'}, -1)
 		}
 
-		assert.Equal(t, result.AST.Dump()+"\n", string(content), "In "+dockerfile)
+		assert.Contains(t, result.AST.Dump()+"\n", string(content), "In "+dockerfile)
 	}
 }
 
@@ -101,24 +102,24 @@ func TestParseWords(t *testing.T) {
 
 	for _, test := range tests {
 		words := parseWords(test["input"][0], NewDefaultDirective())
-		assert.DeepEqual(t, words, test["expect"])
+		assert.Equal(t, test["expect"], words)
 	}
 }
 
 func TestLineInformation(t *testing.T) {
 	df, err := os.Open(testFileLineInfo)
-	assert.NilError(t, err)
+	require.NoError(t, err)
 	defer df.Close()
 
 	result, err := Parse(df)
-	assert.NilError(t, err)
+	require.NoError(t, err)
 
 	ast := result.AST
 	if ast.StartLine != 5 || ast.endLine != 31 {
 		fmt.Fprintf(os.Stderr, "Wrong root line information: expected(%d-%d), actual(%d-%d)\n", 5, 31, ast.StartLine, ast.endLine)
 		t.Fatal("Root line information doesn't match result.")
 	}
-	assert.Equal(t, len(ast.Children), 3)
+	assert.Len(t, ast.Children, 3)
 	expected := [][]int{
 		{5, 5},
 		{11, 12},
diff --git a/builder/dockerfile/shell_parser_test.go b/builder/dockerfile/shell_parser_test.go
index 67e3e2e2fd..da4125488b 100644
--- a/builder/dockerfile/shell_parser_test.go
+++ b/builder/dockerfile/shell_parser_test.go
@@ -7,7 +7,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestShellParser4EnvVars(t *testing.T) {
@@ -15,7 +15,7 @@ func TestShellParser4EnvVars(t *testing.T) {
 	lineCount := 0
 
 	file, err := os.Open(fn)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 	defer file.Close()
 
 	scanner := bufio.NewScanner(file)
@@ -36,7 +36,7 @@ func TestShellParser4EnvVars(t *testing.T) {
 		}
 
 		words := strings.Split(line, "|")
-		assert.Equal(t, len(words), 3)
+		assert.Len(t, words, 3)
 
 		platform := strings.TrimSpace(words[0])
 		source := strings.TrimSpace(words[1])
@@ -51,9 +51,9 @@ func TestShellParser4EnvVars(t *testing.T) {
 			((platform == "U" || platform == "A") && runtime.GOOS != "windows") {
 			newWord, err := ProcessWord(source, envs, '\\')
 			if expected == "error" {
-				assert.Error(t, err, "")
+				assert.Error(t, err)
 			} else {
-				assert.NilError(t, err)
+				assert.NoError(t, err)
 				assert.Equal(t, newWord, expected)
 			}
 		}
diff --git a/cli/command/bundlefile/bundlefile_test.go b/cli/command/bundlefile/bundlefile_test.go
index c343410df3..bd059c4dca 100644
--- a/cli/command/bundlefile/bundlefile_test.go
+++ b/cli/command/bundlefile/bundlefile_test.go
@@ -5,7 +5,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestLoadFileV01Success(t *testing.T) {
@@ -25,9 +25,9 @@ func TestLoadFileV01Success(t *testing.T) {
 	}`)
 
 	bundle, err := LoadFile(reader)
-	assert.NilError(t, err)
-	assert.Equal(t, bundle.Version, "0.1")
-	assert.Equal(t, len(bundle.Services), 2)
+	assert.NoError(t, err)
+	assert.Equal(t, "0.1", bundle.Version)
+	assert.Len(t, bundle.Services, 2)
 }
 
 func TestLoadFileSyntaxError(t *testing.T) {
@@ -37,7 +37,7 @@ func TestLoadFileSyntaxError(t *testing.T) {
 	}`)
 
 	_, err := LoadFile(reader)
-	assert.Error(t, err, "syntax error at byte 37: invalid character 'u'")
+	assert.EqualError(t, err, "JSON syntax error at byte 37: invalid character 'u' looking for beginning of value")
 }
 
 func TestLoadFileTypeError(t *testing.T) {
@@ -52,7 +52,7 @@ func TestLoadFileTypeError(t *testing.T) {
 	}`)
 
 	_, err := LoadFile(reader)
-	assert.Error(t, err, "Unexpected type at byte 94. Expected []string but received string")
+	assert.EqualError(t, err, "Unexpected type at byte 94. Expected []string but received string.")
 }
 
 func TestPrint(t *testing.T) {
@@ -66,7 +66,7 @@ func TestPrint(t *testing.T) {
 			},
 		},
 	}
-	assert.NilError(t, Print(&buffer, bundle))
+	assert.NoError(t, Print(&buffer, bundle))
 	output := buffer.String()
 	assert.Contains(t, output, "\"Image\": \"image\"")
 	assert.Contains(t, output,
diff --git a/cli/command/container/opts_test.go b/cli/command/container/opts_test.go
index 575b214edc..2d0049768a 100644
--- a/cli/command/container/opts_test.go
+++ b/cli/command/container/opts_test.go
@@ -13,11 +13,12 @@ import (
 
 	"github.com/docker/docker/api/types/container"
 	networktypes "github.com/docker/docker/api/types/network"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/docker/docker/runconfig"
 	"github.com/docker/go-connections/nat"
 	"github.com/pkg/errors"
 	"github.com/spf13/pflag"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestValidateAttach(t *testing.T) {
@@ -243,23 +244,23 @@ func TestParseWithMacAddress(t *testing.T) {
 func TestParseWithMemory(t *testing.T) {
 	invalidMemory := "--memory=invalid"
 	_, _, _, err := parseRun([]string{invalidMemory, "img", "cmd"})
-	assert.Error(t, err, invalidMemory)
+	testutil.ErrorContains(t, err, invalidMemory)
 
 	_, hostconfig := mustParse(t, "--memory=1G")
-	assert.Equal(t, hostconfig.Memory, int64(1073741824))
+	assert.Equal(t, int64(1073741824), hostconfig.Memory)
 }
 
 func TestParseWithMemorySwap(t *testing.T) {
 	invalidMemory := "--memory-swap=invalid"
 
 	_, _, _, err := parseRun([]string{invalidMemory, "img", "cmd"})
-	assert.Error(t, err, invalidMemory)
+	testutil.ErrorContains(t, err, invalidMemory)
 
 	_, hostconfig := mustParse(t, "--memory-swap=1G")
-	assert.Equal(t, hostconfig.MemorySwap, int64(1073741824))
+	assert.Equal(t, int64(1073741824), hostconfig.MemorySwap)
 
 	_, hostconfig = mustParse(t, "--memory-swap=-1")
-	assert.Equal(t, hostconfig.MemorySwap, int64(-1))
+	assert.Equal(t, int64(-1), hostconfig.MemorySwap)
 }
 
 func TestParseHostname(t *testing.T) {
diff --git a/cli/command/container/ps_test.go b/cli/command/container/ps_test.go
index 62b0545274..47665b0e2c 100644
--- a/cli/command/container/ps_test.go
+++ b/cli/command/container/ps_test.go
@@ -4,13 +4,13 @@ import (
 	"testing"
 
 	"github.com/docker/docker/opts"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestBuildContainerListOptions(t *testing.T) {
 	filters := opts.NewFilterOpt()
-	assert.NilError(t, filters.Set("foo=bar"))
-	assert.NilError(t, filters.Set("baz=foo"))
+	assert.NoError(t, filters.Set("foo=bar"))
+	assert.NoError(t, filters.Set("baz=foo"))
 
 	contexts := []struct {
 		psOpts          *psOptions
@@ -101,12 +101,12 @@ func TestBuildContainerListOptions(t *testing.T) {
 
 	for _, c := range contexts {
 		options, err := buildContainerListOptions(c.psOpts)
-		assert.NilError(t, err)
+		assert.NoError(t, err)
 
 		assert.Equal(t, c.expectedAll, options.All)
 		assert.Equal(t, c.expectedSize, options.Size)
 		assert.Equal(t, c.expectedLimit, options.Limit)
-		assert.Equal(t, options.Filters.Len(), len(c.expectedFilters))
+		assert.Equal(t, len(c.expectedFilters), options.Filters.Len())
 
 		for k, v := range c.expectedFilters {
 			f := options.Filters
diff --git a/cli/command/formatter/container_test.go b/cli/command/formatter/container_test.go
index a5615d1768..8d23cc781c 100644
--- a/cli/command/formatter/container_test.go
+++ b/cli/command/formatter/container_test.go
@@ -10,7 +10,7 @@ import (
 
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/stringid"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestContainerPsContext(t *testing.T) {
@@ -245,9 +245,9 @@ conta               "ubuntu" 24 hours ago//.FOOBAR_BAR
 		testcase.context.Output = out
 		err := ContainerWrite(testcase.context, containers)
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Equal(t, out.String(), testcase.expected)
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
@@ -334,7 +334,7 @@ func TestContainerContextWriteJSON(t *testing.T) {
 		if err := json.Unmarshal([]byte(line), &m); err != nil {
 			t.Fatal(err)
 		}
-		assert.DeepEqual(t, m, expectedJSONs[i])
+		assert.Equal(t, expectedJSONs[i], m)
 	}
 }
 
@@ -354,7 +354,7 @@ func TestContainerContextWriteJSONField(t *testing.T) {
 		if err := json.Unmarshal([]byte(line), &s); err != nil {
 			t.Fatal(err)
 		}
-		assert.Equal(t, s, containers[i].ID)
+		assert.Equal(t, containers[i].ID, s)
 	}
 }
 
diff --git a/cli/command/formatter/diff_test.go b/cli/command/formatter/diff_test.go
index 52080354f5..1aa7b53056 100644
--- a/cli/command/formatter/diff_test.go
+++ b/cli/command/formatter/diff_test.go
@@ -6,7 +6,7 @@ import (
 
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/pkg/archive"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestDiffContextFormatWrite(t *testing.T) {
@@ -51,9 +51,9 @@ D: /usr/app/old_app.js
 		testcase.context.Output = out
 		err := DiffWrite(testcase.context, diffs)
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Equal(t, out.String(), testcase.expected)
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
diff --git a/cli/command/formatter/disk_usage_test.go b/cli/command/formatter/disk_usage_test.go
index 7093cfe85a..302eb2c8f7 100644
--- a/cli/command/formatter/disk_usage_test.go
+++ b/cli/command/formatter/disk_usage_test.go
@@ -4,7 +4,7 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestDiskUsageContextFormatWrite(t *testing.T) {
@@ -117,9 +117,9 @@ reclaimable: 0B
 		out := bytes.NewBufferString("")
 		testcase.context.Output = out
 		if err := testcase.context.Write(); err != nil {
-			assert.Equal(t, err.Error(), testcase.expected)
+			assert.Equal(t, testcase.expected, err.Error())
 		} else {
-			assert.Equal(t, out.String(), testcase.expected)
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
diff --git a/cli/command/formatter/image_test.go b/cli/command/formatter/image_test.go
index e7c15dbf5a..b3c4cc8094 100644
--- a/cli/command/formatter/image_test.go
+++ b/cli/command/formatter/image_test.go
@@ -9,7 +9,7 @@ import (
 
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/stringid"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestImageContext(t *testing.T) {
@@ -265,9 +265,9 @@ image_id: imageID3
 		testcase.context.Output = out
 		err := ImageWrite(testcase.context, images)
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Equal(t, out.String(), testcase.expected)
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
@@ -320,7 +320,7 @@ func TestImageContextWriteWithNoImage(t *testing.T) {
 
 	for _, context := range contexts {
 		ImageWrite(context.context, images)
-		assert.Equal(t, out.String(), context.expected)
+		assert.Equal(t, context.expected, out.String())
 		// Clean buffer
 		out.Reset()
 	}
diff --git a/cli/command/formatter/network_test.go b/cli/command/formatter/network_test.go
index 24bf46d256..b8cab078e7 100644
--- a/cli/command/formatter/network_test.go
+++ b/cli/command/formatter/network_test.go
@@ -9,7 +9,7 @@ import (
 
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/stringid"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestNetworkContext(t *testing.T) {
@@ -160,9 +160,9 @@ foobar_bar 2017-01-01 00:00:00 +0000 UTC
 		testcase.context.Output = out
 		err := NetworkWrite(testcase.context, networks)
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Equal(t, out.String(), testcase.expected)
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
@@ -188,7 +188,7 @@ func TestNetworkContextWriteJSON(t *testing.T) {
 		if err := json.Unmarshal([]byte(line), &m); err != nil {
 			t.Fatal(err)
 		}
-		assert.DeepEqual(t, m, expectedJSONs[i])
+		assert.Equal(t, expectedJSONs[i], m)
 	}
 }
 
@@ -208,6 +208,6 @@ func TestNetworkContextWriteJSONField(t *testing.T) {
 		if err := json.Unmarshal([]byte(line), &s); err != nil {
 			t.Fatal(err)
 		}
-		assert.Equal(t, s, networks[i].ID)
+		assert.Equal(t, networks[i].ID, s)
 	}
 }
diff --git a/cli/command/formatter/node_test.go b/cli/command/formatter/node_test.go
index 86f4979d3f..ea2f4ce4d5 100644
--- a/cli/command/formatter/node_test.go
+++ b/cli/command/formatter/node_test.go
@@ -9,7 +9,7 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/swarm"
 	"github.com/docker/docker/pkg/stringid"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestNodeContext(t *testing.T) {
@@ -135,9 +135,9 @@ foobar_bar
 		testcase.context.Output = out
 		err := NodeWrite(testcase.context, nodes, types.Info{})
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Equal(t, out.String(), testcase.expected)
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
@@ -163,7 +163,7 @@ func TestNodeContextWriteJSON(t *testing.T) {
 		if err := json.Unmarshal([]byte(line), &m); err != nil {
 			t.Fatal(err)
 		}
-		assert.DeepEqual(t, m, expectedJSONs[i])
+		assert.Equal(t, expectedJSONs[i], m)
 	}
 }
 
@@ -183,6 +183,6 @@ func TestNodeContextWriteJSONField(t *testing.T) {
 		if err := json.Unmarshal([]byte(line), &s); err != nil {
 			t.Fatal(err)
 		}
-		assert.Equal(t, s, nodes[i].ID)
+		assert.Equal(t, nodes[i].ID, s)
 	}
 }
diff --git a/cli/command/formatter/plugin_test.go b/cli/command/formatter/plugin_test.go
index 3cc0af8a3e..607262dcc9 100644
--- a/cli/command/formatter/plugin_test.go
+++ b/cli/command/formatter/plugin_test.go
@@ -8,7 +8,7 @@ import (
 
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/stringid"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestPluginContext(t *testing.T) {
@@ -131,9 +131,9 @@ foobar_bar
 		testcase.context.Output = out
 		err := PluginWrite(testcase.context, plugins)
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Equal(t, out.String(), testcase.expected)
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
@@ -158,7 +158,7 @@ func TestPluginContextWriteJSON(t *testing.T) {
 		if err := json.Unmarshal([]byte(line), &m); err != nil {
 			t.Fatal(err)
 		}
-		assert.DeepEqual(t, m, expectedJSONs[i])
+		assert.Equal(t, expectedJSONs[i], m)
 	}
 }
 
@@ -177,6 +177,6 @@ func TestPluginContextWriteJSONField(t *testing.T) {
 		if err := json.Unmarshal([]byte(line), &s); err != nil {
 			t.Fatal(err)
 		}
-		assert.Equal(t, s, plugins[i].ID)
+		assert.Equal(t, plugins[i].ID, s)
 	}
 }
diff --git a/cli/command/formatter/secret_test.go b/cli/command/formatter/secret_test.go
index 722b650565..98fe61315f 100644
--- a/cli/command/formatter/secret_test.go
+++ b/cli/command/formatter/secret_test.go
@@ -6,7 +6,7 @@ import (
 	"time"
 
 	"github.com/docker/docker/api/types/swarm"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestSecretContextFormatWrite(t *testing.T) {
@@ -55,9 +55,9 @@ id_rsa
 		out := bytes.NewBufferString("")
 		testcase.context.Output = out
 		if err := SecretWrite(testcase.context, secrets); err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Equal(t, out.String(), testcase.expected)
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
diff --git a/cli/command/formatter/service_test.go b/cli/command/formatter/service_test.go
index 93ffc92a3b..629f853930 100644
--- a/cli/command/formatter/service_test.go
+++ b/cli/command/formatter/service_test.go
@@ -7,7 +7,7 @@ import (
 	"testing"
 
 	"github.com/docker/docker/api/types/swarm"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestServiceContextWrite(t *testing.T) {
@@ -137,9 +137,9 @@ bar
 		testcase.context.Output = out
 		err := ServiceListWrite(testcase.context, services, info)
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Equal(t, out.String(), testcase.expected)
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
@@ -205,7 +205,7 @@ func TestServiceContextWriteJSON(t *testing.T) {
 		if err := json.Unmarshal([]byte(line), &m); err != nil {
 			t.Fatal(err)
 		}
-		assert.DeepEqual(t, m, expectedJSONs[i])
+		assert.Equal(t, expectedJSONs[i], m)
 	}
 }
 func TestServiceContextWriteJSONField(t *testing.T) {
@@ -234,6 +234,6 @@ func TestServiceContextWriteJSONField(t *testing.T) {
 		if err := json.Unmarshal([]byte(line), &s); err != nil {
 			t.Fatal(err)
 		}
-		assert.Equal(t, s, services[i].Spec.Name)
+		assert.Equal(t, services[i].Spec.Name, s)
 	}
 }
diff --git a/cli/command/formatter/stats_test.go b/cli/command/formatter/stats_test.go
index 5d6a91e7c9..078e8db32a 100644
--- a/cli/command/formatter/stats_test.go
+++ b/cli/command/formatter/stats_test.go
@@ -5,7 +5,7 @@ import (
 	"testing"
 
 	"github.com/docker/docker/pkg/stringid"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestContainerStatsContext(t *testing.T) {
@@ -116,9 +116,9 @@ container2  --
 		te.context.Output = &out
 		err := ContainerStatsWrite(te.context, stats, "linux")
 		if err != nil {
-			assert.Error(t, err, te.expected)
+			assert.EqualError(t, err, te.expected)
 		} else {
-			assert.Equal(t, out.String(), te.expected)
+			assert.Equal(t, te.expected, out.String())
 		}
 	}
 }
@@ -182,9 +182,9 @@ container2  --  --
 		te.context.Output = &out
 		err := ContainerStatsWrite(te.context, stats, "windows")
 		if err != nil {
-			assert.Error(t, err, te.expected)
+			assert.EqualError(t, err, te.expected)
 		} else {
-			assert.Equal(t, out.String(), te.expected)
+			assert.Equal(t, te.expected, out.String())
 		}
 	}
 }
@@ -259,7 +259,7 @@ func TestContainerStatsContextWriteWithNoStatsWindows(t *testing.T) {
 
 	for _, context := range contexts {
 		ContainerStatsWrite(context.context, []StatsEntry{}, "windows")
-		assert.Equal(t, out.String(), context.expected)
+		assert.Equal(t, context.expected, out.String())
 		// Clean buffer
 		out.Reset()
 	}
diff --git a/cli/command/formatter/task_test.go b/cli/command/formatter/task_test.go
index 8de9d66f57..d2843c70d4 100644
--- a/cli/command/formatter/task_test.go
+++ b/cli/command/formatter/task_test.go
@@ -7,7 +7,7 @@ import (
 	"testing"
 
 	"github.com/docker/docker/api/types/swarm"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestTaskContextWrite(t *testing.T) {
@@ -76,9 +76,9 @@ foobar_bar foo2
 		testcase.context.Output = out
 		err := TaskWrite(testcase.context, tasks, names, nodes)
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Equal(t, out.String(), testcase.expected)
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
@@ -102,6 +102,6 @@ func TestTaskContextWriteJSONField(t *testing.T) {
 		if err := json.Unmarshal([]byte(line), &s); err != nil {
 			t.Fatal(err)
 		}
-		assert.Equal(t, s, tasks[i].ID)
+		assert.Equal(t, tasks[i].ID, s)
 	}
 }
diff --git a/cli/command/formatter/volume_test.go b/cli/command/formatter/volume_test.go
index 9c23ae447d..bf1100893f 100644
--- a/cli/command/formatter/volume_test.go
+++ b/cli/command/formatter/volume_test.go
@@ -8,7 +8,7 @@ import (
 
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/stringid"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestVolumeContext(t *testing.T) {
@@ -131,9 +131,9 @@ foobar_bar
 		testcase.context.Output = out
 		err := VolumeWrite(testcase.context, volumes)
 		if err != nil {
-			assert.Error(t, err, testcase.expected)
+			assert.EqualError(t, err, testcase.expected)
 		} else {
-			assert.Equal(t, out.String(), testcase.expected)
+			assert.Equal(t, testcase.expected, out.String())
 		}
 	}
 }
@@ -158,7 +158,7 @@ func TestVolumeContextWriteJSON(t *testing.T) {
 		if err := json.Unmarshal([]byte(line), &m); err != nil {
 			t.Fatal(err)
 		}
-		assert.DeepEqual(t, m, expectedJSONs[i])
+		assert.Equal(t, expectedJSONs[i], m)
 	}
 }
 
@@ -178,6 +178,6 @@ func TestVolumeContextWriteJSONField(t *testing.T) {
 		if err := json.Unmarshal([]byte(line), &s); err != nil {
 			t.Fatal(err)
 		}
-		assert.Equal(t, s, volumes[i].Name)
+		assert.Equal(t, volumes[i].Name, s)
 	}
 }
diff --git a/cli/command/idresolver/idresolver_test.go b/cli/command/idresolver/idresolver_test.go
index 720667daa1..1aca09ce96 100644
--- a/cli/command/idresolver/idresolver_test.go
+++ b/cli/command/idresolver/idresolver_test.go
@@ -6,8 +6,8 @@ import (
 	"github.com/docker/docker/api/types/swarm"
 	// Import builders to get the builder function as package function
 	. "github.com/docker/docker/cli/internal/test/builders"
-	"github.com/docker/docker/pkg/testutil/assert"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 	"golang.org/x/net/context"
 )
 
@@ -21,7 +21,7 @@ func TestResolveError(t *testing.T) {
 	idResolver := New(cli, false)
 	_, err := idResolver.Resolve(context.Background(), struct{}{}, "nodeID")
 
-	assert.Error(t, err, "unsupported type")
+	assert.EqualError(t, err, "unsupported type")
 }
 
 func TestResolveWithNoResolveOption(t *testing.T) {
@@ -40,9 +40,9 @@ func TestResolveWithNoResolveOption(t *testing.T) {
 	idResolver := New(cli, true)
 	id, err := idResolver.Resolve(context.Background(), swarm.Node{}, "nodeID")
 
-	assert.NilError(t, err)
-	assert.Equal(t, id, "nodeID")
-	assert.Equal(t, resolved, false)
+	assert.NoError(t, err)
+	assert.Equal(t, "nodeID", id)
+	assert.False(t, resolved)
 }
 
 func TestResolveWithCache(t *testing.T) {
@@ -59,11 +59,11 @@ func TestResolveWithCache(t *testing.T) {
 	ctx := context.Background()
 	for i := 0; i < 2; i++ {
 		id, err := idResolver.Resolve(ctx, swarm.Node{}, "nodeID")
-		assert.NilError(t, err)
-		assert.Equal(t, id, "node-foo")
+		assert.NoError(t, err)
+		assert.Equal(t, "node-foo", id)
 	}
 
-	assert.Equal(t, inspectCounter, 1)
+	assert.Equal(t, 1, inspectCounter)
 }
 
 func TestResolveNode(t *testing.T) {
@@ -103,8 +103,8 @@ func TestResolveNode(t *testing.T) {
 		idResolver := New(cli, false)
 		id, err := idResolver.Resolve(ctx, swarm.Node{}, tc.nodeID)
 
-		assert.NilError(t, err)
-		assert.Equal(t, id, tc.expectedID)
+		assert.NoError(t, err)
+		assert.Equal(t, tc.expectedID, id)
 	}
 }
 
@@ -138,7 +138,7 @@ func TestResolveService(t *testing.T) {
 		idResolver := New(cli, false)
 		id, err := idResolver.Resolve(ctx, swarm.Service{}, tc.serviceID)
 
-		assert.NilError(t, err)
-		assert.Equal(t, id, tc.expectedID)
+		assert.NoError(t, err)
+		assert.Equal(t, tc.expectedID, id)
 	}
 }
diff --git a/cli/command/node/demote_test.go b/cli/command/node/demote_test.go
index 710455ff56..803b9c229b 100644
--- a/cli/command/node/demote_test.go
+++ b/cli/command/node/demote_test.go
@@ -10,7 +10,8 @@ import (
 	"github.com/pkg/errors"
 	// Import builders to get the builder function as package function
 	. "github.com/docker/docker/cli/internal/test/builders"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestNodeDemoteErrors(t *testing.T) {
@@ -47,7 +48,7 @@ func TestNodeDemoteErrors(t *testing.T) {
 			}, buf))
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -66,7 +67,7 @@ func TestNodeDemoteNoChange(t *testing.T) {
 			},
 		}, buf))
 	cmd.SetArgs([]string{"nodeID"})
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 }
 
 func TestNodeDemoteMultipleNode(t *testing.T) {
@@ -84,5 +85,5 @@ func TestNodeDemoteMultipleNode(t *testing.T) {
 			},
 		}, buf))
 	cmd.SetArgs([]string{"nodeID1", "nodeID2"})
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 }
diff --git a/cli/command/node/inspect_test.go b/cli/command/node/inspect_test.go
index 9b6a04f11a..95b45d51e9 100644
--- a/cli/command/node/inspect_test.go
+++ b/cli/command/node/inspect_test.go
@@ -12,8 +12,9 @@ import (
 	"github.com/pkg/errors"
 	// Import builders to get the builder function as package function
 	. "github.com/docker/docker/cli/internal/test/builders"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/docker/docker/pkg/testutil/golden"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestNodeInspectErrors(t *testing.T) {
@@ -77,7 +78,7 @@ func TestNodeInspectErrors(t *testing.T) {
 			cmd.Flags().Set(key, value)
 		}
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -115,9 +116,9 @@ func TestNodeInspectPretty(t *testing.T) {
 			}, buf))
 		cmd.SetArgs([]string{"nodeID"})
 		cmd.Flags().Set("pretty", "true")
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 		actual := buf.String()
 		expected := golden.Get(t, []byte(actual), fmt.Sprintf("node-inspect-pretty.%s.golden", tc.name))
-		assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+		testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 	}
 }
diff --git a/cli/command/node/list_test.go b/cli/command/node/list_test.go
index 4b8d906c3a..af2d6be156 100644
--- a/cli/command/node/list_test.go
+++ b/cli/command/node/list_test.go
@@ -12,7 +12,7 @@ import (
 	"github.com/pkg/errors"
 	// Import builders to get the builder function as package function
 	. "github.com/docker/docker/cli/internal/test/builders"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestNodeListErrorOnAPIFailure(t *testing.T) {
@@ -50,7 +50,7 @@ func TestNodeListErrorOnAPIFailure(t *testing.T) {
 		cli.SetConfigfile(&configfile.ConfigFile{})
 		cmd := newListCommand(cli)
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		assert.EqualError(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -74,7 +74,7 @@ func TestNodeList(t *testing.T) {
 	}, buf)
 	cli.SetConfigfile(&configfile.ConfigFile{})
 	cmd := newListCommand(cli)
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	assert.Contains(t, buf.String(), `nodeID1 *           nodeHostname1       Ready               Active              Leader`)
 	assert.Contains(t, buf.String(), `nodeID2             nodeHostname2       Ready               Active              Reachable`)
 	assert.Contains(t, buf.String(), `nodeID3             nodeHostname3       Ready               Active`)
@@ -92,7 +92,7 @@ func TestNodeListQuietShouldOnlyPrintIDs(t *testing.T) {
 	cli.SetConfigfile(&configfile.ConfigFile{})
 	cmd := newListCommand(cli)
 	cmd.Flags().Set("quiet", "true")
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	assert.Contains(t, buf.String(), "nodeID")
 }
 
@@ -102,7 +102,7 @@ func TestNodeListContainsHostname(t *testing.T) {
 	cli := test.NewFakeCli(&fakeClient{}, buf)
 	cli.SetConfigfile(&configfile.ConfigFile{})
 	cmd := newListCommand(cli)
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	assert.Contains(t, buf.String(), "HOSTNAME")
 }
 
@@ -128,7 +128,7 @@ func TestNodeListDefaultFormat(t *testing.T) {
 		NodesFormat: "{{.ID}}: {{.Hostname}} {{.Status}}/{{.ManagerStatus}}",
 	})
 	cmd := newListCommand(cli)
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	assert.Contains(t, buf.String(), `nodeID1: nodeHostname1 Ready/Leader`)
 	assert.Contains(t, buf.String(), `nodeID2: nodeHostname2 Ready/Reachable`)
 	assert.Contains(t, buf.String(), `nodeID3: nodeHostname3 Ready`)
@@ -156,7 +156,7 @@ func TestNodeListFormat(t *testing.T) {
 	})
 	cmd := newListCommand(cli)
 	cmd.Flags().Set("format", "{{.Hostname}}: {{.ManagerStatus}}")
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	assert.Contains(t, buf.String(), `nodeHostname1: Leader`)
 	assert.Contains(t, buf.String(), `nodeHostname2: Reachable`)
 }
diff --git a/cli/command/node/promote_test.go b/cli/command/node/promote_test.go
index 9b646724d1..ce2fb13dca 100644
--- a/cli/command/node/promote_test.go
+++ b/cli/command/node/promote_test.go
@@ -10,7 +10,8 @@ import (
 	"github.com/pkg/errors"
 	// Import builders to get the builder function as package function
 	. "github.com/docker/docker/cli/internal/test/builders"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestNodePromoteErrors(t *testing.T) {
@@ -47,7 +48,7 @@ func TestNodePromoteErrors(t *testing.T) {
 			}, buf))
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -66,7 +67,7 @@ func TestNodePromoteNoChange(t *testing.T) {
 			},
 		}, buf))
 	cmd.SetArgs([]string{"nodeID"})
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 }
 
 func TestNodePromoteMultipleNode(t *testing.T) {
@@ -84,5 +85,5 @@ func TestNodePromoteMultipleNode(t *testing.T) {
 			},
 		}, buf))
 	cmd.SetArgs([]string{"nodeID1", "nodeID2"})
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 }
diff --git a/cli/command/node/ps_test.go b/cli/command/node/ps_test.go
index de6ff7d578..f604628991 100644
--- a/cli/command/node/ps_test.go
+++ b/cli/command/node/ps_test.go
@@ -13,8 +13,9 @@ import (
 	"github.com/pkg/errors"
 	// Import builders to get the builder function as package function
 	. "github.com/docker/docker/cli/internal/test/builders"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/docker/docker/pkg/testutil/golden"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestNodePsErrors(t *testing.T) {
@@ -62,7 +63,7 @@ func TestNodePsErrors(t *testing.T) {
 			cmd.Flags().Set(key, value)
 		}
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		assert.EqualError(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -125,9 +126,9 @@ func TestNodePs(t *testing.T) {
 		for key, value := range tc.flags {
 			cmd.Flags().Set(key, value)
 		}
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 		actual := buf.String()
 		expected := golden.Get(t, []byte(actual), fmt.Sprintf("node-ps.%s.golden", tc.name))
-		assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+		testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 	}
 }
diff --git a/cli/command/node/remove_test.go b/cli/command/node/remove_test.go
index d7e742aa4c..b53431dfa7 100644
--- a/cli/command/node/remove_test.go
+++ b/cli/command/node/remove_test.go
@@ -6,8 +6,9 @@ import (
 	"testing"
 
 	"github.com/docker/docker/cli/internal/test"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestNodeRemoveErrors(t *testing.T) {
@@ -35,7 +36,7 @@ func TestNodeRemoveErrors(t *testing.T) {
 			}, buf))
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -43,5 +44,5 @@ func TestNodeRemoveMultiple(t *testing.T) {
 	buf := new(bytes.Buffer)
 	cmd := newRemoveCommand(test.NewFakeCli(&fakeClient{}, buf))
 	cmd.SetArgs([]string{"nodeID1", "nodeID2"})
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 }
diff --git a/cli/command/node/update_test.go b/cli/command/node/update_test.go
index 493a386270..a5e2d20e9a 100644
--- a/cli/command/node/update_test.go
+++ b/cli/command/node/update_test.go
@@ -10,7 +10,8 @@ import (
 	"github.com/pkg/errors"
 	// Import builders to get the builder function as package function
 	. "github.com/docker/docker/cli/internal/test/builders"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestNodeUpdateErrors(t *testing.T) {
@@ -67,7 +68,7 @@ func TestNodeUpdateErrors(t *testing.T) {
 			cmd.Flags().Set(key, value)
 		}
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -167,6 +168,6 @@ func TestNodeUpdate(t *testing.T) {
 		for key, value := range tc.flags {
 			cmd.Flags().Set(key, value)
 		}
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 	}
 }
diff --git a/cli/command/secret/create_test.go b/cli/command/secret/create_test.go
index cbdfd63338..0e9c1cd4af 100644
--- a/cli/command/secret/create_test.go
+++ b/cli/command/secret/create_test.go
@@ -10,9 +10,10 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/swarm"
 	"github.com/docker/docker/cli/internal/test"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/docker/docker/pkg/testutil/golden"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 const secretDataFile = "secret-create-with-name.golden"
@@ -47,7 +48,7 @@ func TestSecretCreateErrors(t *testing.T) {
 		)
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -71,10 +72,10 @@ func TestSecretCreateWithName(t *testing.T) {
 
 	cmd := newSecretCreateCommand(cli)
 	cmd.SetArgs([]string{name, filepath.Join("testdata", secretDataFile)})
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	expected := golden.Get(t, actual, secretDataFile)
-	assert.Equal(t, string(actual), string(expected))
-	assert.Equal(t, strings.TrimSpace(buf.String()), "ID-"+name)
+	assert.Equal(t, expected, actual)
+	assert.Equal(t, "ID-"+name, strings.TrimSpace(buf.String()))
 }
 
 func TestSecretCreateWithLabels(t *testing.T) {
@@ -105,8 +106,8 @@ func TestSecretCreateWithLabels(t *testing.T) {
 	cmd.SetArgs([]string{name, filepath.Join("testdata", secretDataFile)})
 	cmd.Flags().Set("label", "lbl1=Label-foo")
 	cmd.Flags().Set("label", "lbl2=Label-bar")
-	assert.NilError(t, cmd.Execute())
-	assert.Equal(t, strings.TrimSpace(buf.String()), "ID-"+name)
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, "ID-"+name, strings.TrimSpace(buf.String()))
 }
 
 func compareMap(actual map[string]string, expected map[string]string) bool {
diff --git a/cli/command/secret/inspect_test.go b/cli/command/secret/inspect_test.go
index 558e23d7c7..52b9a1cef0 100644
--- a/cli/command/secret/inspect_test.go
+++ b/cli/command/secret/inspect_test.go
@@ -11,8 +11,9 @@ import (
 	"github.com/pkg/errors"
 	// Import builders to get the builder function as package function
 	. "github.com/docker/docker/cli/internal/test/builders"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/docker/docker/pkg/testutil/golden"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestSecretInspectErrors(t *testing.T) {
@@ -62,7 +63,7 @@ func TestSecretInspectErrors(t *testing.T) {
 			cmd.Flags().Set(key, value)
 		}
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -100,10 +101,10 @@ func TestSecretInspectWithoutFormat(t *testing.T) {
 			}, buf),
 		)
 		cmd.SetArgs(tc.args)
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 		actual := buf.String()
 		expected := golden.Get(t, []byte(actual), fmt.Sprintf("secret-inspect-without-format.%s.golden", tc.name))
-		assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+		testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 	}
 }
 
@@ -141,9 +142,9 @@ func TestSecretInspectWithFormat(t *testing.T) {
 		)
 		cmd.SetArgs(tc.args)
 		cmd.Flags().Set("format", tc.format)
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 		actual := buf.String()
 		expected := golden.Get(t, []byte(actual), fmt.Sprintf("secret-inspect-with-format.%s.golden", tc.name))
-		assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+		testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 	}
 }
diff --git a/cli/command/secret/ls_test.go b/cli/command/secret/ls_test.go
index d9a4324b75..cb0510adff 100644
--- a/cli/command/secret/ls_test.go
+++ b/cli/command/secret/ls_test.go
@@ -13,8 +13,9 @@ import (
 	"github.com/pkg/errors"
 	// Import builders to get the builder function as package function
 	. "github.com/docker/docker/cli/internal/test/builders"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/docker/docker/pkg/testutil/golden"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestSecretListErrors(t *testing.T) {
@@ -43,7 +44,7 @@ func TestSecretListErrors(t *testing.T) {
 		)
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -70,10 +71,10 @@ func TestSecretList(t *testing.T) {
 	cli.SetConfigfile(&configfile.ConfigFile{})
 	cmd := newSecretListCommand(cli)
 	cmd.SetOutput(buf)
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	actual := buf.String()
 	expected := golden.Get(t, []byte(actual), "secret-list.golden")
-	assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+	testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 }
 
 func TestSecretListWithQuietOption(t *testing.T) {
@@ -91,10 +92,10 @@ func TestSecretListWithQuietOption(t *testing.T) {
 	cli.SetConfigfile(&configfile.ConfigFile{})
 	cmd := newSecretListCommand(cli)
 	cmd.Flags().Set("quiet", "true")
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	actual := buf.String()
 	expected := golden.Get(t, []byte(actual), "secret-list-with-quiet-option.golden")
-	assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+	testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 }
 
 func TestSecretListWithConfigFormat(t *testing.T) {
@@ -113,10 +114,10 @@ func TestSecretListWithConfigFormat(t *testing.T) {
 		SecretFormat: "{{ .Name }} {{ .Labels }}",
 	})
 	cmd := newSecretListCommand(cli)
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	actual := buf.String()
 	expected := golden.Get(t, []byte(actual), "secret-list-with-config-format.golden")
-	assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+	testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 }
 
 func TestSecretListWithFormat(t *testing.T) {
@@ -133,18 +134,18 @@ func TestSecretListWithFormat(t *testing.T) {
 	}, buf)
 	cmd := newSecretListCommand(cli)
 	cmd.Flags().Set("format", "{{ .Name }} {{ .Labels }}")
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	actual := buf.String()
 	expected := golden.Get(t, []byte(actual), "secret-list-with-format.golden")
-	assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+	testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 }
 
 func TestSecretListWithFilter(t *testing.T) {
 	buf := new(bytes.Buffer)
 	cli := test.NewFakeCli(&fakeClient{
 		secretListFunc: func(options types.SecretListOptions) ([]swarm.Secret, error) {
-			assert.Equal(t, options.Filters.Get("name")[0], "foo")
-			assert.Equal(t, options.Filters.Get("label")[0], "lbl1=Label-bar")
+			assert.Equal(t, "foo", options.Filters.Get("name")[0], "foo")
+			assert.Equal(t, "lbl1=Label-bar", options.Filters.Get("label")[0])
 			return []swarm.Secret{
 				*Secret(SecretID("ID-foo"),
 					SecretName("foo"),
@@ -165,8 +166,8 @@ func TestSecretListWithFilter(t *testing.T) {
 	cmd := newSecretListCommand(cli)
 	cmd.Flags().Set("filter", "name=foo")
 	cmd.Flags().Set("filter", "label=lbl1=Label-bar")
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	actual := buf.String()
 	expected := golden.Get(t, []byte(actual), "secret-list-with-filter.golden")
-	assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+	testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 }
diff --git a/cli/command/secret/remove_test.go b/cli/command/secret/remove_test.go
index 92ca9b9b9d..b8bbb5e6f5 100644
--- a/cli/command/secret/remove_test.go
+++ b/cli/command/secret/remove_test.go
@@ -7,8 +7,9 @@ import (
 	"testing"
 
 	"github.com/docker/docker/cli/internal/test"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestSecretRemoveErrors(t *testing.T) {
@@ -38,7 +39,7 @@ func TestSecretRemoveErrors(t *testing.T) {
 		)
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -54,9 +55,9 @@ func TestSecretRemoveWithName(t *testing.T) {
 	}, buf)
 	cmd := newSecretRemoveCommand(cli)
 	cmd.SetArgs(names)
-	assert.NilError(t, cmd.Execute())
-	assert.EqualStringSlice(t, strings.Split(strings.TrimSpace(buf.String()), "\n"), names)
-	assert.EqualStringSlice(t, removedSecrets, names)
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, names, strings.Split(strings.TrimSpace(buf.String()), "\n"))
+	assert.Equal(t, names, removedSecrets)
 }
 
 func TestSecretRemoveContinueAfterError(t *testing.T) {
@@ -76,6 +77,6 @@ func TestSecretRemoveContinueAfterError(t *testing.T) {
 
 	cmd := newSecretRemoveCommand(cli)
 	cmd.SetArgs(names)
-	assert.Error(t, cmd.Execute(), "error removing secret: foo")
-	assert.EqualStringSlice(t, removedSecrets, names)
+	assert.EqualError(t, cmd.Execute(), "error removing secret: foo")
+	assert.Equal(t, names, removedSecrets)
 }
diff --git a/cli/command/service/inspect_test.go b/cli/command/service/inspect_test.go
index 44d9df9176..c5bda7dcd9 100644
--- a/cli/command/service/inspect_test.go
+++ b/cli/command/service/inspect_test.go
@@ -10,7 +10,7 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/swarm"
 	"github.com/docker/docker/cli/command/formatter"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func formatServiceInspect(t *testing.T, format formatter.Format, now time.Time) string {
@@ -136,5 +136,5 @@ func TestJSONFormatWithNoUpdateConfig(t *testing.T) {
 		t.Fatal(err)
 	}
 	t.Logf("m2=%+v", m2)
-	assert.DeepEqual(t, m2, m1)
+	assert.Equal(t, m1, m2)
 }
diff --git a/cli/command/service/opts_test.go b/cli/command/service/opts_test.go
index 46db5fc838..675fbe4b99 100644
--- a/cli/command/service/opts_test.go
+++ b/cli/command/service/opts_test.go
@@ -1,71 +1,70 @@
 package service
 
 import (
-	"reflect"
 	"testing"
 	"time"
 
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/opts"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestMemBytesString(t *testing.T) {
 	var mem opts.MemBytes = 1048576
-	assert.Equal(t, mem.String(), "1MiB")
+	assert.Equal(t, "1MiB", mem.String())
 }
 
 func TestMemBytesSetAndValue(t *testing.T) {
 	var mem opts.MemBytes
-	assert.NilError(t, mem.Set("5kb"))
-	assert.Equal(t, mem.Value(), int64(5120))
+	assert.NoError(t, mem.Set("5kb"))
+	assert.Equal(t, int64(5120), mem.Value())
 }
 
 func TestNanoCPUsString(t *testing.T) {
 	var cpus opts.NanoCPUs = 6100000000
-	assert.Equal(t, cpus.String(), "6.100")
+	assert.Equal(t, "6.100", cpus.String())
 }
 
 func TestNanoCPUsSetAndValue(t *testing.T) {
 	var cpus opts.NanoCPUs
-	assert.NilError(t, cpus.Set("0.35"))
-	assert.Equal(t, cpus.Value(), int64(350000000))
+	assert.NoError(t, cpus.Set("0.35"))
+	assert.Equal(t, int64(350000000), cpus.Value())
 }
 
 func TestDurationOptString(t *testing.T) {
 	dur := time.Duration(300 * 10e8)
 	duration := DurationOpt{value: &dur}
-	assert.Equal(t, duration.String(), "5m0s")
+	assert.Equal(t, "5m0s", duration.String())
 }
 
 func TestDurationOptSetAndValue(t *testing.T) {
 	var duration DurationOpt
-	assert.NilError(t, duration.Set("300s"))
-	assert.Equal(t, *duration.Value(), time.Duration(300*10e8))
-	assert.NilError(t, duration.Set("-300s"))
-	assert.Equal(t, *duration.Value(), time.Duration(-300*10e8))
+	assert.NoError(t, duration.Set("300s"))
+	assert.Equal(t, time.Duration(300*10e8), *duration.Value())
+	assert.NoError(t, duration.Set("-300s"))
+	assert.Equal(t, time.Duration(-300*10e8), *duration.Value())
 }
 
 func TestPositiveDurationOptSetAndValue(t *testing.T) {
 	var duration PositiveDurationOpt
-	assert.NilError(t, duration.Set("300s"))
-	assert.Equal(t, *duration.Value(), time.Duration(300*10e8))
-	assert.Error(t, duration.Set("-300s"), "cannot be negative")
+	assert.NoError(t, duration.Set("300s"))
+	assert.Equal(t, time.Duration(300*10e8), *duration.Value())
+	assert.EqualError(t, duration.Set("-300s"), "duration cannot be negative")
 }
 
 func TestUint64OptString(t *testing.T) {
 	value := uint64(2345678)
 	opt := Uint64Opt{value: &value}
-	assert.Equal(t, opt.String(), "2345678")
+	assert.Equal(t, "2345678", opt.String())
 
 	opt = Uint64Opt{}
-	assert.Equal(t, opt.String(), "")
+	assert.Equal(t, "", opt.String())
 }
 
 func TestUint64OptSetAndValue(t *testing.T) {
 	var opt Uint64Opt
-	assert.NilError(t, opt.Set("14445"))
-	assert.Equal(t, *opt.Value(), uint64(14445))
+	assert.NoError(t, opt.Set("14445"))
+	assert.Equal(t, uint64(14445), *opt.Value())
 }
 
 func TestHealthCheckOptionsToHealthConfig(t *testing.T) {
@@ -78,14 +77,14 @@ func TestHealthCheckOptionsToHealthConfig(t *testing.T) {
 		retries:     10,
 	}
 	config, err := opt.toHealthConfig()
-	assert.NilError(t, err)
-	assert.Equal(t, reflect.DeepEqual(config, &container.HealthConfig{
+	assert.NoError(t, err)
+	assert.Equal(t, &container.HealthConfig{
 		Test:        []string{"CMD-SHELL", "curl"},
 		Interval:    time.Second,
 		Timeout:     time.Second,
 		StartPeriod: time.Second,
 		Retries:     10,
-	}), true)
+	}, config)
 }
 
 func TestHealthCheckOptionsToHealthConfigNoHealthcheck(t *testing.T) {
@@ -93,10 +92,10 @@ func TestHealthCheckOptionsToHealthConfigNoHealthcheck(t *testing.T) {
 		noHealthcheck: true,
 	}
 	config, err := opt.toHealthConfig()
-	assert.NilError(t, err)
-	assert.Equal(t, reflect.DeepEqual(config, &container.HealthConfig{
+	assert.NoError(t, err)
+	assert.Equal(t, &container.HealthConfig{
 		Test: []string{"NONE"},
-	}), true)
+	}, config)
 }
 
 func TestHealthCheckOptionsToHealthConfigConflict(t *testing.T) {
@@ -105,5 +104,5 @@ func TestHealthCheckOptionsToHealthConfigConflict(t *testing.T) {
 		noHealthcheck: true,
 	}
 	_, err := opt.toHealthConfig()
-	assert.Error(t, err, "--no-healthcheck conflicts with --health-* options")
+	assert.EqualError(t, err, "--no-healthcheck conflicts with --health-* options")
 }
diff --git a/cli/command/service/update_test.go b/cli/command/service/update_test.go
index 090372fb78..8f49d52ab8 100644
--- a/cli/command/service/update_test.go
+++ b/cli/command/service/update_test.go
@@ -10,7 +10,8 @@ import (
 	"github.com/docker/docker/api/types/container"
 	mounttypes "github.com/docker/docker/api/types/mount"
 	"github.com/docker/docker/api/types/swarm"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"golang.org/x/net/context"
 )
 
@@ -23,7 +24,7 @@ func TestUpdateServiceArgs(t *testing.T) {
 	cspec.Args = []string{"old", "args"}
 
 	updateService(nil, nil, flags, spec)
-	assert.EqualStringSlice(t, cspec.Args, []string{"the", "new args"})
+	assert.Equal(t, []string{"the", "new args"}, cspec.Args)
 }
 
 func TestUpdateLabels(t *testing.T) {
@@ -37,9 +38,9 @@ func TestUpdateLabels(t *testing.T) {
 	}
 
 	updateLabels(flags, &labels)
-	assert.Equal(t, len(labels), 2)
-	assert.Equal(t, labels["tokeep"], "value")
-	assert.Equal(t, labels["toadd"], "newlabel")
+	assert.Len(t, labels, 2)
+	assert.Equal(t, "value", labels["tokeep"])
+	assert.Equal(t, "newlabel", labels["toadd"])
 }
 
 func TestUpdateLabelsRemoveALabelThatDoesNotExist(t *testing.T) {
@@ -48,7 +49,7 @@ func TestUpdateLabelsRemoveALabelThatDoesNotExist(t *testing.T) {
 
 	labels := map[string]string{"foo": "theoldlabel"}
 	updateLabels(flags, &labels)
-	assert.Equal(t, len(labels), 1)
+	assert.Len(t, labels, 1)
 }
 
 func TestUpdatePlacementConstraints(t *testing.T) {
@@ -61,9 +62,9 @@ func TestUpdatePlacementConstraints(t *testing.T) {
 	}
 
 	updatePlacementConstraints(flags, placement)
-	assert.Equal(t, len(placement.Constraints), 2)
-	assert.Equal(t, placement.Constraints[0], "container=tokeep")
-	assert.Equal(t, placement.Constraints[1], "node=toadd")
+	require.Len(t, placement.Constraints, 2)
+	assert.Equal(t, "container=tokeep", placement.Constraints[0])
+	assert.Equal(t, "node=toadd", placement.Constraints[1])
 }
 
 func TestUpdatePlacementPrefs(t *testing.T) {
@@ -87,9 +88,9 @@ func TestUpdatePlacementPrefs(t *testing.T) {
 	}
 
 	updatePlacementPreferences(flags, placement)
-	assert.Equal(t, len(placement.Preferences), 2)
-	assert.Equal(t, placement.Preferences[0].Spread.SpreadDescriptor, "node.labels.row")
-	assert.Equal(t, placement.Preferences[1].Spread.SpreadDescriptor, "node.labels.dc")
+	require.Len(t, placement.Preferences, 2)
+	assert.Equal(t, "node.labels.row", placement.Preferences[0].Spread.SpreadDescriptor)
+	assert.Equal(t, "node.labels.dc", placement.Preferences[1].Spread.SpreadDescriptor)
 }
 
 func TestUpdateEnvironment(t *testing.T) {
@@ -100,11 +101,11 @@ func TestUpdateEnvironment(t *testing.T) {
 	envs := []string{"toremove=theenvtoremove", "tokeep=value"}
 
 	updateEnvironment(flags, &envs)
-	assert.Equal(t, len(envs), 2)
+	require.Len(t, envs, 2)
 	// Order has been removed in updateEnvironment (map)
 	sort.Strings(envs)
-	assert.Equal(t, envs[0], "toadd=newenv")
-	assert.Equal(t, envs[1], "tokeep=value")
+	assert.Equal(t, "toadd=newenv", envs[0])
+	assert.Equal(t, "tokeep=value", envs[1])
 }
 
 func TestUpdateEnvironmentWithDuplicateValues(t *testing.T) {
@@ -116,7 +117,7 @@ func TestUpdateEnvironmentWithDuplicateValues(t *testing.T) {
 	envs := []string{"foo=value"}
 
 	updateEnvironment(flags, &envs)
-	assert.Equal(t, len(envs), 0)
+	assert.Len(t, envs, 0)
 }
 
 func TestUpdateEnvironmentWithDuplicateKeys(t *testing.T) {
@@ -127,8 +128,8 @@ func TestUpdateEnvironmentWithDuplicateKeys(t *testing.T) {
 	envs := []string{"A=c"}
 
 	updateEnvironment(flags, &envs)
-	assert.Equal(t, len(envs), 1)
-	assert.Equal(t, envs[0], "A=b")
+	require.Len(t, envs, 1)
+	assert.Equal(t, "A=b", envs[0])
 }
 
 func TestUpdateGroups(t *testing.T) {
@@ -142,10 +143,10 @@ func TestUpdateGroups(t *testing.T) {
 	groups := []string{"bar", "root"}
 
 	updateGroups(flags, &groups)
-	assert.Equal(t, len(groups), 3)
-	assert.Equal(t, groups[0], "bar")
-	assert.Equal(t, groups[1], "foo")
-	assert.Equal(t, groups[2], "wheel")
+	require.Len(t, groups, 3)
+	assert.Equal(t, "bar", groups[0])
+	assert.Equal(t, "foo", groups[1])
+	assert.Equal(t, "wheel", groups[2])
 }
 
 func TestUpdateDNSConfig(t *testing.T) {
@@ -160,7 +161,7 @@ func TestUpdateDNSConfig(t *testing.T) {
 	// IPv6
 	flags.Set("dns-add", "2001:db8:abc8::1")
 	// Invalid dns record
-	assert.Error(t, flags.Set("dns-add", "x.y.z.w"), "x.y.z.w is not an ip address")
+	assert.EqualError(t, flags.Set("dns-add", "x.y.z.w"), "x.y.z.w is not an ip address")
 
 	// domains with duplicates
 	flags.Set("dns-search-add", "example.com")
@@ -168,7 +169,7 @@ func TestUpdateDNSConfig(t *testing.T) {
 	flags.Set("dns-search-add", "example.org")
 	flags.Set("dns-search-rm", "example.org")
 	// Invalid dns search domain
-	assert.Error(t, flags.Set("dns-search-add", "example$com"), "example$com is not a valid domain")
+	assert.EqualError(t, flags.Set("dns-search-add", "example$com"), "example$com is not a valid domain")
 
 	flags.Set("dns-option-add", "ndots:9")
 	flags.Set("dns-option-rm", "timeout:3")
@@ -181,16 +182,16 @@ func TestUpdateDNSConfig(t *testing.T) {
 
 	updateDNSConfig(flags, &config)
 
-	assert.Equal(t, len(config.Nameservers), 3)
-	assert.Equal(t, config.Nameservers[0], "1.1.1.1")
-	assert.Equal(t, config.Nameservers[1], "2001:db8:abc8::1")
-	assert.Equal(t, config.Nameservers[2], "5.5.5.5")
+	require.Len(t, config.Nameservers, 3)
+	assert.Equal(t, "1.1.1.1", config.Nameservers[0])
+	assert.Equal(t, "2001:db8:abc8::1", config.Nameservers[1])
+	assert.Equal(t, "5.5.5.5", config.Nameservers[2])
 
-	assert.Equal(t, len(config.Search), 2)
-	assert.Equal(t, config.Search[0], "example.com")
-	assert.Equal(t, config.Search[1], "localdomain")
+	require.Len(t, config.Search, 2)
+	assert.Equal(t, "example.com", config.Search[0])
+	assert.Equal(t, "localdomain", config.Search[1])
 
-	assert.Equal(t, len(config.Options), 1)
+	require.Len(t, config.Options, 1)
 	assert.Equal(t, config.Options[0], "ndots:9")
 }
 
@@ -205,10 +206,9 @@ func TestUpdateMounts(t *testing.T) {
 	}
 
 	updateMounts(flags, &mounts)
-	assert.Equal(t, len(mounts), 2)
-	assert.Equal(t, mounts[0].Target, "/toadd")
-	assert.Equal(t, mounts[1].Target, "/tokeep")
-
+	require.Len(t, mounts, 2)
+	assert.Equal(t, "/toadd", mounts[0].Target)
+	assert.Equal(t, "/tokeep", mounts[1].Target)
 }
 
 func TestUpdateMountsWithDuplicateMounts(t *testing.T) {
@@ -222,10 +222,10 @@ func TestUpdateMountsWithDuplicateMounts(t *testing.T) {
 	}
 
 	updateMounts(flags, &mounts)
-	assert.Equal(t, len(mounts), 3)
-	assert.Equal(t, mounts[0].Target, "/tokeep1")
-	assert.Equal(t, mounts[1].Target, "/tokeep2")
-	assert.Equal(t, mounts[2].Target, "/toadd")
+	require.Len(t, mounts, 3)
+	assert.Equal(t, "/tokeep1", mounts[0].Target)
+	assert.Equal(t, "/tokeep2", mounts[1].Target)
+	assert.Equal(t, "/toadd", mounts[2].Target)
 }
 
 func TestUpdatePorts(t *testing.T) {
@@ -239,13 +239,13 @@ func TestUpdatePorts(t *testing.T) {
 	}
 
 	err := updatePorts(flags, &portConfigs)
-	assert.Equal(t, err, nil)
-	assert.Equal(t, len(portConfigs), 2)
+	assert.NoError(t, err)
+	require.Len(t, portConfigs, 2)
 	// Do a sort to have the order (might have changed by map)
 	targetPorts := []int{int(portConfigs[0].TargetPort), int(portConfigs[1].TargetPort)}
 	sort.Ints(targetPorts)
-	assert.Equal(t, targetPorts[0], 555)
-	assert.Equal(t, targetPorts[1], 1000)
+	assert.Equal(t, 555, targetPorts[0])
+	assert.Equal(t, 1000, targetPorts[1])
 }
 
 func TestUpdatePortsDuplicate(t *testing.T) {
@@ -263,9 +263,9 @@ func TestUpdatePortsDuplicate(t *testing.T) {
 	}
 
 	err := updatePorts(flags, &portConfigs)
-	assert.Equal(t, err, nil)
-	assert.Equal(t, len(portConfigs), 1)
-	assert.Equal(t, portConfigs[0].TargetPort, uint32(80))
+	assert.NoError(t, err)
+	require.Len(t, portConfigs, 1)
+	assert.Equal(t, uint32(80), portConfigs[0].TargetPort)
 }
 
 func TestUpdateHealthcheckTable(t *testing.T) {
@@ -339,9 +339,9 @@ func TestUpdateHealthcheckTable(t *testing.T) {
 		}
 		err := updateHealthcheck(flags, cspec)
 		if c.err != "" {
-			assert.Error(t, err, c.err)
+			assert.EqualError(t, err, c.err)
 		} else {
-			assert.NilError(t, err)
+			assert.NoError(t, err)
 			if !reflect.DeepEqual(cspec.Healthcheck, c.expected) {
 				t.Errorf("incorrect result for test %d, expected health config:\n\t%#v\ngot:\n\t%#v", i, c.expected, cspec.Healthcheck)
 			}
@@ -358,15 +358,15 @@ func TestUpdateHosts(t *testing.T) {
 	// just hostname should work as well
 	flags.Set("host-rm", "example.net")
 	// bad format error
-	assert.Error(t, flags.Set("host-add", "$example.com$"), "bad format for add-host:")
+	assert.EqualError(t, flags.Set("host-add", "$example.com$"), `bad format for add-host: "$example.com$"`)
 
 	hosts := []string{"1.2.3.4 example.com", "4.3.2.1 example.org", "2001:db8:abc8::1 example.net"}
 
 	updateHosts(flags, &hosts)
-	assert.Equal(t, len(hosts), 3)
-	assert.Equal(t, hosts[0], "1.2.3.4 example.com")
-	assert.Equal(t, hosts[1], "2001:db8:abc8::1 ipv6.net")
-	assert.Equal(t, hosts[2], "4.3.2.1 example.org")
+	require.Len(t, hosts, 3)
+	assert.Equal(t, "1.2.3.4 example.com", hosts[0])
+	assert.Equal(t, "2001:db8:abc8::1 ipv6.net", hosts[1])
+	assert.Equal(t, "4.3.2.1 example.org", hosts[2])
 }
 
 func TestUpdatePortsRmWithProtocol(t *testing.T) {
@@ -387,10 +387,10 @@ func TestUpdatePortsRmWithProtocol(t *testing.T) {
 	}
 
 	err := updatePorts(flags, &portConfigs)
-	assert.Equal(t, err, nil)
-	assert.Equal(t, len(portConfigs), 2)
-	assert.Equal(t, portConfigs[0].TargetPort, uint32(81))
-	assert.Equal(t, portConfigs[1].TargetPort, uint32(82))
+	assert.NoError(t, err)
+	require.Len(t, portConfigs, 2)
+	assert.Equal(t, uint32(81), portConfigs[0].TargetPort)
+	assert.Equal(t, uint32(82), portConfigs[1].TargetPort)
 }
 
 type secretAPIClientMock struct {
@@ -444,11 +444,11 @@ func TestUpdateSecretUpdateInPlace(t *testing.T) {
 
 	updatedSecrets, err := getUpdatedSecrets(apiClient, flags, secrets)
 
-	assert.Equal(t, err, nil)
-	assert.Equal(t, len(updatedSecrets), 1)
-	assert.Equal(t, updatedSecrets[0].SecretID, "tn9qiblgnuuut11eufquw5dev")
-	assert.Equal(t, updatedSecrets[0].SecretName, "foo")
-	assert.Equal(t, updatedSecrets[0].File.Name, "foo2")
+	assert.NoError(t, err)
+	require.Len(t, updatedSecrets, 1)
+	assert.Equal(t, "tn9qiblgnuuut11eufquw5dev", updatedSecrets[0].SecretID)
+	assert.Equal(t, "foo", updatedSecrets[0].SecretName)
+	assert.Equal(t, "foo2", updatedSecrets[0].File.Name)
 }
 
 func TestUpdateReadOnly(t *testing.T) {
@@ -459,18 +459,18 @@ func TestUpdateReadOnly(t *testing.T) {
 	flags := newUpdateCommand(nil).Flags()
 	flags.Set("read-only", "true")
 	updateService(nil, nil, flags, spec)
-	assert.Equal(t, cspec.ReadOnly, true)
+	assert.True(t, cspec.ReadOnly)
 
 	// Update without --read-only, no change
 	flags = newUpdateCommand(nil).Flags()
 	updateService(nil, nil, flags, spec)
-	assert.Equal(t, cspec.ReadOnly, true)
+	assert.True(t, cspec.ReadOnly)
 
 	// Update with --read-only=false, changed to false
 	flags = newUpdateCommand(nil).Flags()
 	flags.Set("read-only", "false")
 	updateService(nil, nil, flags, spec)
-	assert.Equal(t, cspec.ReadOnly, false)
+	assert.False(t, cspec.ReadOnly)
 }
 
 func TestUpdateStopSignal(t *testing.T) {
@@ -481,16 +481,16 @@ func TestUpdateStopSignal(t *testing.T) {
 	flags := newUpdateCommand(nil).Flags()
 	flags.Set("stop-signal", "SIGUSR1")
 	updateService(nil, nil, flags, spec)
-	assert.Equal(t, cspec.StopSignal, "SIGUSR1")
+	assert.Equal(t, "SIGUSR1", cspec.StopSignal)
 
 	// Update without --stop-signal, no change
 	flags = newUpdateCommand(nil).Flags()
 	updateService(nil, nil, flags, spec)
-	assert.Equal(t, cspec.StopSignal, "SIGUSR1")
+	assert.Equal(t, "SIGUSR1", cspec.StopSignal)
 
 	// Update with --stop-signal=SIGWINCH
 	flags = newUpdateCommand(nil).Flags()
 	flags.Set("stop-signal", "SIGWINCH")
 	updateService(nil, nil, flags, spec)
-	assert.Equal(t, cspec.StopSignal, "SIGWINCH")
+	assert.Equal(t, "SIGWINCH", cspec.StopSignal)
 }
diff --git a/cli/command/stack/deploy_test.go b/cli/command/stack/deploy_test.go
index 328222af53..817c06dd04 100644
--- a/cli/command/stack/deploy_test.go
+++ b/cli/command/stack/deploy_test.go
@@ -6,7 +6,7 @@ import (
 
 	"github.com/docker/docker/cli/compose/convert"
 	"github.com/docker/docker/cli/internal/test"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 	"golang.org/x/net/context"
 )
 
@@ -23,5 +23,5 @@ func TestPruneServices(t *testing.T) {
 
 	pruneServices(ctx, dockerCli, namespace, services)
 
-	assert.DeepEqual(t, client.removedServices, buildObjectIDs([]string{objectName("foo", "remove")}))
+	assert.Equal(t, buildObjectIDs([]string{objectName("foo", "remove")}), client.removedServices)
 }
diff --git a/cli/command/stack/remove_test.go b/cli/command/stack/remove_test.go
index 7f64fb5505..17a334db1e 100644
--- a/cli/command/stack/remove_test.go
+++ b/cli/command/stack/remove_test.go
@@ -7,7 +7,7 @@ import (
 	"testing"
 
 	"github.com/docker/docker/cli/internal/test"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestRemoveStack(t *testing.T) {
@@ -17,20 +17,20 @@ func TestRemoveStack(t *testing.T) {
 		objectName("bar", "service1"),
 		objectName("bar", "service2"),
 	}
-	allServicesIDs := buildObjectIDs(allServices)
+	allServiceIDs := buildObjectIDs(allServices)
 
 	allNetworks := []string{
 		objectName("foo", "network1"),
 		objectName("bar", "network1"),
 	}
-	allNetworksIDs := buildObjectIDs(allNetworks)
+	allNetworkIDs := buildObjectIDs(allNetworks)
 
 	allSecrets := []string{
 		objectName("foo", "secret1"),
 		objectName("foo", "secret2"),
 		objectName("bar", "secret1"),
 	}
-	allSecretsIDs := buildObjectIDs(allSecrets)
+	allSecretIDs := buildObjectIDs(allSecrets)
 
 	cli := &fakeClient{
 		services: allServices,
@@ -40,22 +40,22 @@ func TestRemoveStack(t *testing.T) {
 	cmd := newRemoveCommand(test.NewFakeCli(cli, &bytes.Buffer{}))
 	cmd.SetArgs([]string{"foo", "bar"})
 
-	assert.NilError(t, cmd.Execute())
-	assert.DeepEqual(t, cli.removedServices, allServicesIDs)
-	assert.DeepEqual(t, cli.removedNetworks, allNetworksIDs)
-	assert.DeepEqual(t, cli.removedSecrets, allSecretsIDs)
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, allServiceIDs, cli.removedServices)
+	assert.Equal(t, allNetworkIDs, cli.removedNetworks)
+	assert.Equal(t, allSecretIDs, cli.removedSecrets)
 }
 
 func TestSkipEmptyStack(t *testing.T) {
 	buf := new(bytes.Buffer)
 	allServices := []string{objectName("bar", "service1"), objectName("bar", "service2")}
-	allServicesIDs := buildObjectIDs(allServices)
+	allServiceIDs := buildObjectIDs(allServices)
 
 	allNetworks := []string{objectName("bar", "network1")}
-	allNetworksIDs := buildObjectIDs(allNetworks)
+	allNetworkIDs := buildObjectIDs(allNetworks)
 
 	allSecrets := []string{objectName("bar", "secret1")}
-	allSecretsIDs := buildObjectIDs(allSecrets)
+	allSecretIDs := buildObjectIDs(allSecrets)
 
 	cli := &fakeClient{
 		services: allServices,
@@ -65,22 +65,22 @@ func TestSkipEmptyStack(t *testing.T) {
 	cmd := newRemoveCommand(test.NewFakeCli(cli, buf))
 	cmd.SetArgs([]string{"foo", "bar"})
 
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	assert.Contains(t, buf.String(), "Nothing found in stack: foo")
-	assert.DeepEqual(t, cli.removedServices, allServicesIDs)
-	assert.DeepEqual(t, cli.removedNetworks, allNetworksIDs)
-	assert.DeepEqual(t, cli.removedSecrets, allSecretsIDs)
+	assert.Equal(t, allServiceIDs, cli.removedServices)
+	assert.Equal(t, allNetworkIDs, cli.removedNetworks)
+	assert.Equal(t, allSecretIDs, cli.removedSecrets)
 }
 
 func TestContinueAfterError(t *testing.T) {
 	allServices := []string{objectName("foo", "service1"), objectName("bar", "service1")}
-	allServicesIDs := buildObjectIDs(allServices)
+	allServiceIDs := buildObjectIDs(allServices)
 
 	allNetworks := []string{objectName("foo", "network1"), objectName("bar", "network1")}
-	allNetworksIDs := buildObjectIDs(allNetworks)
+	allNetworkIDs := buildObjectIDs(allNetworks)
 
 	allSecrets := []string{objectName("foo", "secret1"), objectName("bar", "secret1")}
-	allSecretsIDs := buildObjectIDs(allSecrets)
+	allSecretIDs := buildObjectIDs(allSecrets)
 
 	removedServices := []string{}
 	cli := &fakeClient{
@@ -100,8 +100,8 @@ func TestContinueAfterError(t *testing.T) {
 	cmd := newRemoveCommand(test.NewFakeCli(cli, &bytes.Buffer{}))
 	cmd.SetArgs([]string{"foo", "bar"})
 
-	assert.Error(t, cmd.Execute(), "Failed to remove some resources from stack: foo")
-	assert.DeepEqual(t, removedServices, allServicesIDs)
-	assert.DeepEqual(t, cli.removedNetworks, allNetworksIDs)
-	assert.DeepEqual(t, cli.removedSecrets, allSecretsIDs)
+	assert.EqualError(t, cmd.Execute(), "Failed to remove some resources from stack: foo")
+	assert.Equal(t, allServiceIDs, removedServices)
+	assert.Equal(t, allNetworkIDs, cli.removedNetworks)
+	assert.Equal(t, allSecretIDs, cli.removedSecrets)
 }
diff --git a/cli/command/swarm/init_test.go b/cli/command/swarm/init_test.go
index c21433bdb9..39cb73888c 100644
--- a/cli/command/swarm/init_test.go
+++ b/cli/command/swarm/init_test.go
@@ -9,9 +9,10 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/swarm"
 	"github.com/docker/docker/cli/internal/test"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/docker/docker/pkg/testutil/golden"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestSwarmInitErrorOnAPIFailure(t *testing.T) {
@@ -76,7 +77,7 @@ func TestSwarmInitErrorOnAPIFailure(t *testing.T) {
 			cmd.Flags().Set(key, value)
 		}
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		assert.EqualError(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -122,9 +123,9 @@ func TestSwarmInit(t *testing.T) {
 		for key, value := range tc.flags {
 			cmd.Flags().Set(key, value)
 		}
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 		actual := buf.String()
 		expected := golden.Get(t, []byte(actual), fmt.Sprintf("init-%s.golden", tc.name))
-		assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+		testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 	}
 }
diff --git a/cli/command/swarm/join_test.go b/cli/command/swarm/join_test.go
index 6d92f0c4fa..6893f68e1d 100644
--- a/cli/command/swarm/join_test.go
+++ b/cli/command/swarm/join_test.go
@@ -9,8 +9,9 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/swarm"
 	"github.com/docker/docker/cli/internal/test"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestSwarmJoinErrors(t *testing.T) {
@@ -56,7 +57,7 @@ func TestSwarmJoinErrors(t *testing.T) {
 			}, buf))
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -96,7 +97,7 @@ func TestSwarmJoin(t *testing.T) {
 				infoFunc: tc.infoFunc,
 			}, buf))
 		cmd.SetArgs([]string{"remote"})
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 		assert.Equal(t, strings.TrimSpace(buf.String()), tc.expected)
 	}
 }
diff --git a/cli/command/swarm/join_token_test.go b/cli/command/swarm/join_token_test.go
index 9b10369ad0..9289189009 100644
--- a/cli/command/swarm/join_token_test.go
+++ b/cli/command/swarm/join_token_test.go
@@ -12,8 +12,9 @@ import (
 	"github.com/pkg/errors"
 	// Import builders to get the builder function as package function
 	. "github.com/docker/docker/cli/internal/test/builders"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/docker/docker/pkg/testutil/golden"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestSwarmJoinTokenErrors(t *testing.T) {
@@ -102,7 +103,7 @@ func TestSwarmJoinTokenErrors(t *testing.T) {
 			cmd.Flags().Set(key, value)
 		}
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -208,9 +209,9 @@ func TestSwarmJoinToken(t *testing.T) {
 		for key, value := range tc.flags {
 			cmd.Flags().Set(key, value)
 		}
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 		actual := buf.String()
 		expected := golden.Get(t, []byte(actual), fmt.Sprintf("jointoken-%s.golden", tc.name))
-		assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+		testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 	}
 }
diff --git a/cli/command/swarm/leave_test.go b/cli/command/swarm/leave_test.go
index 93a58887a7..030f18039a 100644
--- a/cli/command/swarm/leave_test.go
+++ b/cli/command/swarm/leave_test.go
@@ -7,8 +7,9 @@ import (
 	"testing"
 
 	"github.com/docker/docker/cli/internal/test"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestSwarmLeaveErrors(t *testing.T) {
@@ -39,7 +40,7 @@ func TestSwarmLeaveErrors(t *testing.T) {
 			}, buf))
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -47,6 +48,6 @@ func TestSwarmLeave(t *testing.T) {
 	buf := new(bytes.Buffer)
 	cmd := newLeaveCommand(
 		test.NewFakeCli(&fakeClient{}, buf))
-	assert.NilError(t, cmd.Execute())
-	assert.Equal(t, strings.TrimSpace(buf.String()), "Node left the swarm.")
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, "Node left the swarm.", strings.TrimSpace(buf.String()))
 }
diff --git a/cli/command/swarm/opts_test.go b/cli/command/swarm/opts_test.go
index 9a97e8bd2c..c694cc1bdd 100644
--- a/cli/command/swarm/opts_test.go
+++ b/cli/command/swarm/opts_test.go
@@ -3,37 +3,37 @@ package swarm
 import (
 	"testing"
 
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestNodeAddrOptionSetHostAndPort(t *testing.T) {
 	opt := NewNodeAddrOption("old:123")
 	addr := "newhost:5555"
-	assert.NilError(t, opt.Set(addr))
-	assert.Equal(t, opt.Value(), addr)
+	assert.NoError(t, opt.Set(addr))
+	assert.Equal(t, addr, opt.Value())
 }
 
 func TestNodeAddrOptionSetHostOnly(t *testing.T) {
 	opt := NewListenAddrOption()
-	assert.NilError(t, opt.Set("newhost"))
-	assert.Equal(t, opt.Value(), "newhost:2377")
+	assert.NoError(t, opt.Set("newhost"))
+	assert.Equal(t, "newhost:2377", opt.Value())
 }
 
 func TestNodeAddrOptionSetHostOnlyIPv6(t *testing.T) {
 	opt := NewListenAddrOption()
-	assert.NilError(t, opt.Set("::1"))
-	assert.Equal(t, opt.Value(), "[::1]:2377")
+	assert.NoError(t, opt.Set("::1"))
+	assert.Equal(t, "[::1]:2377", opt.Value())
 }
 
 func TestNodeAddrOptionSetPortOnly(t *testing.T) {
 	opt := NewListenAddrOption()
-	assert.NilError(t, opt.Set(":4545"))
-	assert.Equal(t, opt.Value(), "0.0.0.0:4545")
+	assert.NoError(t, opt.Set(":4545"))
+	assert.Equal(t, "0.0.0.0:4545", opt.Value())
 }
 
 func TestNodeAddrOptionSetInvalidFormat(t *testing.T) {
 	opt := NewListenAddrOption()
-	assert.Error(t, opt.Set("http://localhost:4545"), "Invalid")
+	assert.EqualError(t, opt.Set("http://localhost:4545"), "Invalid proto, expected tcp: http://localhost:4545")
 }
 
 func TestExternalCAOptionErrors(t *testing.T) {
@@ -64,7 +64,7 @@ func TestExternalCAOptionErrors(t *testing.T) {
 	}
 	for _, tc := range testCases {
 		opt := &ExternalCAOption{}
-		assert.Error(t, opt.Set(tc.externalCA), tc.expectedError)
+		assert.EqualError(t, opt.Set(tc.externalCA), tc.expectedError)
 	}
 }
 
@@ -96,15 +96,15 @@ func TestExternalCAOption(t *testing.T) {
 	}
 	for _, tc := range testCases {
 		opt := &ExternalCAOption{}
-		assert.NilError(t, opt.Set(tc.externalCA))
-		assert.Equal(t, opt.String(), tc.expected)
+		assert.NoError(t, opt.Set(tc.externalCA))
+		assert.Equal(t, tc.expected, opt.String())
 	}
 }
 
 func TestExternalCAOptionMultiple(t *testing.T) {
 	opt := &ExternalCAOption{}
-	assert.NilError(t, opt.Set("protocol=cfssl,url=https://example.com"))
-	assert.NilError(t, opt.Set("protocol=CFSSL,url=anything"))
-	assert.Equal(t, len(opt.Value()), 2)
-	assert.Equal(t, opt.String(), "cfssl: https://example.com, cfssl: anything")
+	assert.NoError(t, opt.Set("protocol=cfssl,url=https://example.com"))
+	assert.NoError(t, opt.Set("protocol=CFSSL,url=anything"))
+	assert.Len(t, opt.Value(), 2)
+	assert.Equal(t, "cfssl: https://example.com, cfssl: anything", opt.String())
 }
diff --git a/cli/command/swarm/unlock_key_test.go b/cli/command/swarm/unlock_key_test.go
index 7b644f70e9..23752104aa 100644
--- a/cli/command/swarm/unlock_key_test.go
+++ b/cli/command/swarm/unlock_key_test.go
@@ -12,8 +12,9 @@ import (
 	"github.com/pkg/errors"
 	// Import builders to get the builder function as package function
 	. "github.com/docker/docker/cli/internal/test/builders"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/docker/docker/pkg/testutil/golden"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestSwarmUnlockKeyErrors(t *testing.T) {
@@ -94,7 +95,7 @@ func TestSwarmUnlockKeyErrors(t *testing.T) {
 			cmd.Flags().Set(key, value)
 		}
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -168,9 +169,9 @@ func TestSwarmUnlockKey(t *testing.T) {
 		for key, value := range tc.flags {
 			cmd.Flags().Set(key, value)
 		}
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 		actual := buf.String()
 		expected := golden.Get(t, []byte(actual), fmt.Sprintf("unlockkeys-%s.golden", tc.name))
-		assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+		testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 	}
 }
diff --git a/cli/command/swarm/unlock_test.go b/cli/command/swarm/unlock_test.go
index 620fecafed..e1a2bb4cc5 100644
--- a/cli/command/swarm/unlock_test.go
+++ b/cli/command/swarm/unlock_test.go
@@ -9,8 +9,9 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/swarm"
 	"github.com/docker/docker/cli/internal/test"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestSwarmUnlockErrors(t *testing.T) {
@@ -73,7 +74,7 @@ func TestSwarmUnlockErrors(t *testing.T) {
 			}, buf))
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -97,5 +98,5 @@ func TestSwarmUnlock(t *testing.T) {
 	}, buf)
 	dockerCli.SetIn(ioutil.NopCloser(strings.NewReader(input)))
 	cmd := newUnlockCommand(dockerCli)
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 }
diff --git a/cli/command/swarm/update_test.go b/cli/command/swarm/update_test.go
index 0450c02979..65366ddd20 100644
--- a/cli/command/swarm/update_test.go
+++ b/cli/command/swarm/update_test.go
@@ -13,8 +13,9 @@ import (
 	"github.com/pkg/errors"
 	// Import builders to get the builder function as package function
 	. "github.com/docker/docker/cli/internal/test/builders"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/docker/docker/pkg/testutil/golden"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestSwarmUpdateErrors(t *testing.T) {
@@ -79,7 +80,7 @@ func TestSwarmUpdateErrors(t *testing.T) {
 			cmd.Flags().Set(key, value)
 		}
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -175,9 +176,9 @@ func TestSwarmUpdate(t *testing.T) {
 			cmd.Flags().Set(key, value)
 		}
 		cmd.SetOutput(buf)
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 		actual := buf.String()
 		expected := golden.Get(t, []byte(actual), fmt.Sprintf("update-%s.golden", tc.name))
-		assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+		testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 	}
 }
diff --git a/cli/command/volume/create_test.go b/cli/command/volume/create_test.go
index ccb7ac75bf..45cf631134 100644
--- a/cli/command/volume/create_test.go
+++ b/cli/command/volume/create_test.go
@@ -9,8 +9,9 @@ import (
 	"github.com/docker/docker/api/types"
 	volumetypes "github.com/docker/docker/api/types/volume"
 	"github.com/docker/docker/cli/internal/test"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestVolumeCreateErrors(t *testing.T) {
@@ -50,7 +51,7 @@ func TestVolumeCreateErrors(t *testing.T) {
 			cmd.Flags().Set(key, value)
 		}
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -71,15 +72,15 @@ func TestVolumeCreateWithName(t *testing.T) {
 	// Test by flags
 	cmd := newCreateCommand(cli)
 	cmd.Flags().Set("name", name)
-	assert.NilError(t, cmd.Execute())
-	assert.Equal(t, strings.TrimSpace(buf.String()), name)
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, name, strings.TrimSpace(buf.String()))
 
 	// Then by args
 	buf.Reset()
 	cmd = newCreateCommand(cli)
 	cmd.SetArgs([]string{name})
-	assert.NilError(t, cmd.Execute())
-	assert.Equal(t, strings.TrimSpace(buf.String()), name)
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, name, strings.TrimSpace(buf.String()))
 }
 
 func TestVolumeCreateWithFlags(t *testing.T) {
@@ -121,8 +122,8 @@ func TestVolumeCreateWithFlags(t *testing.T) {
 	cmd.Flags().Set("opt", "baz=baz")
 	cmd.Flags().Set("label", "lbl1=v1")
 	cmd.Flags().Set("label", "lbl2=v2")
-	assert.NilError(t, cmd.Execute())
-	assert.Equal(t, strings.TrimSpace(buf.String()), name)
+	assert.NoError(t, cmd.Execute())
+	assert.Equal(t, name, strings.TrimSpace(buf.String()))
 }
 
 func compareMap(actual map[string]string, expected map[string]string) bool {
diff --git a/cli/command/volume/inspect_test.go b/cli/command/volume/inspect_test.go
index 7c4cce39db..bc1b526440 100644
--- a/cli/command/volume/inspect_test.go
+++ b/cli/command/volume/inspect_test.go
@@ -11,8 +11,9 @@ import (
 	"github.com/pkg/errors"
 	// Import builders to get the builder function as package function
 	. "github.com/docker/docker/cli/internal/test/builders"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/docker/docker/pkg/testutil/golden"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestVolumeInspectErrors(t *testing.T) {
@@ -64,7 +65,7 @@ func TestVolumeInspectErrors(t *testing.T) {
 			cmd.Flags().Set(key, value)
 		}
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -102,10 +103,10 @@ func TestVolumeInspectWithoutFormat(t *testing.T) {
 			}, buf),
 		)
 		cmd.SetArgs(tc.args)
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 		actual := buf.String()
 		expected := golden.Get(t, []byte(actual), fmt.Sprintf("volume-inspect-without-format.%s.golden", tc.name))
-		assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+		testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 	}
 }
 
@@ -143,9 +144,9 @@ func TestVolumeInspectWithFormat(t *testing.T) {
 		)
 		cmd.SetArgs(tc.args)
 		cmd.Flags().Set("format", tc.format)
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 		actual := buf.String()
 		expected := golden.Get(t, []byte(actual), fmt.Sprintf("volume-inspect-with-format.%s.golden", tc.name))
-		assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+		testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 	}
 }
diff --git a/cli/command/volume/list_test.go b/cli/command/volume/list_test.go
index b2306a5d8e..4f5e99389f 100644
--- a/cli/command/volume/list_test.go
+++ b/cli/command/volume/list_test.go
@@ -13,8 +13,9 @@ import (
 	"github.com/pkg/errors"
 	// Import builders to get the builder function as package function
 	. "github.com/docker/docker/cli/internal/test/builders"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/docker/docker/pkg/testutil/golden"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestVolumeListErrors(t *testing.T) {
@@ -47,7 +48,7 @@ func TestVolumeListErrors(t *testing.T) {
 			cmd.Flags().Set(key, value)
 		}
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -68,10 +69,10 @@ func TestVolumeListWithoutFormat(t *testing.T) {
 	}, buf)
 	cli.SetConfigfile(&configfile.ConfigFile{})
 	cmd := newListCommand(cli)
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	actual := buf.String()
 	expected := golden.Get(t, []byte(actual), "volume-list-without-format.golden")
-	assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+	testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 }
 
 func TestVolumeListWithConfigFormat(t *testing.T) {
@@ -93,10 +94,10 @@ func TestVolumeListWithConfigFormat(t *testing.T) {
 		VolumesFormat: "{{ .Name }} {{ .Driver }} {{ .Labels }}",
 	})
 	cmd := newListCommand(cli)
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	actual := buf.String()
 	expected := golden.Get(t, []byte(actual), "volume-list-with-config-format.golden")
-	assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+	testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 }
 
 func TestVolumeListWithFormat(t *testing.T) {
@@ -117,8 +118,8 @@ func TestVolumeListWithFormat(t *testing.T) {
 	cli.SetConfigfile(&configfile.ConfigFile{})
 	cmd := newListCommand(cli)
 	cmd.Flags().Set("format", "{{ .Name }} {{ .Driver }} {{ .Labels }}")
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 	actual := buf.String()
 	expected := golden.Get(t, []byte(actual), "volume-list-with-format.golden")
-	assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+	testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 }
diff --git a/cli/command/volume/prune_test.go b/cli/command/volume/prune_test.go
index dab997f625..05da9bdded 100644
--- a/cli/command/volume/prune_test.go
+++ b/cli/command/volume/prune_test.go
@@ -11,9 +11,10 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/cli/internal/test"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/docker/docker/pkg/testutil/golden"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestVolumePruneErrors(t *testing.T) {
@@ -48,7 +49,7 @@ func TestVolumePruneErrors(t *testing.T) {
 			cmd.Flags().Set(key, value)
 		}
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -73,10 +74,10 @@ func TestVolumePruneForce(t *testing.T) {
 			}, buf),
 		)
 		cmd.Flags().Set("force", "true")
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 		actual := buf.String()
 		expected := golden.Get(t, []byte(actual), fmt.Sprintf("volume-prune.%s.golden", tc.name))
-		assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+		testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 	}
 }
 func TestVolumePrunePromptYes(t *testing.T) {
@@ -94,10 +95,10 @@ func TestVolumePrunePromptYes(t *testing.T) {
 		cmd := NewPruneCommand(
 			cli,
 		)
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 		actual := buf.String()
 		expected := golden.Get(t, []byte(actual), "volume-prune-yes.golden")
-		assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+		testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 	}
 }
 
@@ -116,10 +117,10 @@ func TestVolumePrunePromptNo(t *testing.T) {
 		cmd := NewPruneCommand(
 			cli,
 		)
-		assert.NilError(t, cmd.Execute())
+		assert.NoError(t, cmd.Execute())
 		actual := buf.String()
 		expected := golden.Get(t, []byte(actual), "volume-prune-no.golden")
-		assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected))
+		testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected))
 	}
 }
 
diff --git a/cli/command/volume/remove_test.go b/cli/command/volume/remove_test.go
index 0154a5d551..5a4dc1f4b7 100644
--- a/cli/command/volume/remove_test.go
+++ b/cli/command/volume/remove_test.go
@@ -6,8 +6,9 @@ import (
 	"testing"
 
 	"github.com/docker/docker/cli/internal/test"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestVolumeRemoveErrors(t *testing.T) {
@@ -35,7 +36,7 @@ func TestVolumeRemoveErrors(t *testing.T) {
 			}, buf))
 		cmd.SetArgs(tc.args)
 		cmd.SetOutput(ioutil.Discard)
-		assert.Error(t, cmd.Execute(), tc.expectedError)
+		testutil.ErrorContains(t, cmd.Execute(), tc.expectedError)
 	}
 }
 
@@ -43,5 +44,5 @@ func TestNodeRemoveMultiple(t *testing.T) {
 	buf := new(bytes.Buffer)
 	cmd := newRemoveCommand(test.NewFakeCli(&fakeClient{}, buf))
 	cmd.SetArgs([]string{"volume1", "volume2"})
-	assert.NilError(t, cmd.Execute())
+	assert.NoError(t, cmd.Execute())
 }
diff --git a/cli/compose/convert/compose_test.go b/cli/compose/convert/compose_test.go
index c267820956..a76d5ecd4f 100644
--- a/cli/compose/convert/compose_test.go
+++ b/cli/compose/convert/compose_test.go
@@ -6,13 +6,14 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/network"
 	composetypes "github.com/docker/docker/cli/compose/types"
-	"github.com/docker/docker/pkg/testutil/assert"
 	"github.com/docker/docker/pkg/testutil/tempfile"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNamespaceScope(t *testing.T) {
 	scoped := Namespace{name: "foo"}.Scope("bar")
-	assert.Equal(t, scoped, "foo_bar")
+	assert.Equal(t, "foo_bar", scoped)
 }
 
 func TestAddStackLabel(t *testing.T) {
@@ -24,7 +25,7 @@ func TestAddStackLabel(t *testing.T) {
 		"something":    "labeled",
 		LabelNamespace: "foo",
 	}
-	assert.DeepEqual(t, actual, expected)
+	assert.Equal(t, expected, actual)
 }
 
 func TestNetworks(t *testing.T) {
@@ -98,8 +99,8 @@ func TestNetworks(t *testing.T) {
 	}
 
 	networks, externals := Networks(namespace, source, serviceNetworks)
-	assert.DeepEqual(t, networks, expected)
-	assert.DeepEqual(t, externals, []string{"special"})
+	assert.Equal(t, expected, networks)
+	assert.Equal(t, []string{"special"}, externals)
 }
 
 func TestSecrets(t *testing.T) {
@@ -122,13 +123,13 @@ func TestSecrets(t *testing.T) {
 	}
 
 	specs, err := Secrets(namespace, source)
-	assert.NilError(t, err)
-	assert.Equal(t, len(specs), 1)
+	assert.NoError(t, err)
+	require.Len(t, specs, 1)
 	secret := specs[0]
-	assert.Equal(t, secret.Name, "foo_one")
-	assert.DeepEqual(t, secret.Labels, map[string]string{
+	assert.Equal(t, "foo_one", secret.Name)
+	assert.Equal(t, map[string]string{
 		"monster":      "mash",
 		LabelNamespace: "foo",
-	})
-	assert.DeepEqual(t, secret.Data, []byte(secretText))
+	}, secret.Labels)
+	assert.Equal(t, []byte(secretText), secret.Data)
 }
diff --git a/cli/compose/convert/service_test.go b/cli/compose/convert/service_test.go
index 91af572994..b08ecf3636 100644
--- a/cli/compose/convert/service_test.go
+++ b/cli/compose/convert/service_test.go
@@ -9,18 +9,18 @@ import (
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/swarm"
 	composetypes "github.com/docker/docker/cli/compose/types"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestConvertRestartPolicyFromNone(t *testing.T) {
 	policy, err := convertRestartPolicy("no", nil)
-	assert.NilError(t, err)
-	assert.Equal(t, policy, (*swarm.RestartPolicy)(nil))
+	assert.NoError(t, err)
+	assert.Equal(t, (*swarm.RestartPolicy)(nil), policy)
 }
 
 func TestConvertRestartPolicyFromUnknown(t *testing.T) {
 	_, err := convertRestartPolicy("unknown", nil)
-	assert.Error(t, err, "unknown restart policy: unknown")
+	assert.EqualError(t, err, "unknown restart policy: unknown")
 }
 
 func TestConvertRestartPolicyFromAlways(t *testing.T) {
@@ -28,8 +28,8 @@ func TestConvertRestartPolicyFromAlways(t *testing.T) {
 	expected := &swarm.RestartPolicy{
 		Condition: swarm.RestartPolicyConditionAny,
 	}
-	assert.NilError(t, err)
-	assert.DeepEqual(t, policy, expected)
+	assert.NoError(t, err)
+	assert.Equal(t, expected, policy)
 }
 
 func TestConvertRestartPolicyFromFailure(t *testing.T) {
@@ -39,8 +39,8 @@ func TestConvertRestartPolicyFromFailure(t *testing.T) {
 		Condition:   swarm.RestartPolicyConditionOnFailure,
 		MaxAttempts: &attempts,
 	}
-	assert.NilError(t, err)
-	assert.DeepEqual(t, policy, expected)
+	assert.NoError(t, err)
+	assert.Equal(t, expected, policy)
 }
 
 func strPtr(val string) *string {
@@ -54,7 +54,7 @@ func TestConvertEnvironment(t *testing.T) {
 	}
 	env := convertEnvironment(source)
 	sort.Strings(env)
-	assert.DeepEqual(t, env, []string{"foo=bar", "key=value"})
+	assert.Equal(t, []string{"foo=bar", "key=value"}, env)
 }
 
 func TestConvertResourcesFull(t *testing.T) {
@@ -69,7 +69,7 @@ func TestConvertResourcesFull(t *testing.T) {
 		},
 	}
 	resources, err := convertResources(source)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	expected := &swarm.ResourceRequirements{
 		Limits: &swarm.Resources{
@@ -81,7 +81,7 @@ func TestConvertResourcesFull(t *testing.T) {
 			MemoryBytes: 200000000,
 		},
 	}
-	assert.DeepEqual(t, resources, expected)
+	assert.Equal(t, expected, resources)
 }
 
 func TestConvertResourcesOnlyMemory(t *testing.T) {
@@ -94,7 +94,7 @@ func TestConvertResourcesOnlyMemory(t *testing.T) {
 		},
 	}
 	resources, err := convertResources(source)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	expected := &swarm.ResourceRequirements{
 		Limits: &swarm.Resources{
@@ -104,7 +104,7 @@ func TestConvertResourcesOnlyMemory(t *testing.T) {
 			MemoryBytes: 200000000,
 		},
 	}
-	assert.DeepEqual(t, resources, expected)
+	assert.Equal(t, expected, resources)
 }
 
 func TestConvertHealthcheck(t *testing.T) {
@@ -123,8 +123,8 @@ func TestConvertHealthcheck(t *testing.T) {
 	}
 
 	healthcheck, err := convertHealthcheck(source)
-	assert.NilError(t, err)
-	assert.DeepEqual(t, healthcheck, expected)
+	assert.NoError(t, err)
+	assert.Equal(t, expected, healthcheck)
 }
 
 func TestConvertHealthcheckDisable(t *testing.T) {
@@ -134,8 +134,8 @@ func TestConvertHealthcheckDisable(t *testing.T) {
 	}
 
 	healthcheck, err := convertHealthcheck(source)
-	assert.NilError(t, err)
-	assert.DeepEqual(t, healthcheck, expected)
+	assert.NoError(t, err)
+	assert.Equal(t, expected, healthcheck)
 }
 
 func TestConvertHealthcheckDisableWithTest(t *testing.T) {
@@ -144,7 +144,7 @@ func TestConvertHealthcheckDisableWithTest(t *testing.T) {
 		Test:    []string{"EXEC", "touch"},
 	}
 	_, err := convertHealthcheck(source)
-	assert.Error(t, err, "test and disable can't be set")
+	assert.EqualError(t, err, "test and disable can't be set at the same time")
 }
 
 func TestConvertEndpointSpec(t *testing.T) {
@@ -178,8 +178,8 @@ func TestConvertEndpointSpec(t *testing.T) {
 		},
 	}
 
-	assert.NilError(t, err)
-	assert.DeepEqual(t, *endpoint, expected)
+	assert.NoError(t, err)
+	assert.Equal(t, expected, *endpoint)
 }
 
 func TestConvertServiceNetworksOnlyDefault(t *testing.T) {
@@ -195,8 +195,8 @@ func TestConvertServiceNetworksOnlyDefault(t *testing.T) {
 		},
 	}
 
-	assert.NilError(t, err)
-	assert.DeepEqual(t, configs, expected)
+	assert.NoError(t, err)
+	assert.Equal(t, expected, configs)
 }
 
 func TestConvertServiceNetworks(t *testing.T) {
@@ -235,8 +235,8 @@ func TestConvertServiceNetworks(t *testing.T) {
 	sortedConfigs := byTargetSort(configs)
 	sort.Sort(&sortedConfigs)
 
-	assert.NilError(t, err)
-	assert.DeepEqual(t, []swarm.NetworkAttachmentConfig(sortedConfigs), expected)
+	assert.NoError(t, err)
+	assert.Equal(t, expected, []swarm.NetworkAttachmentConfig(sortedConfigs))
 }
 
 func TestConvertServiceNetworksCustomDefault(t *testing.T) {
@@ -260,8 +260,8 @@ func TestConvertServiceNetworksCustomDefault(t *testing.T) {
 		},
 	}
 
-	assert.NilError(t, err)
-	assert.DeepEqual(t, []swarm.NetworkAttachmentConfig(configs), expected)
+	assert.NoError(t, err)
+	assert.Equal(t, expected, []swarm.NetworkAttachmentConfig(configs))
 }
 
 type byTargetSort []swarm.NetworkAttachmentConfig
@@ -281,8 +281,8 @@ func (s byTargetSort) Swap(i, j int) {
 func TestConvertDNSConfigEmpty(t *testing.T) {
 	dnsConfig, err := convertDNSConfig(nil, nil)
 
-	assert.NilError(t, err)
-	assert.Equal(t, dnsConfig, (*swarm.DNSConfig)(nil))
+	assert.NoError(t, err)
+	assert.Equal(t, (*swarm.DNSConfig)(nil), dnsConfig)
 }
 
 var (
@@ -292,27 +292,27 @@ var (
 
 func TestConvertDNSConfigAll(t *testing.T) {
 	dnsConfig, err := convertDNSConfig(nameservers, search)
-	assert.NilError(t, err)
-	assert.DeepEqual(t, dnsConfig, &swarm.DNSConfig{
+	assert.NoError(t, err)
+	assert.Equal(t, &swarm.DNSConfig{
 		Nameservers: nameservers,
 		Search:      search,
-	})
+	}, dnsConfig)
 }
 
 func TestConvertDNSConfigNameservers(t *testing.T) {
 	dnsConfig, err := convertDNSConfig(nameservers, nil)
-	assert.NilError(t, err)
-	assert.DeepEqual(t, dnsConfig, &swarm.DNSConfig{
+	assert.NoError(t, err)
+	assert.Equal(t, &swarm.DNSConfig{
 		Nameservers: nameservers,
 		Search:      nil,
-	})
+	}, dnsConfig)
 }
 
 func TestConvertDNSConfigSearch(t *testing.T) {
 	dnsConfig, err := convertDNSConfig(nil, search)
-	assert.NilError(t, err)
-	assert.DeepEqual(t, dnsConfig, &swarm.DNSConfig{
+	assert.NoError(t, err)
+	assert.Equal(t, &swarm.DNSConfig{
 		Nameservers: nil,
 		Search:      search,
-	})
+	}, dnsConfig)
 }
diff --git a/cli/compose/convert/volume_test.go b/cli/compose/convert/volume_test.go
index 73d642e5fe..a7502d1737 100644
--- a/cli/compose/convert/volume_test.go
+++ b/cli/compose/convert/volume_test.go
@@ -5,7 +5,7 @@ import (
 
 	"github.com/docker/docker/api/types/mount"
 	composetypes "github.com/docker/docker/cli/compose/types"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestConvertVolumeToMountAnonymousVolume(t *testing.T) {
@@ -18,8 +18,8 @@ func TestConvertVolumeToMountAnonymousVolume(t *testing.T) {
 		Target: "/foo/bar",
 	}
 	mount, err := convertVolumeToMount(config, volumes{}, NewNamespace("foo"))
-	assert.NilError(t, err)
-	assert.DeepEqual(t, mount, expected)
+	assert.NoError(t, err)
+	assert.Equal(t, expected, mount)
 }
 
 func TestConvertVolumeToMountConflictingOptionsBind(t *testing.T) {
@@ -34,7 +34,7 @@ func TestConvertVolumeToMountConflictingOptionsBind(t *testing.T) {
 		},
 	}
 	_, err := convertVolumeToMount(config, volumes{}, namespace)
-	assert.Error(t, err, "bind options are incompatible")
+	assert.EqualError(t, err, "bind options are incompatible with type volume")
 }
 
 func TestConvertVolumeToMountConflictingOptionsVolume(t *testing.T) {
@@ -49,7 +49,7 @@ func TestConvertVolumeToMountConflictingOptionsVolume(t *testing.T) {
 		},
 	}
 	_, err := convertVolumeToMount(config, volumes{}, namespace)
-	assert.Error(t, err, "volume options are incompatible")
+	assert.EqualError(t, err, "volume options are incompatible with type bind")
 }
 
 func TestConvertVolumeToMountNamedVolume(t *testing.T) {
@@ -94,8 +94,8 @@ func TestConvertVolumeToMountNamedVolume(t *testing.T) {
 		},
 	}
 	mount, err := convertVolumeToMount(config, stackVolumes, namespace)
-	assert.NilError(t, err)
-	assert.DeepEqual(t, mount, expected)
+	assert.NoError(t, err)
+	assert.Equal(t, expected, mount)
 }
 
 func TestConvertVolumeToMountNamedVolumeExternal(t *testing.T) {
@@ -122,8 +122,8 @@ func TestConvertVolumeToMountNamedVolumeExternal(t *testing.T) {
 		Target: "/foo",
 	}
 	mount, err := convertVolumeToMount(config, stackVolumes, namespace)
-	assert.NilError(t, err)
-	assert.DeepEqual(t, mount, expected)
+	assert.NoError(t, err)
+	assert.Equal(t, expected, mount)
 }
 
 func TestConvertVolumeToMountNamedVolumeExternalNoCopy(t *testing.T) {
@@ -153,8 +153,8 @@ func TestConvertVolumeToMountNamedVolumeExternalNoCopy(t *testing.T) {
 		},
 	}
 	mount, err := convertVolumeToMount(config, stackVolumes, namespace)
-	assert.NilError(t, err)
-	assert.DeepEqual(t, mount, expected)
+	assert.NoError(t, err)
+	assert.Equal(t, expected, mount)
 }
 
 func TestConvertVolumeToMountBind(t *testing.T) {
@@ -175,8 +175,8 @@ func TestConvertVolumeToMountBind(t *testing.T) {
 		Bind:     &composetypes.ServiceVolumeBind{Propagation: "shared"},
 	}
 	mount, err := convertVolumeToMount(config, stackVolumes, namespace)
-	assert.NilError(t, err)
-	assert.DeepEqual(t, mount, expected)
+	assert.NoError(t, err)
+	assert.Equal(t, expected, mount)
 }
 
 func TestConvertVolumeToMountVolumeDoesNotExist(t *testing.T) {
@@ -188,5 +188,5 @@ func TestConvertVolumeToMountVolumeDoesNotExist(t *testing.T) {
 		ReadOnly: true,
 	}
 	_, err := convertVolumeToMount(config, volumes{}, namespace)
-	assert.Error(t, err, "undefined volume \"unknown\"")
+	assert.EqualError(t, err, "undefined volume \"unknown\"")
 }
diff --git a/cli/compose/loader/volume_test.go b/cli/compose/loader/volume_test.go
index 19d19f2306..9b09c13534 100644
--- a/cli/compose/loader/volume_test.go
+++ b/cli/compose/loader/volume_test.go
@@ -4,15 +4,16 @@ import (
 	"testing"
 
 	"github.com/docker/docker/cli/compose/types"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestParseVolumeAnonymousVolume(t *testing.T) {
 	for _, path := range []string{"/path", "/path/foo"} {
 		volume, err := parseVolume(path)
 		expected := types.ServiceVolumeConfig{Type: "volume", Target: path}
-		assert.NilError(t, err)
-		assert.DeepEqual(t, volume, expected)
+		assert.NoError(t, err)
+		assert.Equal(t, expected, volume)
 	}
 }
 
@@ -20,29 +21,29 @@ func TestParseVolumeAnonymousVolumeWindows(t *testing.T) {
 	for _, path := range []string{"C:\\path", "Z:\\path\\foo"} {
 		volume, err := parseVolume(path)
 		expected := types.ServiceVolumeConfig{Type: "volume", Target: path}
-		assert.NilError(t, err)
-		assert.DeepEqual(t, volume, expected)
+		assert.NoError(t, err)
+		assert.Equal(t, expected, volume)
 	}
 }
 
 func TestParseVolumeTooManyColons(t *testing.T) {
 	_, err := parseVolume("/foo:/foo:ro:foo")
-	assert.Error(t, err, "too many colons")
+	assert.EqualError(t, err, "invalid spec: /foo:/foo:ro:foo: too many colons")
 }
 
 func TestParseVolumeShortVolumes(t *testing.T) {
 	for _, path := range []string{".", "/a"} {
 		volume, err := parseVolume(path)
 		expected := types.ServiceVolumeConfig{Type: "volume", Target: path}
-		assert.NilError(t, err)
-		assert.DeepEqual(t, volume, expected)
+		assert.NoError(t, err)
+		assert.Equal(t, expected, volume)
 	}
 }
 
 func TestParseVolumeMissingSource(t *testing.T) {
 	for _, spec := range []string{":foo", "/foo::ro"} {
 		_, err := parseVolume(spec)
-		assert.Error(t, err, "empty section between colons")
+		testutil.ErrorContains(t, err, "empty section between colons")
 	}
 }
 
@@ -54,8 +55,8 @@ func TestParseVolumeBindMount(t *testing.T) {
 			Source: path,
 			Target: "/target",
 		}
-		assert.NilError(t, err)
-		assert.DeepEqual(t, volume, expected)
+		assert.NoError(t, err)
+		assert.Equal(t, expected, volume)
 	}
 }
 
@@ -72,8 +73,8 @@ func TestParseVolumeRelativeBindMountWindows(t *testing.T) {
 			Source: path,
 			Target: "d:\\target",
 		}
-		assert.NilError(t, err)
-		assert.DeepEqual(t, volume, expected)
+		assert.NoError(t, err)
+		assert.Equal(t, expected, volume)
 	}
 }
 
@@ -85,8 +86,8 @@ func TestParseVolumeWithBindOptions(t *testing.T) {
 		Target: "/target",
 		Bind:   &types.ServiceVolumeBind{Propagation: "slave"},
 	}
-	assert.NilError(t, err)
-	assert.DeepEqual(t, volume, expected)
+	assert.NoError(t, err)
+	assert.Equal(t, expected, volume)
 }
 
 func TestParseVolumeWithBindOptionsWindows(t *testing.T) {
@@ -98,13 +99,13 @@ func TestParseVolumeWithBindOptionsWindows(t *testing.T) {
 		ReadOnly: true,
 		Bind:     &types.ServiceVolumeBind{Propagation: "rprivate"},
 	}
-	assert.NilError(t, err)
-	assert.DeepEqual(t, volume, expected)
+	assert.NoError(t, err)
+	assert.Equal(t, expected, volume)
 }
 
 func TestParseVolumeWithInvalidVolumeOptions(t *testing.T) {
 	_, err := parseVolume("name:/target:bogus")
-	assert.Error(t, err, "invalid spec: name:/target:bogus: unknown option: bogus")
+	assert.EqualError(t, err, "invalid spec: name:/target:bogus: unknown option: bogus")
 }
 
 func TestParseVolumeWithVolumeOptions(t *testing.T) {
@@ -115,8 +116,8 @@ func TestParseVolumeWithVolumeOptions(t *testing.T) {
 		Target: "/target",
 		Volume: &types.ServiceVolumeVolume{NoCopy: true},
 	}
-	assert.NilError(t, err)
-	assert.DeepEqual(t, volume, expected)
+	assert.NoError(t, err)
+	assert.Equal(t, expected, volume)
 }
 
 func TestParseVolumeWithReadOnly(t *testing.T) {
@@ -128,8 +129,8 @@ func TestParseVolumeWithReadOnly(t *testing.T) {
 			Target:   "/target",
 			ReadOnly: true,
 		}
-		assert.NilError(t, err)
-		assert.DeepEqual(t, volume, expected)
+		assert.NoError(t, err)
+		assert.Equal(t, expected, volume)
 	}
 }
 
@@ -142,7 +143,7 @@ func TestParseVolumeWithRW(t *testing.T) {
 			Target:   "/target",
 			ReadOnly: false,
 		}
-		assert.NilError(t, err)
-		assert.DeepEqual(t, volume, expected)
+		assert.NoError(t, err)
+		assert.Equal(t, expected, volume)
 	}
 }
diff --git a/cli/compose/template/template_test.go b/cli/compose/template/template_test.go
index 6b81bf0a39..4ad3f252ac 100644
--- a/cli/compose/template/template_test.go
+++ b/cli/compose/template/template_test.go
@@ -18,7 +18,7 @@ func defaultMapping(name string) (string, bool) {
 
 func TestEscaped(t *testing.T) {
 	result, err := Substitute("$${foo}", defaultMapping)
-	assert.NoError(t, err)
+	assert.Nil(t, err)
 	assert.Equal(t, "${foo}", result)
 }
 
@@ -43,7 +43,7 @@ func TestInvalid(t *testing.T) {
 func TestNoValueNoDefault(t *testing.T) {
 	for _, template := range []string{"This ${missing} var", "This ${BAR} var"} {
 		result, err := Substitute(template, defaultMapping)
-		assert.NoError(t, err)
+		assert.Nil(t, err)
 		assert.Equal(t, "This  var", result)
 	}
 }
@@ -51,7 +51,7 @@ func TestNoValueNoDefault(t *testing.T) {
 func TestValueNoDefault(t *testing.T) {
 	for _, template := range []string{"This $FOO var", "This ${FOO} var"} {
 		result, err := Substitute(template, defaultMapping)
-		assert.NoError(t, err)
+		assert.Nil(t, err)
 		assert.Equal(t, "This first var", result)
 	}
 }
@@ -59,25 +59,25 @@ func TestValueNoDefault(t *testing.T) {
 func TestNoValueWithDefault(t *testing.T) {
 	for _, template := range []string{"ok ${missing:-def}", "ok ${missing-def}"} {
 		result, err := Substitute(template, defaultMapping)
-		assert.NoError(t, err)
+		assert.Nil(t, err)
 		assert.Equal(t, "ok def", result)
 	}
 }
 
 func TestEmptyValueWithSoftDefault(t *testing.T) {
 	result, err := Substitute("ok ${BAR:-def}", defaultMapping)
-	assert.NoError(t, err)
+	assert.Nil(t, err)
 	assert.Equal(t, "ok def", result)
 }
 
 func TestEmptyValueWithHardDefault(t *testing.T) {
 	result, err := Substitute("ok ${BAR-def}", defaultMapping)
-	assert.NoError(t, err)
+	assert.Nil(t, err)
 	assert.Equal(t, "ok ", result)
 }
 
 func TestNonAlphanumericDefault(t *testing.T) {
 	result, err := Substitute("ok ${BAR:-/non:-alphanumeric}", defaultMapping)
-	assert.NoError(t, err)
+	assert.Nil(t, err)
 	assert.Equal(t, "ok /non:-alphanumeric", result)
 }
diff --git a/cli/flags/common_test.go b/cli/flags/common_test.go
index 616d577f0b..cf0bf22e26 100644
--- a/cli/flags/common_test.go
+++ b/cli/flags/common_test.go
@@ -5,8 +5,8 @@ import (
 	"testing"
 
 	cliconfig "github.com/docker/docker/cli/config"
-	"github.com/docker/docker/pkg/testutil/assert"
 	"github.com/spf13/pflag"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestCommonOptionsInstallFlags(t *testing.T) {
@@ -19,9 +19,9 @@ func TestCommonOptionsInstallFlags(t *testing.T) {
 		"--tlscert=\"/foo/cert\"",
 		"--tlskey=\"/foo/key\"",
 	})
-	assert.NilError(t, err)
-	assert.Equal(t, opts.TLSOptions.CAFile, "/foo/cafile")
-	assert.Equal(t, opts.TLSOptions.CertFile, "/foo/cert")
+	assert.NoError(t, err)
+	assert.Equal(t, "/foo/cafile", opts.TLSOptions.CAFile)
+	assert.Equal(t, "/foo/cert", opts.TLSOptions.CertFile)
 	assert.Equal(t, opts.TLSOptions.KeyFile, "/foo/key")
 }
 
@@ -35,8 +35,8 @@ func TestCommonOptionsInstallFlagsWithDefaults(t *testing.T) {
 	opts.InstallFlags(flags)
 
 	err := flags.Parse([]string{})
-	assert.NilError(t, err)
-	assert.Equal(t, opts.TLSOptions.CAFile, defaultPath("ca.pem"))
-	assert.Equal(t, opts.TLSOptions.CertFile, defaultPath("cert.pem"))
-	assert.Equal(t, opts.TLSOptions.KeyFile, defaultPath("key.pem"))
+	assert.NoError(t, err)
+	assert.Equal(t, defaultPath("ca.pem"), opts.TLSOptions.CAFile)
+	assert.Equal(t, defaultPath("cert.pem"), opts.TLSOptions.CertFile)
+	assert.Equal(t, defaultPath("key.pem"), opts.TLSOptions.KeyFile)
 }
diff --git a/client/container_prune_test.go b/client/container_prune_test.go
index 55e551bb4b..8a1c63897b 100644
--- a/client/container_prune_test.go
+++ b/client/container_prune_test.go
@@ -11,7 +11,7 @@ import (
 
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 	"golang.org/x/net/context"
 )
 
@@ -24,7 +24,7 @@ func TestContainersPruneError(t *testing.T) {
 	filters := filters.NewArgs()
 
 	_, err := client.ContainersPrune(context.Background(), filters)
-	assert.Error(t, err, "Error response from daemon: Server error")
+	assert.EqualError(t, err, "Error response from daemon: Server error")
 }
 
 func TestContainersPrune(t *testing.T) {
@@ -99,7 +99,7 @@ func TestContainersPrune(t *testing.T) {
 				query := req.URL.Query()
 				for key, expected := range listCase.expectedQueryParams {
 					actual := query.Get(key)
-					assert.Equal(t, actual, expected)
+					assert.Equal(t, expected, actual)
 				}
 				content, err := json.Marshal(types.ContainersPruneReport{
 					ContainersDeleted: []string{"container_id1", "container_id2"},
@@ -117,8 +117,8 @@ func TestContainersPrune(t *testing.T) {
 		}
 
 		report, err := client.ContainersPrune(context.Background(), listCase.filters)
-		assert.NilError(t, err)
-		assert.Equal(t, len(report.ContainersDeleted), 2)
-		assert.Equal(t, report.SpaceReclaimed, uint64(9999))
+		assert.NoError(t, err)
+		assert.Len(t, report.ContainersDeleted, 2)
+		assert.Equal(t, uint64(9999), report.SpaceReclaimed)
 	}
 }
diff --git a/client/image_prune_test.go b/client/image_prune_test.go
index 5dfb173acc..453f84adee 100644
--- a/client/image_prune_test.go
+++ b/client/image_prune_test.go
@@ -11,7 +11,7 @@ import (
 
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 	"golang.org/x/net/context"
 )
 
@@ -24,7 +24,7 @@ func TestImagesPruneError(t *testing.T) {
 	filters := filters.NewArgs()
 
 	_, err := client.ImagesPrune(context.Background(), filters)
-	assert.Error(t, err, "Error response from daemon: Server error")
+	assert.EqualError(t, err, "Error response from daemon: Server error")
 }
 
 func TestImagesPrune(t *testing.T) {
@@ -87,7 +87,7 @@ func TestImagesPrune(t *testing.T) {
 				query := req.URL.Query()
 				for key, expected := range listCase.expectedQueryParams {
 					actual := query.Get(key)
-					assert.Equal(t, actual, expected)
+					assert.Equal(t, expected, actual)
 				}
 				content, err := json.Marshal(types.ImagesPruneReport{
 					ImagesDeleted: []types.ImageDeleteResponseItem{
@@ -112,8 +112,8 @@ func TestImagesPrune(t *testing.T) {
 		}
 
 		report, err := client.ImagesPrune(context.Background(), listCase.filters)
-		assert.NilError(t, err)
-		assert.Equal(t, len(report.ImagesDeleted), 2)
-		assert.Equal(t, report.SpaceReclaimed, uint64(9999))
+		assert.NoError(t, err)
+		assert.Len(t, report.ImagesDeleted, 2)
+		assert.Equal(t, uint64(9999), report.SpaceReclaimed)
 	}
 }
diff --git a/client/network_prune_test.go b/client/network_prune_test.go
index 2bf4af4716..3e4f5d0415 100644
--- a/client/network_prune_test.go
+++ b/client/network_prune_test.go
@@ -11,7 +11,7 @@ import (
 
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 	"golang.org/x/net/context"
 )
 
@@ -89,7 +89,7 @@ func TestNetworksPrune(t *testing.T) {
 				query := req.URL.Query()
 				for key, expected := range listCase.expectedQueryParams {
 					actual := query.Get(key)
-					assert.Equal(t, actual, expected)
+					assert.Equal(t, expected, actual)
 				}
 				content, err := json.Marshal(types.NetworksPruneReport{
 					NetworksDeleted: []string{"network_id1", "network_id2"},
@@ -106,7 +106,7 @@ func TestNetworksPrune(t *testing.T) {
 		}
 
 		report, err := client.NetworksPrune(context.Background(), listCase.filters)
-		assert.NilError(t, err)
-		assert.Equal(t, len(report.NetworksDeleted), 2)
+		assert.NoError(t, err)
+		assert.Len(t, report.NetworksDeleted, 2)
 	}
 }
diff --git a/cmd/docker/daemon_none_test.go b/cmd/docker/daemon_none_test.go
index bd42add986..af0fcfd670 100644
--- a/cmd/docker/daemon_none_test.go
+++ b/cmd/docker/daemon_none_test.go
@@ -5,7 +5,7 @@ package main
 import (
 	"testing"
 
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestDaemonCommand(t *testing.T) {
@@ -13,5 +13,5 @@ func TestDaemonCommand(t *testing.T) {
 	cmd.SetArgs([]string{"--version"})
 	err := cmd.Execute()
 
-	assert.Error(t, err, "Please run `dockerd`")
+	assert.EqualError(t, err, "Please run `dockerd`")
 }
diff --git a/cmd/docker/daemon_unit_test.go b/cmd/docker/daemon_unit_test.go
index 26348a8843..ffd8a5e2f5 100644
--- a/cmd/docker/daemon_unit_test.go
+++ b/cmd/docker/daemon_unit_test.go
@@ -5,8 +5,8 @@ package main
 import (
 	"testing"
 
-	"github.com/docker/docker/pkg/testutil/assert"
 	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/assert"
 )
 
 func stubRun(cmd *cobra.Command, args []string) error {
@@ -18,7 +18,7 @@ func TestDaemonCommandHelp(t *testing.T) {
 	cmd.RunE = stubRun
 	cmd.SetArgs([]string{"--help"})
 	err := cmd.Execute()
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 }
 
 func TestDaemonCommand(t *testing.T) {
@@ -26,5 +26,5 @@ func TestDaemonCommand(t *testing.T) {
 	cmd.RunE = stubRun
 	cmd.SetArgs([]string{"--containerd", "/foo"})
 	err := cmd.Execute()
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 }
diff --git a/cmd/docker/docker_test.go b/cmd/docker/docker_test.go
index f8a5297ed4..88afb41e9e 100644
--- a/cmd/docker/docker_test.go
+++ b/cmd/docker/docker_test.go
@@ -8,7 +8,7 @@ import (
 	"github.com/Sirupsen/logrus"
 	"github.com/docker/docker/cli/command"
 	"github.com/docker/docker/cli/debug"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestClientDebugEnabled(t *testing.T) {
@@ -18,9 +18,9 @@ func TestClientDebugEnabled(t *testing.T) {
 	cmd.Flags().Set("debug", "true")
 
 	err := cmd.PersistentPreRunE(cmd, []string{})
-	assert.NilError(t, err)
-	assert.Equal(t, os.Getenv("DEBUG"), "1")
-	assert.Equal(t, logrus.GetLevel(), logrus.DebugLevel)
+	assert.NoError(t, err)
+	assert.Equal(t, "1", os.Getenv("DEBUG"))
+	assert.Equal(t, logrus.DebugLevel, logrus.GetLevel())
 }
 
 func TestExitStatusForInvalidSubcommandWithHelpFlag(t *testing.T) {
@@ -28,5 +28,5 @@ func TestExitStatusForInvalidSubcommandWithHelpFlag(t *testing.T) {
 	cmd := newDockerCommand(command.NewDockerCli(os.Stdin, discard, discard))
 	cmd.SetArgs([]string{"help", "invalid"})
 	err := cmd.Execute()
-	assert.Error(t, err, "unknown help topic: invalid")
+	assert.EqualError(t, err, "unknown help topic: invalid")
 }
diff --git a/cmd/dockerd/config_unix_test.go b/cmd/dockerd/config_unix_test.go
index 595b07263b..99b2f90b40 100644
--- a/cmd/dockerd/config_unix_test.go
+++ b/cmd/dockerd/config_unix_test.go
@@ -7,8 +7,8 @@ import (
 	"testing"
 
 	"github.com/docker/docker/daemon/config"
-	"github.com/docker/docker/pkg/testutil/assert"
 	"github.com/spf13/pflag"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestDaemonParseShmSize(t *testing.T) {
@@ -20,13 +20,7 @@ func TestDaemonParseShmSize(t *testing.T) {
 	conf := &config.Config{}
 	installConfigFlags(conf, flags)
 	// By default `--default-shm-size=64M`
-	expectedValue := 64 * 1024 * 1024
-	if conf.ShmSize.Value() != int64(expectedValue) {
-		t.Fatalf("expected default shm size %d, got %d", expectedValue, conf.ShmSize.Value())
-	}
-	assert.NilError(t, flags.Set("default-shm-size", "128M"))
-	expectedValue = 128 * 1024 * 1024
-	if conf.ShmSize.Value() != int64(expectedValue) {
-		t.Fatalf("expected default shm size %d, got %d", expectedValue, conf.ShmSize.Value())
-	}
+	assert.Equal(t, int64(64*1024*1024), conf.ShmSize.Value())
+	assert.NoError(t, flags.Set("default-shm-size", "128M"))
+	assert.Equal(t, int64(128*1024*1024), conf.ShmSize.Value())
 }
diff --git a/cmd/dockerd/daemon_test.go b/cmd/dockerd/daemon_test.go
index dade9c7806..5e60ef55f6 100644
--- a/cmd/dockerd/daemon_test.go
+++ b/cmd/dockerd/daemon_test.go
@@ -6,9 +6,11 @@ import (
 	"github.com/Sirupsen/logrus"
 	cliflags "github.com/docker/docker/cli/flags"
 	"github.com/docker/docker/daemon/config"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/docker/docker/pkg/testutil/tempfile"
 	"github.com/spf13/pflag"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func defaultOptions(configFile string) daemonOptions {
@@ -29,8 +31,8 @@ func TestLoadDaemonCliConfigWithoutOverriding(t *testing.T) {
 	opts.common.Debug = true
 
 	loadedConfig, err := loadDaemonCliConfig(opts)
-	assert.NilError(t, err)
-	assert.NotNil(t, loadedConfig)
+	require.NoError(t, err)
+	require.NotNil(t, loadedConfig)
 	if !loadedConfig.Debug {
 		t.Fatalf("expected debug to be copied from the common flags, got false")
 	}
@@ -42,9 +44,9 @@ func TestLoadDaemonCliConfigWithTLS(t *testing.T) {
 	opts.common.TLS = true
 
 	loadedConfig, err := loadDaemonCliConfig(opts)
-	assert.NilError(t, err)
-	assert.NotNil(t, loadedConfig)
-	assert.Equal(t, loadedConfig.CommonTLSOptions.CAFile, "/tmp/ca.pem")
+	require.NoError(t, err)
+	require.NotNil(t, loadedConfig)
+	assert.Equal(t, "/tmp/ca.pem", loadedConfig.CommonTLSOptions.CAFile)
 }
 
 func TestLoadDaemonCliConfigWithConflicts(t *testing.T) {
@@ -55,12 +57,12 @@ func TestLoadDaemonCliConfigWithConflicts(t *testing.T) {
 	opts := defaultOptions(configFile)
 	flags := opts.flags
 
-	assert.NilError(t, flags.Set("config-file", configFile))
-	assert.NilError(t, flags.Set("label", "l1=bar"))
-	assert.NilError(t, flags.Set("label", "l2=baz"))
+	assert.NoError(t, flags.Set("config-file", configFile))
+	assert.NoError(t, flags.Set("label", "l1=bar"))
+	assert.NoError(t, flags.Set("label", "l2=baz"))
 
 	_, err := loadDaemonCliConfig(opts)
-	assert.Error(t, err, "as a flag and in the configuration file: labels")
+	testutil.ErrorContains(t, err, "as a flag and in the configuration file: labels")
 }
 
 func TestLoadDaemonCliConfigWithTLSVerify(t *testing.T) {
@@ -71,8 +73,8 @@ func TestLoadDaemonCliConfigWithTLSVerify(t *testing.T) {
 	opts.common.TLSOptions.CAFile = "/tmp/ca.pem"
 
 	loadedConfig, err := loadDaemonCliConfig(opts)
-	assert.NilError(t, err)
-	assert.NotNil(t, loadedConfig)
+	require.NoError(t, err)
+	require.NotNil(t, loadedConfig)
 	assert.Equal(t, loadedConfig.TLS, true)
 }
 
@@ -84,9 +86,9 @@ func TestLoadDaemonCliConfigWithExplicitTLSVerifyFalse(t *testing.T) {
 	opts.common.TLSOptions.CAFile = "/tmp/ca.pem"
 
 	loadedConfig, err := loadDaemonCliConfig(opts)
-	assert.NilError(t, err)
-	assert.NotNil(t, loadedConfig)
-	assert.Equal(t, loadedConfig.TLS, true)
+	require.NoError(t, err)
+	require.NotNil(t, loadedConfig)
+	assert.True(t, loadedConfig.TLS)
 }
 
 func TestLoadDaemonCliConfigWithoutTLSVerify(t *testing.T) {
@@ -97,9 +99,9 @@ func TestLoadDaemonCliConfigWithoutTLSVerify(t *testing.T) {
 	opts.common.TLSOptions.CAFile = "/tmp/ca.pem"
 
 	loadedConfig, err := loadDaemonCliConfig(opts)
-	assert.NilError(t, err)
-	assert.NotNil(t, loadedConfig)
-	assert.Equal(t, loadedConfig.TLS, false)
+	require.NoError(t, err)
+	require.NotNil(t, loadedConfig)
+	assert.False(t, loadedConfig.TLS)
 }
 
 func TestLoadDaemonCliConfigWithLogLevel(t *testing.T) {
@@ -108,10 +110,10 @@ func TestLoadDaemonCliConfigWithLogLevel(t *testing.T) {
 
 	opts := defaultOptions(tempFile.Name())
 	loadedConfig, err := loadDaemonCliConfig(opts)
-	assert.NilError(t, err)
-	assert.NotNil(t, loadedConfig)
-	assert.Equal(t, loadedConfig.LogLevel, "warn")
-	assert.Equal(t, logrus.GetLevel(), logrus.WarnLevel)
+	require.NoError(t, err)
+	require.NotNil(t, loadedConfig)
+	assert.Equal(t, "warn", loadedConfig.LogLevel)
+	assert.Equal(t, logrus.WarnLevel, logrus.GetLevel())
 }
 
 func TestLoadDaemonConfigWithEmbeddedOptions(t *testing.T) {
@@ -121,10 +123,10 @@ func TestLoadDaemonConfigWithEmbeddedOptions(t *testing.T) {
 
 	opts := defaultOptions(tempFile.Name())
 	loadedConfig, err := loadDaemonCliConfig(opts)
-	assert.NilError(t, err)
-	assert.NotNil(t, loadedConfig)
-	assert.Equal(t, loadedConfig.CommonTLSOptions.CAFile, "/etc/certs/ca.pem")
-	assert.Equal(t, loadedConfig.LogConfig.Type, "syslog")
+	require.NoError(t, err)
+	require.NotNil(t, loadedConfig)
+	assert.Equal(t, "/etc/certs/ca.pem", loadedConfig.CommonTLSOptions.CAFile)
+	assert.Equal(t, "syslog", loadedConfig.LogConfig.Type)
 }
 
 func TestLoadDaemonConfigWithRegistryOptions(t *testing.T) {
@@ -137,9 +139,9 @@ func TestLoadDaemonConfigWithRegistryOptions(t *testing.T) {
 
 	opts := defaultOptions(tempFile.Name())
 	loadedConfig, err := loadDaemonCliConfig(opts)
-	assert.NilError(t, err)
-	assert.NotNil(t, loadedConfig)
+	require.NoError(t, err)
+	require.NotNil(t, loadedConfig)
 
-	assert.Equal(t, len(loadedConfig.Mirrors), 1)
-	assert.Equal(t, len(loadedConfig.InsecureRegistries), 1)
+	assert.Len(t, loadedConfig.Mirrors, 1)
+	assert.Len(t, loadedConfig.InsecureRegistries, 1)
 }
diff --git a/cmd/dockerd/daemon_unix_test.go b/cmd/dockerd/daemon_unix_test.go
index f757c52e24..4aaa758d53 100644
--- a/cmd/dockerd/daemon_unix_test.go
+++ b/cmd/dockerd/daemon_unix_test.go
@@ -9,8 +9,9 @@ import (
 	"testing"
 
 	"github.com/docker/docker/daemon/config"
-	"github.com/docker/docker/pkg/testutil/assert"
 	"github.com/docker/docker/pkg/testutil/tempfile"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestLoadDaemonCliConfigWithDaemonFlags(t *testing.T) {
@@ -21,17 +22,17 @@ func TestLoadDaemonCliConfigWithDaemonFlags(t *testing.T) {
 	opts := defaultOptions(tempFile.Name())
 	opts.common.Debug = true
 	opts.common.LogLevel = "info"
-	assert.NilError(t, opts.flags.Set("selinux-enabled", "true"))
+	assert.NoError(t, opts.flags.Set("selinux-enabled", "true"))
 
 	loadedConfig, err := loadDaemonCliConfig(opts)
-	assert.NilError(t, err)
-	assert.NotNil(t, loadedConfig)
+	require.NoError(t, err)
+	require.NotNil(t, loadedConfig)
 
-	assert.Equal(t, loadedConfig.Debug, true)
-	assert.Equal(t, loadedConfig.LogLevel, "info")
-	assert.Equal(t, loadedConfig.EnableSelinuxSupport, true)
-	assert.Equal(t, loadedConfig.LogConfig.Type, "json-file")
-	assert.Equal(t, loadedConfig.LogConfig.Config["max-size"], "1k")
+	assert.True(t, loadedConfig.Debug)
+	assert.Equal(t, "info", loadedConfig.LogLevel)
+	assert.True(t, loadedConfig.EnableSelinuxSupport)
+	assert.Equal(t, "json-file", loadedConfig.LogConfig.Type)
+	assert.Equal(t, "1k", loadedConfig.LogConfig.Config["max-size"])
 }
 
 func TestLoadDaemonConfigWithNetwork(t *testing.T) {
@@ -41,11 +42,11 @@ func TestLoadDaemonConfigWithNetwork(t *testing.T) {
 
 	opts := defaultOptions(tempFile.Name())
 	loadedConfig, err := loadDaemonCliConfig(opts)
-	assert.NilError(t, err)
-	assert.NotNil(t, loadedConfig)
+	require.NoError(t, err)
+	require.NotNil(t, loadedConfig)
 
-	assert.Equal(t, loadedConfig.IP, "127.0.0.2")
-	assert.Equal(t, loadedConfig.DefaultIP.String(), "127.0.0.1")
+	assert.Equal(t, "127.0.0.2", loadedConfig.IP)
+	assert.Equal(t, "127.0.0.1", loadedConfig.DefaultIP.String())
 }
 
 func TestLoadDaemonConfigWithMapOptions(t *testing.T) {
@@ -58,14 +59,14 @@ func TestLoadDaemonConfigWithMapOptions(t *testing.T) {
 
 	opts := defaultOptions(tempFile.Name())
 	loadedConfig, err := loadDaemonCliConfig(opts)
-	assert.NilError(t, err)
-	assert.NotNil(t, loadedConfig)
+	require.NoError(t, err)
+	require.NotNil(t, loadedConfig)
 	assert.NotNil(t, loadedConfig.ClusterOpts)
 
 	expectedPath := "/var/lib/docker/discovery_certs/ca.pem"
-	assert.Equal(t, loadedConfig.ClusterOpts["kv.cacertfile"], expectedPath)
+	assert.Equal(t, expectedPath, loadedConfig.ClusterOpts["kv.cacertfile"])
 	assert.NotNil(t, loadedConfig.LogConfig.Config)
-	assert.Equal(t, loadedConfig.LogConfig.Config["tag"], "test")
+	assert.Equal(t, "test", loadedConfig.LogConfig.Config["tag"])
 }
 
 func TestLoadDaemonConfigWithTrueDefaultValues(t *testing.T) {
@@ -75,18 +76,17 @@ func TestLoadDaemonConfigWithTrueDefaultValues(t *testing.T) {
 
 	opts := defaultOptions(tempFile.Name())
 	loadedConfig, err := loadDaemonCliConfig(opts)
-	assert.NilError(t, err)
-	assert.NotNil(t, loadedConfig)
-	assert.NotNil(t, loadedConfig.ClusterOpts)
+	require.NoError(t, err)
+	require.NotNil(t, loadedConfig)
 
-	assert.Equal(t, loadedConfig.EnableUserlandProxy, false)
+	assert.False(t, loadedConfig.EnableUserlandProxy)
 
 	// make sure reloading doesn't generate configuration
 	// conflicts after normalizing boolean values.
 	reload := func(reloadedConfig *config.Config) {
-		assert.Equal(t, reloadedConfig.EnableUserlandProxy, false)
+		assert.False(t, reloadedConfig.EnableUserlandProxy)
 	}
-	assert.NilError(t, config.Reload(opts.configFile, opts.flags, reload))
+	assert.NoError(t, config.Reload(opts.configFile, opts.flags, reload))
 }
 
 func TestLoadDaemonConfigWithTrueDefaultValuesLeaveDefaults(t *testing.T) {
@@ -95,11 +95,10 @@ func TestLoadDaemonConfigWithTrueDefaultValuesLeaveDefaults(t *testing.T) {
 
 	opts := defaultOptions(tempFile.Name())
 	loadedConfig, err := loadDaemonCliConfig(opts)
-	assert.NilError(t, err)
-	assert.NotNil(t, loadedConfig)
-	assert.NotNil(t, loadedConfig.ClusterOpts)
+	require.NoError(t, err)
+	require.NotNil(t, loadedConfig)
 
-	assert.Equal(t, loadedConfig.EnableUserlandProxy, true)
+	assert.True(t, loadedConfig.EnableUserlandProxy)
 }
 
 func TestLoadDaemonConfigWithLegacyRegistryOptions(t *testing.T) {
@@ -109,7 +108,7 @@ func TestLoadDaemonConfigWithLegacyRegistryOptions(t *testing.T) {
 
 	opts := defaultOptions(tempFile.Name())
 	loadedConfig, err := loadDaemonCliConfig(opts)
-	assert.NilError(t, err)
-	assert.NotNil(t, loadedConfig)
-	assert.Equal(t, loadedConfig.V2Only, true)
+	require.NoError(t, err)
+	require.NotNil(t, loadedConfig)
+	assert.True(t, loadedConfig.V2Only)
 }
diff --git a/daemon/config/config_test.go b/daemon/config/config_test.go
index 7508c213c4..cc5f01063c 100644
--- a/daemon/config/config_test.go
+++ b/daemon/config/config_test.go
@@ -9,8 +9,9 @@ import (
 
 	"github.com/docker/docker/daemon/discovery"
 	"github.com/docker/docker/opts"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/spf13/pflag"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestDaemonConfigurationNotFound(t *testing.T) {
@@ -61,9 +62,9 @@ func TestFindConfigurationConflicts(t *testing.T) {
 	flags := pflag.NewFlagSet("test", pflag.ContinueOnError)
 
 	flags.String("authorization-plugins", "", "")
-	assert.NilError(t, flags.Set("authorization-plugins", "asdf"))
+	assert.NoError(t, flags.Set("authorization-plugins", "asdf"))
 
-	assert.Error(t,
+	testutil.ErrorContains(t,
 		findConfigurationConflicts(config, flags),
 		"authorization-plugins: (from flag: asdf, from file: foobar)")
 }
@@ -74,10 +75,10 @@ func TestFindConfigurationConflictsWithNamedOptions(t *testing.T) {
 
 	var hosts []string
 	flags.VarP(opts.NewNamedListOptsRef("hosts", &hosts, opts.ValidateHost), "host", "H", "Daemon socket(s) to connect to")
-	assert.NilError(t, flags.Set("host", "tcp://127.0.0.1:4444"))
-	assert.NilError(t, flags.Set("host", "unix:///var/run/docker.sock"))
+	assert.NoError(t, flags.Set("host", "tcp://127.0.0.1:4444"))
+	assert.NoError(t, flags.Set("host", "unix:///var/run/docker.sock"))
 
-	assert.Error(t, findConfigurationConflicts(config, flags), "hosts")
+	testutil.ErrorContains(t, findConfigurationConflicts(config, flags), "hosts")
 }
 
 func TestDaemonConfigurationMergeConflicts(t *testing.T) {
diff --git a/daemon/delete_test.go b/daemon/delete_test.go
index 21b4696a6d..3113d77aee 100644
--- a/daemon/delete_test.go
+++ b/daemon/delete_test.go
@@ -9,12 +9,13 @@ import (
 	"github.com/docker/docker/api/types"
 	containertypes "github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/container"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
+	"github.com/stretchr/testify/require"
 )
 
 func newDaemonWithTmpRoot(t *testing.T) (*Daemon, func()) {
 	tmp, err := ioutil.TempDir("", "docker-daemon-unix-test-")
-	assert.NilError(t, err)
+	require.NoError(t, err)
 	d := &Daemon{
 		repository: tmp,
 		root:       tmp,
@@ -40,8 +41,8 @@ func TestContainerDeletePaused(t *testing.T) {
 
 	err := d.ContainerRm(c.ID, &types.ContainerRmConfig{ForceRemove: false})
 
-	assert.Error(t, err, "cannot remove a paused container")
-	assert.Error(t, err, "Unpause and then stop the container before attempting removal or force remove")
+	testutil.ErrorContains(t, err, "cannot remove a paused container")
+	testutil.ErrorContains(t, err, "Unpause and then stop the container before attempting removal or force remove")
 }
 
 // TestContainerDeleteRestarting tests that a useful error message and instructions is given when attempting
@@ -63,8 +64,8 @@ func TestContainerDeleteRestarting(t *testing.T) {
 	d.containers.Add(c.ID, c)
 
 	err := d.ContainerRm(c.ID, &types.ContainerRmConfig{ForceRemove: false})
-	assert.Error(t, err, "cannot remove a restarting container")
-	assert.Error(t, err, "Stop the container before attempting removal or force remove")
+	testutil.ErrorContains(t, err, "cannot remove a restarting container")
+	testutil.ErrorContains(t, err, "Stop the container before attempting removal or force remove")
 }
 
 // TestContainerDeleteRunning tests that a useful error message and instructions is given when attempting
@@ -83,8 +84,7 @@ func TestContainerDeleteRunning(t *testing.T) {
 	d.containers.Add(c.ID, c)
 
 	err := d.ContainerRm(c.ID, &types.ContainerRmConfig{ForceRemove: false})
-	assert.Error(t, err, "cannot remove a running container")
-	assert.Error(t, err, "Stop the container before attempting removal or force remove")
+	testutil.ErrorContains(t, err, "cannot remove a running container")
 }
 
 func TestContainerDoubleDelete(t *testing.T) {
@@ -106,5 +106,5 @@ func TestContainerDoubleDelete(t *testing.T) {
 	// Try to remove the container when its state is removalInProgress.
 	// It should return an error indicating it is under removal progress.
 	err := d.ContainerRm(c.ID, &types.ContainerRmConfig{ForceRemove: true})
-	assert.Error(t, err, fmt.Sprintf("removal of container %s is already in progress", c.ID))
+	testutil.ErrorContains(t, err, fmt.Sprintf("removal of container %s is already in progress", c.ID))
 }
diff --git a/image/fs_test.go b/image/fs_test.go
index 76abbdcc42..5f2437cadd 100644
--- a/image/fs_test.go
+++ b/image/fs_test.go
@@ -11,16 +11,17 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/opencontainers/go-digest"
+	"github.com/stretchr/testify/assert"
 )
 
 func defaultFSStoreBackend(t *testing.T) (StoreBackend, func()) {
 	tmpdir, err := ioutil.TempDir("", "images-fs-store")
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	fsBackend, err := NewFSStoreBackend(tmpdir)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	return fsBackend, func() { os.RemoveAll(tmpdir) }
 }
@@ -30,15 +31,15 @@ func TestFSGetInvalidData(t *testing.T) {
 	defer cleanup()
 
 	id, err := store.Set([]byte("foobar"))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	dgst := digest.Digest(id)
 
 	err = ioutil.WriteFile(filepath.Join(store.(*fs).root, contentDirName, string(dgst.Algorithm()), dgst.Hex()), []byte("foobar2"), 0600)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	_, err = store.Get(id)
-	assert.Error(t, err, "failed to verify")
+	testutil.ErrorContains(t, err, "failed to verify")
 }
 
 func TestFSInvalidSet(t *testing.T) {
@@ -47,15 +48,15 @@ func TestFSInvalidSet(t *testing.T) {
 
 	id := digest.FromBytes([]byte("foobar"))
 	err := os.Mkdir(filepath.Join(store.(*fs).root, contentDirName, string(id.Algorithm()), id.Hex()), 0700)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	_, err = store.Set([]byte("foobar"))
-	assert.Error(t, err, "failed to write digest data")
+	testutil.ErrorContains(t, err, "failed to write digest data")
 }
 
 func TestFSInvalidRoot(t *testing.T) {
 	tmpdir, err := ioutil.TempDir("", "images-fs-store")
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 	defer os.RemoveAll(tmpdir)
 
 	tcases := []struct {
@@ -70,14 +71,14 @@ func TestFSInvalidRoot(t *testing.T) {
 		root := filepath.Join(tmpdir, tc.root)
 		filePath := filepath.Join(tmpdir, tc.invalidFile)
 		err := os.MkdirAll(filepath.Dir(filePath), 0700)
-		assert.NilError(t, err)
+		assert.NoError(t, err)
 
 		f, err := os.Create(filePath)
-		assert.NilError(t, err)
+		assert.NoError(t, err)
 		f.Close()
 
 		_, err = NewFSStoreBackend(root)
-		assert.Error(t, err, "failed to create storage backend")
+		testutil.ErrorContains(t, err, "failed to create storage backend")
 
 		os.RemoveAll(root)
 	}
@@ -89,10 +90,10 @@ func TestFSMetadataGetSet(t *testing.T) {
 	defer cleanup()
 
 	id, err := store.Set([]byte("foo"))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	id2, err := store.Set([]byte("bar"))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	tcases := []struct {
 		id    digest.Digest
@@ -106,10 +107,10 @@ func TestFSMetadataGetSet(t *testing.T) {
 
 	for _, tc := range tcases {
 		err = store.SetMetadata(tc.id, tc.key, tc.value)
-		assert.NilError(t, err)
+		assert.NoError(t, err)
 
 		actual, err := store.GetMetadata(tc.id, tc.key)
-		assert.NilError(t, err)
+		assert.NoError(t, err)
 
 		if bytes.Compare(actual, tc.value) != 0 {
 			t.Fatalf("Metadata expected %q, got %q", tc.value, actual)
@@ -117,14 +118,14 @@ func TestFSMetadataGetSet(t *testing.T) {
 	}
 
 	_, err = store.GetMetadata(id2, "tkey2")
-	assert.Error(t, err, "failed to read metadata")
+	testutil.ErrorContains(t, err, "failed to read metadata")
 
 	id3 := digest.FromBytes([]byte("baz"))
 	err = store.SetMetadata(id3, "tkey", []byte("tval"))
-	assert.Error(t, err, "failed to get digest")
+	testutil.ErrorContains(t, err, "failed to get digest")
 
 	_, err = store.GetMetadata(id3, "tkey")
-	assert.Error(t, err, "failed to get digest")
+	testutil.ErrorContains(t, err, "failed to get digest")
 }
 
 func TestFSInvalidWalker(t *testing.T) {
@@ -132,19 +133,19 @@ func TestFSInvalidWalker(t *testing.T) {
 	defer cleanup()
 
 	fooID, err := store.Set([]byte("foo"))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	err = ioutil.WriteFile(filepath.Join(store.(*fs).root, contentDirName, "sha256/foobar"), []byte("foobar"), 0600)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	n := 0
 	err = store.Walk(func(id digest.Digest) error {
-		assert.Equal(t, id, fooID)
+		assert.Equal(t, fooID, id)
 		n++
 		return nil
 	})
-	assert.NilError(t, err)
-	assert.Equal(t, n, 1)
+	assert.NoError(t, err)
+	assert.Equal(t, 1, n)
 }
 
 func TestFSGetSet(t *testing.T) {
@@ -161,12 +162,12 @@ func TestFSGetSet(t *testing.T) {
 
 	randomInput := make([]byte, 8*1024)
 	_, err := rand.Read(randomInput)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	// skipping use of digest pkg because it is used by the implementation
 	h := sha256.New()
 	_, err = h.Write(randomInput)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	tcases = append(tcases, tcase{
 		input:    randomInput,
@@ -175,13 +176,13 @@ func TestFSGetSet(t *testing.T) {
 
 	for _, tc := range tcases {
 		id, err := store.Set([]byte(tc.input))
-		assert.NilError(t, err)
-		assert.Equal(t, id, tc.expected)
+		assert.NoError(t, err)
+		assert.Equal(t, tc.expected, id)
 	}
 
 	for _, tc := range tcases {
 		data, err := store.Get(tc.expected)
-		assert.NilError(t, err)
+		assert.NoError(t, err)
 		if bytes.Compare(data, tc.input) != 0 {
 			t.Fatalf("expected data %q, got %q", tc.input, data)
 		}
@@ -194,7 +195,7 @@ func TestFSGetUnsetKey(t *testing.T) {
 
 	for _, key := range []digest.Digest{"foobar:abc", "sha256:abc", "sha256:c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2a"} {
 		_, err := store.Get(key)
-		assert.Error(t, err, "failed to get digest")
+		testutil.ErrorContains(t, err, "failed to get digest")
 	}
 }
 
@@ -204,7 +205,7 @@ func TestFSGetEmptyData(t *testing.T) {
 
 	for _, emptyData := range [][]byte{nil, {}} {
 		_, err := store.Set(emptyData)
-		assert.Error(t, err, "invalid empty data")
+		testutil.ErrorContains(t, err, "invalid empty data")
 	}
 }
 
@@ -213,25 +214,25 @@ func TestFSDelete(t *testing.T) {
 	defer cleanup()
 
 	id, err := store.Set([]byte("foo"))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	id2, err := store.Set([]byte("bar"))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	err = store.Delete(id)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	_, err = store.Get(id)
-	assert.Error(t, err, "failed to get digest")
+	testutil.ErrorContains(t, err, "failed to get digest")
 
 	_, err = store.Get(id2)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	err = store.Delete(id2)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	_, err = store.Get(id2)
-	assert.Error(t, err, "failed to get digest")
+	testutil.ErrorContains(t, err, "failed to get digest")
 }
 
 func TestFSWalker(t *testing.T) {
@@ -239,10 +240,10 @@ func TestFSWalker(t *testing.T) {
 	defer cleanup()
 
 	id, err := store.Set([]byte("foo"))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	id2, err := store.Set([]byte("bar"))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	tcases := make(map[digest.Digest]struct{})
 	tcases[id] = struct{}{}
@@ -253,9 +254,9 @@ func TestFSWalker(t *testing.T) {
 		n++
 		return nil
 	})
-	assert.NilError(t, err)
-	assert.Equal(t, n, 2)
-	assert.Equal(t, len(tcases), 0)
+	assert.NoError(t, err)
+	assert.Equal(t, 2, n)
+	assert.Len(t, tcases, 0)
 }
 
 func TestFSWalkerStopOnError(t *testing.T) {
@@ -263,12 +264,12 @@ func TestFSWalkerStopOnError(t *testing.T) {
 	defer cleanup()
 
 	id, err := store.Set([]byte("foo"))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	tcases := make(map[digest.Digest]struct{})
 	tcases[id] = struct{}{}
 	err = store.Walk(func(id digest.Digest) error {
 		return errors.New("what")
 	})
-	assert.Error(t, err, "what")
+	testutil.ErrorContains(t, err, "what")
 }
diff --git a/image/image_test.go b/image/image_test.go
index b0561536d3..1455947df2 100644
--- a/image/image_test.go
+++ b/image/image_test.go
@@ -6,7 +6,8 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const sampleImageJSON = `{
@@ -21,13 +22,13 @@ const sampleImageJSON = `{
 
 func TestNewFromJSON(t *testing.T) {
 	img, err := NewFromJSON([]byte(sampleImageJSON))
-	assert.NilError(t, err)
-	assert.Equal(t, string(img.RawJSON()), sampleImageJSON)
+	require.NoError(t, err)
+	assert.Equal(t, sampleImageJSON, string(img.RawJSON()))
 }
 
 func TestNewFromJSONWithInvalidJSON(t *testing.T) {
 	_, err := NewFromJSON([]byte("{}"))
-	assert.Error(t, err, "invalid image JSON, no RootFS key")
+	assert.EqualError(t, err, "invalid image JSON, no RootFS key")
 }
 
 func TestMarshalKeyOrder(t *testing.T) {
@@ -38,7 +39,7 @@ func TestMarshalKeyOrder(t *testing.T) {
 			Architecture: "c",
 		},
 	})
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	expectedOrder := []string{"architecture", "author", "comment"}
 	var indexes []int
diff --git a/image/store_test.go b/image/store_test.go
index bc0148b03e..21a9b0b41b 100644
--- a/image/store_test.go
+++ b/image/store_test.go
@@ -4,8 +4,9 @@ import (
 	"testing"
 
 	"github.com/docker/docker/layer"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
 	"github.com/opencontainers/go-digest"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestRestore(t *testing.T) {
@@ -13,55 +14,55 @@ func TestRestore(t *testing.T) {
 	defer cleanup()
 
 	id1, err := fs.Set([]byte(`{"comment": "abc", "rootfs": {"type": "layers"}}`))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	_, err = fs.Set([]byte(`invalid`))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	id2, err := fs.Set([]byte(`{"comment": "def", "rootfs": {"type": "layers", "diff_ids": ["2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"]}}`))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	err = fs.SetMetadata(id2, "parent", []byte(id1))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	is, err := NewImageStore(fs, &mockLayerGetReleaser{})
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
-	assert.Equal(t, len(is.Map()), 2)
+	assert.Len(t, is.Map(), 2)
 
 	img1, err := is.Get(ID(id1))
-	assert.NilError(t, err)
-	assert.Equal(t, img1.computedID, ID(id1))
-	assert.Equal(t, img1.computedID.String(), string(id1))
+	assert.NoError(t, err)
+	assert.Equal(t, ID(id1), img1.computedID)
+	assert.Equal(t, string(id1), img1.computedID.String())
 
 	img2, err := is.Get(ID(id2))
-	assert.NilError(t, err)
-	assert.Equal(t, img1.Comment, "abc")
-	assert.Equal(t, img2.Comment, "def")
+	assert.NoError(t, err)
+	assert.Equal(t, "abc", img1.Comment)
+	assert.Equal(t, "def", img2.Comment)
 
 	p, err := is.GetParent(ID(id1))
-	assert.Error(t, err, "failed to read metadata")
+	testutil.ErrorContains(t, err, "failed to read metadata")
 
 	p, err = is.GetParent(ID(id2))
-	assert.NilError(t, err)
-	assert.Equal(t, p, ID(id1))
+	assert.NoError(t, err)
+	assert.Equal(t, ID(id1), p)
 
 	children := is.Children(ID(id1))
-	assert.Equal(t, len(children), 1)
-	assert.Equal(t, children[0], ID(id2))
-	assert.Equal(t, len(is.Heads()), 1)
+	assert.Len(t, children, 1)
+	assert.Equal(t, ID(id2), children[0])
+	assert.Len(t, is.Heads(), 1)
 
 	sid1, err := is.Search(string(id1)[:10])
-	assert.NilError(t, err)
-	assert.Equal(t, sid1, ID(id1))
+	assert.NoError(t, err)
+	assert.Equal(t, ID(id1), sid1)
 
 	sid1, err = is.Search(digest.Digest(id1).Hex()[:6])
-	assert.NilError(t, err)
-	assert.Equal(t, sid1, ID(id1))
+	assert.NoError(t, err)
+	assert.Equal(t, ID(id1), sid1)
 
 	invalidPattern := digest.Digest(id1).Hex()[1:6]
 	_, err = is.Search(invalidPattern)
-	assert.Error(t, err, "No such image")
+	testutil.ErrorContains(t, err, "No such image")
 }
 
 func TestAddDelete(t *testing.T) {
@@ -69,34 +70,34 @@ func TestAddDelete(t *testing.T) {
 	defer cleanup()
 
 	id1, err := is.Create([]byte(`{"comment": "abc", "rootfs": {"type": "layers", "diff_ids": ["2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"]}}`))
-	assert.NilError(t, err)
-	assert.Equal(t, id1, ID("sha256:8d25a9c45df515f9d0fe8e4a6b1c64dd3b965a84790ddbcc7954bb9bc89eb993"))
+	assert.NoError(t, err)
+	assert.Equal(t, ID("sha256:8d25a9c45df515f9d0fe8e4a6b1c64dd3b965a84790ddbcc7954bb9bc89eb993"), id1)
 
 	img, err := is.Get(id1)
-	assert.NilError(t, err)
-	assert.Equal(t, img.Comment, "abc")
+	assert.NoError(t, err)
+	assert.Equal(t, "abc", img.Comment)
 
 	id2, err := is.Create([]byte(`{"comment": "def", "rootfs": {"type": "layers", "diff_ids": ["2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"]}}`))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	err = is.SetParent(id2, id1)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	pid1, err := is.GetParent(id2)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, pid1, id1)
 
 	_, err = is.Delete(id1)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	_, err = is.Get(id1)
-	assert.Error(t, err, "failed to get digest")
+	testutil.ErrorContains(t, err, "failed to get digest")
 
 	_, err = is.Get(id2)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	_, err = is.GetParent(id2)
-	assert.Error(t, err, "failed to read metadata")
+	testutil.ErrorContains(t, err, "failed to read metadata")
 }
 
 func TestSearchAfterDelete(t *testing.T) {
@@ -104,17 +105,17 @@ func TestSearchAfterDelete(t *testing.T) {
 	defer cleanup()
 
 	id, err := is.Create([]byte(`{"comment": "abc", "rootfs": {"type": "layers"}}`))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	id1, err := is.Search(string(id)[:15])
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, id1, id)
 
 	_, err = is.Delete(id)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	_, err = is.Search(string(id)[:15])
-	assert.Error(t, err, "No such image")
+	testutil.ErrorContains(t, err, "No such image")
 }
 
 func TestParentReset(t *testing.T) {
@@ -122,27 +123,27 @@ func TestParentReset(t *testing.T) {
 	defer cleanup()
 
 	id, err := is.Create([]byte(`{"comment": "abc1", "rootfs": {"type": "layers"}}`))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	id2, err := is.Create([]byte(`{"comment": "abc2", "rootfs": {"type": "layers"}}`))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	id3, err := is.Create([]byte(`{"comment": "abc3", "rootfs": {"type": "layers"}}`))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
-	assert.NilError(t, is.SetParent(id, id2))
-	assert.Equal(t, len(is.Children(id2)), 1)
+	assert.NoError(t, is.SetParent(id, id2))
+	assert.Len(t, is.Children(id2), 1)
 
-	assert.NilError(t, is.SetParent(id, id3))
-	assert.Equal(t, len(is.Children(id2)), 0)
-	assert.Equal(t, len(is.Children(id3)), 1)
+	assert.NoError(t, is.SetParent(id, id3))
+	assert.Len(t, is.Children(id2), 0)
+	assert.Len(t, is.Children(id3), 1)
 }
 
 func defaultImageStore(t *testing.T) (Store, func()) {
 	fsBackend, cleanup := defaultFSStoreBackend(t)
 
 	store, err := NewImageStore(fsBackend, &mockLayerGetReleaser{})
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	return store, cleanup
 }
diff --git a/opts/mount_test.go b/opts/mount_test.go
index 59606c38e2..72aaa6258e 100644
--- a/opts/mount_test.go
+++ b/opts/mount_test.go
@@ -5,7 +5,9 @@ import (
 	"testing"
 
 	mounttypes "github.com/docker/docker/api/types/mount"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestMountOptString(t *testing.T) {
@@ -24,7 +26,7 @@ func TestMountOptString(t *testing.T) {
 		},
 	}
 	expected := "bind /home/path /target, volume foo /target/foo"
-	assert.Equal(t, mount.String(), expected)
+	assert.Equal(t, expected, mount.String())
 }
 
 func TestMountOptSetBindNoErrorBind(t *testing.T) {
@@ -37,15 +39,15 @@ func TestMountOptSetBindNoErrorBind(t *testing.T) {
 	} {
 		var mount MountOpt
 
-		assert.NilError(t, mount.Set(testcase))
+		assert.NoError(t, mount.Set(testcase))
 
 		mounts := mount.Value()
-		assert.Equal(t, len(mounts), 1)
-		assert.Equal(t, mounts[0], mounttypes.Mount{
+		require.Len(t, mounts, 1)
+		assert.Equal(t, mounttypes.Mount{
 			Type:   mounttypes.TypeBind,
 			Source: "/source",
 			Target: "/target",
-		})
+		}, mounts[0])
 	}
 }
 
@@ -59,15 +61,15 @@ func TestMountOptSetVolumeNoError(t *testing.T) {
 	} {
 		var mount MountOpt
 
-		assert.NilError(t, mount.Set(testcase))
+		assert.NoError(t, mount.Set(testcase))
 
 		mounts := mount.Value()
-		assert.Equal(t, len(mounts), 1)
-		assert.Equal(t, mounts[0], mounttypes.Mount{
+		require.Len(t, mounts, 1)
+		assert.Equal(t, mounttypes.Mount{
 			Type:   mounttypes.TypeVolume,
 			Source: "/source",
 			Target: "/target",
-		})
+		}, mounts[0])
 	}
 }
 
@@ -75,82 +77,82 @@ func TestMountOptSetVolumeNoError(t *testing.T) {
 // volume mount.
 func TestMountOptDefaultType(t *testing.T) {
 	var mount MountOpt
-	assert.NilError(t, mount.Set("target=/target,source=/foo"))
-	assert.Equal(t, mount.values[0].Type, mounttypes.TypeVolume)
+	assert.NoError(t, mount.Set("target=/target,source=/foo"))
+	assert.Equal(t, mounttypes.TypeVolume, mount.values[0].Type)
 }
 
 func TestMountOptSetErrorNoTarget(t *testing.T) {
 	var mount MountOpt
-	assert.Error(t, mount.Set("type=volume,source=/foo"), "target is required")
+	assert.EqualError(t, mount.Set("type=volume,source=/foo"), "target is required")
 }
 
 func TestMountOptSetErrorInvalidKey(t *testing.T) {
 	var mount MountOpt
-	assert.Error(t, mount.Set("type=volume,bogus=foo"), "unexpected key 'bogus'")
+	assert.EqualError(t, mount.Set("type=volume,bogus=foo"), "unexpected key 'bogus' in 'bogus=foo'")
 }
 
 func TestMountOptSetErrorInvalidField(t *testing.T) {
 	var mount MountOpt
-	assert.Error(t, mount.Set("type=volume,bogus"), "invalid field 'bogus'")
+	assert.EqualError(t, mount.Set("type=volume,bogus"), "invalid field 'bogus' must be a key=value pair")
 }
 
 func TestMountOptSetErrorInvalidReadOnly(t *testing.T) {
 	var mount MountOpt
-	assert.Error(t, mount.Set("type=volume,readonly=no"), "invalid value for readonly: no")
-	assert.Error(t, mount.Set("type=volume,readonly=invalid"), "invalid value for readonly: invalid")
+	assert.EqualError(t, mount.Set("type=volume,readonly=no"), "invalid value for readonly: no")
+	assert.EqualError(t, mount.Set("type=volume,readonly=invalid"), "invalid value for readonly: invalid")
 }
 
 func TestMountOptDefaultEnableReadOnly(t *testing.T) {
 	var m MountOpt
-	assert.NilError(t, m.Set("type=bind,target=/foo,source=/foo"))
-	assert.Equal(t, m.values[0].ReadOnly, false)
+	assert.NoError(t, m.Set("type=bind,target=/foo,source=/foo"))
+	assert.False(t, m.values[0].ReadOnly)
 
 	m = MountOpt{}
-	assert.NilError(t, m.Set("type=bind,target=/foo,source=/foo,readonly"))
-	assert.Equal(t, m.values[0].ReadOnly, true)
+	assert.NoError(t, m.Set("type=bind,target=/foo,source=/foo,readonly"))
+	assert.True(t, m.values[0].ReadOnly)
 
 	m = MountOpt{}
-	assert.NilError(t, m.Set("type=bind,target=/foo,source=/foo,readonly=1"))
-	assert.Equal(t, m.values[0].ReadOnly, true)
+	assert.NoError(t, m.Set("type=bind,target=/foo,source=/foo,readonly=1"))
+	assert.True(t, m.values[0].ReadOnly)
 
 	m = MountOpt{}
-	assert.NilError(t, m.Set("type=bind,target=/foo,source=/foo,readonly=true"))
-	assert.Equal(t, m.values[0].ReadOnly, true)
+	assert.NoError(t, m.Set("type=bind,target=/foo,source=/foo,readonly=true"))
+	assert.True(t, m.values[0].ReadOnly)
 
 	m = MountOpt{}
-	assert.NilError(t, m.Set("type=bind,target=/foo,source=/foo,readonly=0"))
-	assert.Equal(t, m.values[0].ReadOnly, false)
+	assert.NoError(t, m.Set("type=bind,target=/foo,source=/foo,readonly=0"))
+	assert.False(t, m.values[0].ReadOnly)
 }
 
 func TestMountOptVolumeNoCopy(t *testing.T) {
 	var m MountOpt
-	assert.NilError(t, m.Set("type=volume,target=/foo,volume-nocopy"))
-	assert.Equal(t, m.values[0].Source, "")
+	assert.NoError(t, m.Set("type=volume,target=/foo,volume-nocopy"))
+	assert.Equal(t, "", m.values[0].Source)
 
 	m = MountOpt{}
-	assert.NilError(t, m.Set("type=volume,target=/foo,source=foo"))
-	assert.Equal(t, m.values[0].VolumeOptions == nil, true)
+	assert.NoError(t, m.Set("type=volume,target=/foo,source=foo"))
+	assert.True(t, m.values[0].VolumeOptions == nil)
 
 	m = MountOpt{}
-	assert.NilError(t, m.Set("type=volume,target=/foo,source=foo,volume-nocopy=true"))
-	assert.Equal(t, m.values[0].VolumeOptions != nil, true)
-	assert.Equal(t, m.values[0].VolumeOptions.NoCopy, true)
+	assert.NoError(t, m.Set("type=volume,target=/foo,source=foo,volume-nocopy=true"))
+	assert.True(t, m.values[0].VolumeOptions != nil)
+	assert.True(t, m.values[0].VolumeOptions.NoCopy)
 
 	m = MountOpt{}
-	assert.NilError(t, m.Set("type=volume,target=/foo,source=foo,volume-nocopy"))
-	assert.Equal(t, m.values[0].VolumeOptions != nil, true)
-	assert.Equal(t, m.values[0].VolumeOptions.NoCopy, true)
+	assert.NoError(t, m.Set("type=volume,target=/foo,source=foo,volume-nocopy"))
+	assert.True(t, m.values[0].VolumeOptions != nil)
+	assert.True(t, m.values[0].VolumeOptions.NoCopy)
 
 	m = MountOpt{}
-	assert.NilError(t, m.Set("type=volume,target=/foo,source=foo,volume-nocopy=1"))
-	assert.Equal(t, m.values[0].VolumeOptions != nil, true)
-	assert.Equal(t, m.values[0].VolumeOptions.NoCopy, true)
+	assert.NoError(t, m.Set("type=volume,target=/foo,source=foo,volume-nocopy=1"))
+	assert.True(t, m.values[0].VolumeOptions != nil)
+	assert.True(t, m.values[0].VolumeOptions.NoCopy)
 }
 
 func TestMountOptTypeConflict(t *testing.T) {
 	var m MountOpt
-	assert.Error(t, m.Set("type=bind,target=/foo,source=/foo,volume-nocopy=true"), "cannot mix")
-	assert.Error(t, m.Set("type=volume,target=/foo,source=/foo,bind-propagation=rprivate"), "cannot mix")
+	testutil.ErrorContains(t, m.Set("type=bind,target=/foo,source=/foo,volume-nocopy=true"), "cannot mix")
+	testutil.ErrorContains(t, m.Set("type=volume,target=/foo,source=/foo,bind-propagation=rprivate"), "cannot mix")
 }
 
 func TestMountOptSetTmpfsNoError(t *testing.T) {
@@ -161,24 +163,24 @@ func TestMountOptSetTmpfsNoError(t *testing.T) {
 	} {
 		var mount MountOpt
 
-		assert.NilError(t, mount.Set(testcase))
+		assert.NoError(t, mount.Set(testcase))
 
 		mounts := mount.Value()
-		assert.Equal(t, len(mounts), 1)
-		assert.DeepEqual(t, mounts[0], mounttypes.Mount{
+		require.Len(t, mounts, 1)
+		assert.Equal(t, mounttypes.Mount{
 			Type:   mounttypes.TypeTmpfs,
 			Target: "/target",
 			TmpfsOptions: &mounttypes.TmpfsOptions{
 				SizeBytes: 1024 * 1024, // not 1000 * 1000
 				Mode:      os.FileMode(0700),
 			},
-		})
+		}, mounts[0])
 	}
 }
 
 func TestMountOptSetTmpfsError(t *testing.T) {
 	var m MountOpt
-	assert.Error(t, m.Set("type=tmpfs,target=/foo,tmpfs-size=foo"), "invalid value for tmpfs-size")
-	assert.Error(t, m.Set("type=tmpfs,target=/foo,tmpfs-mode=foo"), "invalid value for tmpfs-mode")
-	assert.Error(t, m.Set("type=tmpfs"), "target is required")
+	testutil.ErrorContains(t, m.Set("type=tmpfs,target=/foo,tmpfs-size=foo"), "invalid value for tmpfs-size")
+	testutil.ErrorContains(t, m.Set("type=tmpfs,target=/foo,tmpfs-mode=foo"), "invalid value for tmpfs-mode")
+	testutil.ErrorContains(t, m.Set("type=tmpfs"), "target is required")
 }
diff --git a/opts/port_test.go b/opts/port_test.go
index a483d269aa..9315b7218c 100644
--- a/opts/port_test.go
+++ b/opts/port_test.go
@@ -4,7 +4,8 @@ import (
 	"testing"
 
 	"github.com/docker/docker/api/types/swarm"
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/docker/docker/pkg/testutil"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestPortOptValidSimpleSyntax(t *testing.T) {
@@ -98,8 +99,8 @@ func TestPortOptValidSimpleSyntax(t *testing.T) {
 	}
 	for _, tc := range testCases {
 		var port PortOpt
-		assert.NilError(t, port.Set(tc.value))
-		assert.Equal(t, len(port.Value()), len(tc.expected))
+		assert.NoError(t, port.Set(tc.value))
+		assert.Len(t, port.Value(), len(tc.expected))
 		for _, expectedPortConfig := range tc.expected {
 			assertContains(t, port.Value(), expectedPortConfig)
 		}
@@ -189,8 +190,8 @@ func TestPortOptValidComplexSyntax(t *testing.T) {
 	}
 	for _, tc := range testCases {
 		var port PortOpt
-		assert.NilError(t, port.Set(tc.value))
-		assert.Equal(t, len(port.Value()), len(tc.expected))
+		assert.NoError(t, port.Set(tc.value))
+		assert.Len(t, port.Value(), len(tc.expected))
 		for _, expectedPortConfig := range tc.expected {
 			assertContains(t, port.Value(), expectedPortConfig)
 		}
@@ -241,7 +242,7 @@ func TestPortOptInvalidComplexSyntax(t *testing.T) {
 	}
 	for _, tc := range testCases {
 		var port PortOpt
-		assert.Error(t, port.Set(tc.value), tc.expectedError)
+		testutil.ErrorContains(t, port.Set(tc.value), tc.expectedError)
 	}
 }
 
@@ -268,16 +269,16 @@ func TestPortOptInvalidSimpleSyntax(t *testing.T) {
 		},
 		{
 			value:         "",
-			expectedError: "No port specified",
+			expectedError: "No port specified: <empty>",
 		},
 		{
 			value:         "1.1.1.1:80:80",
-			expectedError: "HostIP is not supported",
+			expectedError: "HostIP is not supported.",
 		},
 	}
 	for _, tc := range testCases {
 		var port PortOpt
-		assert.Error(t, port.Set(tc.value), tc.expectedError)
+		assert.EqualError(t, port.Set(tc.value), tc.expectedError)
 	}
 }
 
diff --git a/opts/quotedstring_test.go b/opts/quotedstring_test.go
index 0ebf04bbe0..54dcbc19bc 100644
--- a/opts/quotedstring_test.go
+++ b/opts/quotedstring_test.go
@@ -1,28 +1,29 @@
 package opts
 
 import (
-	"github.com/docker/docker/pkg/testutil/assert"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestQuotedStringSetWithQuotes(t *testing.T) {
 	value := ""
 	qs := NewQuotedString(&value)
-	assert.NilError(t, qs.Set("\"something\""))
-	assert.Equal(t, qs.String(), "something")
-	assert.Equal(t, value, "something")
+	assert.NoError(t, qs.Set(`"something"`))
+	assert.Equal(t, "something", qs.String())
+	assert.Equal(t, "something", value)
 }
 
 func TestQuotedStringSetWithMismatchedQuotes(t *testing.T) {
 	value := ""
 	qs := NewQuotedString(&value)
-	assert.NilError(t, qs.Set("\"something'"))
-	assert.Equal(t, qs.String(), "\"something'")
+	assert.NoError(t, qs.Set(`"something'`))
+	assert.Equal(t, `"something'`, qs.String())
 }
 
 func TestQuotedStringSetWithNoQuotes(t *testing.T) {
 	value := ""
 	qs := NewQuotedString(&value)
-	assert.NilError(t, qs.Set("something"))
-	assert.Equal(t, qs.String(), "something")
+	assert.NoError(t, qs.Set("something"))
+	assert.Equal(t, "something", qs.String())
 }
diff --git a/opts/secret_test.go b/opts/secret_test.go
index 5654c79f1f..ad0005e4ad 100644
--- a/opts/secret_test.go
+++ b/opts/secret_test.go
@@ -4,76 +4,77 @@ import (
 	"os"
 	"testing"
 
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestSecretOptionsSimple(t *testing.T) {
 	var opt SecretOpt
 
 	testCase := "app-secret"
-	assert.NilError(t, opt.Set(testCase))
+	assert.NoError(t, opt.Set(testCase))
 
 	reqs := opt.Value()
-	assert.Equal(t, len(reqs), 1)
+	require.Len(t, reqs, 1)
 	req := reqs[0]
-	assert.Equal(t, req.SecretName, "app-secret")
-	assert.Equal(t, req.File.Name, "app-secret")
-	assert.Equal(t, req.File.UID, "0")
-	assert.Equal(t, req.File.GID, "0")
+	assert.Equal(t, "app-secret", req.SecretName)
+	assert.Equal(t, "app-secret", req.File.Name)
+	assert.Equal(t, "0", req.File.UID)
+	assert.Equal(t, "0", req.File.GID)
 }
 
 func TestSecretOptionsSourceTarget(t *testing.T) {
 	var opt SecretOpt
 
 	testCase := "source=foo,target=testing"
-	assert.NilError(t, opt.Set(testCase))
+	assert.NoError(t, opt.Set(testCase))
 
 	reqs := opt.Value()
-	assert.Equal(t, len(reqs), 1)
+	require.Len(t, reqs, 1)
 	req := reqs[0]
-	assert.Equal(t, req.SecretName, "foo")
-	assert.Equal(t, req.File.Name, "testing")
+	assert.Equal(t, "foo", req.SecretName)
+	assert.Equal(t, "testing", req.File.Name)
 }
 
 func TestSecretOptionsShorthand(t *testing.T) {
 	var opt SecretOpt
 
 	testCase := "src=foo,target=testing"
-	assert.NilError(t, opt.Set(testCase))
+	assert.NoError(t, opt.Set(testCase))
 
 	reqs := opt.Value()
-	assert.Equal(t, len(reqs), 1)
+	require.Len(t, reqs, 1)
 	req := reqs[0]
-	assert.Equal(t, req.SecretName, "foo")
+	assert.Equal(t, "foo", req.SecretName)
 }
 
 func TestSecretOptionsCustomUidGid(t *testing.T) {
 	var opt SecretOpt
 
 	testCase := "source=foo,target=testing,uid=1000,gid=1001"
-	assert.NilError(t, opt.Set(testCase))
+	assert.NoError(t, opt.Set(testCase))
 
 	reqs := opt.Value()
-	assert.Equal(t, len(reqs), 1)
+	require.Len(t, reqs, 1)
 	req := reqs[0]
-	assert.Equal(t, req.SecretName, "foo")
-	assert.Equal(t, req.File.Name, "testing")
-	assert.Equal(t, req.File.UID, "1000")
-	assert.Equal(t, req.File.GID, "1001")
+	assert.Equal(t, "foo", req.SecretName)
+	assert.Equal(t, "testing", req.File.Name)
+	assert.Equal(t, "1000", req.File.UID)
+	assert.Equal(t, "1001", req.File.GID)
 }
 
 func TestSecretOptionsCustomMode(t *testing.T) {
 	var opt SecretOpt
 
 	testCase := "source=foo,target=testing,uid=1000,gid=1001,mode=0444"
-	assert.NilError(t, opt.Set(testCase))
+	assert.NoError(t, opt.Set(testCase))
 
 	reqs := opt.Value()
-	assert.Equal(t, len(reqs), 1)
+	require.Len(t, reqs, 1)
 	req := reqs[0]
-	assert.Equal(t, req.SecretName, "foo")
-	assert.Equal(t, req.File.Name, "testing")
-	assert.Equal(t, req.File.UID, "1000")
-	assert.Equal(t, req.File.GID, "1001")
-	assert.Equal(t, req.File.Mode, os.FileMode(0444))
+	assert.Equal(t, "foo", req.SecretName)
+	assert.Equal(t, "testing", req.File.Name)
+	assert.Equal(t, "1000", req.File.UID)
+	assert.Equal(t, "1001", req.File.GID)
+	assert.Equal(t, os.FileMode(0444), req.File.Mode)
 }
diff --git a/pkg/archive/archive_test.go b/pkg/archive/archive_test.go
index 481369da73..e351a0455b 100644
--- a/pkg/archive/archive_test.go
+++ b/pkg/archive/archive_test.go
@@ -14,7 +14,8 @@ import (
 	"testing"
 	"time"
 
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 var tmp string
@@ -1211,19 +1212,19 @@ func TestReplaceFileTarWrapper(t *testing.T) {
 			map[string]TarModifierFunc{testcase.filename: testcase.modifier})
 
 		actual := readFileFromArchive(t, resultArchive, testcase.filename, testcase.fileCount, testcase.doc)
-		assert.Equal(t, actual, testcase.expected, testcase.doc)
+		assert.Equal(t, testcase.expected, actual, testcase.doc)
 	}
 }
 
 func buildSourceArchive(t *testing.T, numberOfFiles int) (io.ReadCloser, func()) {
 	srcDir, err := ioutil.TempDir("", "docker-test-srcDir")
-	assert.NilError(t, err)
+	require.NoError(t, err)
 
 	_, err = prepareUntarSourceDirectory(numberOfFiles, srcDir, false)
-	assert.NilError(t, err)
+	require.NoError(t, err)
 
 	sourceArchive, err := TarWithOptions(srcDir, &TarOptions{})
-	assert.NilError(t, err)
+	require.NoError(t, err)
 	return sourceArchive, func() {
 		os.RemoveAll(srcDir)
 		sourceArchive.Close()
@@ -1257,16 +1258,16 @@ func appendModifier(path string, header *tar.Header, content io.Reader) (*tar.He
 
 func readFileFromArchive(t *testing.T, archive io.ReadCloser, name string, expectedCount int, doc string) string {
 	destDir, err := ioutil.TempDir("", "docker-test-destDir")
-	assert.NilError(t, err)
+	require.NoError(t, err)
 	defer os.RemoveAll(destDir)
 
 	err = Untar(archive, destDir, nil)
-	assert.NilError(t, err)
+	require.NoError(t, err)
 
 	files, _ := ioutil.ReadDir(destDir)
-	assert.Equal(t, len(files), expectedCount, doc)
+	assert.Len(t, files, expectedCount, doc)
 
 	content, err := ioutil.ReadFile(filepath.Join(destDir, name))
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 	return string(content)
 }
diff --git a/pkg/templates/templates_test.go b/pkg/templates/templates_test.go
index 7fa1df64ee..f972571912 100644
--- a/pkg/templates/templates_test.go
+++ b/pkg/templates/templates_test.go
@@ -4,27 +4,27 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestParseStringFunctions(t *testing.T) {
 	tm, err := Parse(`{{join (split . ":") "/"}}`)
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	var b bytes.Buffer
-	assert.NilError(t, tm.Execute(&b, "text:with:colon"))
+	assert.NoError(t, tm.Execute(&b, "text:with:colon"))
 	want := "text/with/colon"
-	assert.Equal(t, b.String(), want)
+	assert.Equal(t, want, b.String())
 }
 
 func TestNewParse(t *testing.T) {
 	tm, err := NewParse("foo", "this is a {{ . }}")
-	assert.NilError(t, err)
+	assert.NoError(t, err)
 
 	var b bytes.Buffer
-	assert.NilError(t, tm.Execute(&b, "string"))
+	assert.NoError(t, tm.Execute(&b, "string"))
 	want := "this is a string"
-	assert.Equal(t, b.String(), want)
+	assert.Equal(t, want, b.String())
 }
 
 func TestParseTruncateFunction(t *testing.T) {
@@ -50,10 +50,10 @@ func TestParseTruncateFunction(t *testing.T) {
 
 	for _, testCase := range testCases {
 		tm, err := Parse(testCase.template)
-		assert.NilError(t, err)
+		assert.NoError(t, err)
 
 		var b bytes.Buffer
-		assert.NilError(t, tm.Execute(&b, source))
-		assert.Equal(t, b.String(), testCase.expected)
+		assert.NoError(t, tm.Execute(&b, source))
+		assert.Equal(t, testCase.expected, b.String())
 	}
 }
diff --git a/pkg/testutil/assert/assert.go b/pkg/testutil/assert/assert.go
deleted file mode 100644
index fdc0fab5d8..0000000000
--- a/pkg/testutil/assert/assert.go
+++ /dev/null
@@ -1,132 +0,0 @@
-// Package assert contains functions for making assertions in unit tests
-package assert
-
-import (
-	"fmt"
-	"path/filepath"
-	"reflect"
-	"runtime"
-	"strings"
-	"unicode"
-
-	"github.com/davecgh/go-spew/spew"
-)
-
-// TestingT is an interface which defines the methods of testing.T that are
-// required by this package
-type TestingT interface {
-	Fatalf(string, ...interface{})
-}
-
-// Equal compare the actual value to the expected value and fails the test if
-// they are not equal.
-func Equal(t TestingT, actual, expected interface{}, extra ...string) {
-	if expected != actual {
-		fatalWithExtra(t, extra, "Expected '%v' (%T) got '%v' (%T)", expected, expected, actual, actual)
-	}
-}
-
-// EqualNormalizedString compare the actual value to the expected value after applying the specified
-// transform function. It fails the test if these two transformed string are not equal.
-// For example `EqualNormalizedString(t, RemoveSpace, "foo\n", "foo")` wouldn't fail the test as
-// spaces (and thus '\n') are removed before comparing the string.
-func EqualNormalizedString(t TestingT, transformFun func(rune) rune, actual, expected string) {
-	if strings.Map(transformFun, actual) != strings.Map(transformFun, expected) {
-		fatal(t, "Expected '%v' got '%v'", expected, expected, actual, actual)
-	}
-}
-
-// RemoveSpace returns -1 if the specified runes is considered as a space (unicode)
-// and the rune itself otherwise.
-func RemoveSpace(r rune) rune {
-	if unicode.IsSpace(r) {
-		return -1
-	}
-	return r
-}
-
-//EqualStringSlice compares two slices and fails the test if they do not contain
-// the same items.
-func EqualStringSlice(t TestingT, actual, expected []string) {
-	if len(actual) != len(expected) {
-		fatal(t, "Expected (length %d): %q\nActual (length %d): %q",
-			len(expected), expected, len(actual), actual)
-	}
-	for i, item := range actual {
-		if item != expected[i] {
-			fatal(t, "Slices differ at element %d, expected %q got %q",
-				i, expected[i], item)
-		}
-	}
-}
-
-// NilError asserts that the error is nil, otherwise it fails the test.
-func NilError(t TestingT, err error) {
-	if err != nil {
-		fatal(t, "Expected no error, got: %s", err.Error())
-	}
-}
-
-// DeepEqual compare the actual value to the expected value and fails the test if
-// they are not "deeply equal".
-func DeepEqual(t TestingT, actual, expected interface{}) {
-	if !reflect.DeepEqual(actual, expected) {
-		fatal(t, "Expected (%T):\n%v\n\ngot (%T):\n%s\n",
-			expected, spew.Sdump(expected), actual, spew.Sdump(actual))
-	}
-}
-
-// Error asserts that error is not nil, and contains the expected text,
-// otherwise it fails the test.
-func Error(t TestingT, err error, contains string) {
-	if err == nil {
-		fatal(t, "Expected an error, but error was nil")
-	}
-
-	if !strings.Contains(err.Error(), contains) {
-		fatal(t, "Expected error to contain '%s', got '%s'", contains, err.Error())
-	}
-}
-
-// Contains asserts that the string contains a substring, otherwise it fails the
-// test.
-func Contains(t TestingT, actual, contains string) {
-	if !strings.Contains(actual, contains) {
-		fatal(t, "Expected '%s' to contain '%s'", actual, contains)
-	}
-}
-
-// NotNil fails the test if the object is nil
-func NotNil(t TestingT, obj interface{}) {
-	if obj == nil {
-		fatal(t, "Expected non-nil value.")
-	}
-}
-
-// Nil fails the test if the object is not nil
-func Nil(t TestingT, obj interface{}) {
-	if obj != nil {
-		fatal(t, "Expected nil value, got (%T) %s", obj, obj)
-	}
-}
-
-func fatal(t TestingT, format string, args ...interface{}) {
-	t.Fatalf(errorSource()+format, args...)
-}
-
-func fatalWithExtra(t TestingT, extra []string, format string, args ...interface{}) {
-	msg := fmt.Sprintf(errorSource()+format, args...)
-	if len(extra) > 0 {
-		msg += ": " + strings.Join(extra, ", ")
-	}
-	t.Fatalf(msg)
-}
-
-// See testing.decorate()
-func errorSource() string {
-	_, filename, line, ok := runtime.Caller(3)
-	if !ok {
-		return ""
-	}
-	return fmt.Sprintf("%s:%d: ", filepath.Base(filename), line)
-}
diff --git a/pkg/testutil/cmd/command_test.go b/pkg/testutil/cmd/command_test.go
index df23442079..d24b42b726 100644
--- a/pkg/testutil/cmd/command_test.go
+++ b/pkg/testutil/cmd/command_test.go
@@ -6,7 +6,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/docker/docker/pkg/testutil/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestRunCommand(t *testing.T) {
@@ -74,7 +74,7 @@ func TestRunCommandWithTimeoutKilled(t *testing.T) {
 	result.Assert(t, Expected{Timeout: true})
 
 	ones := strings.Split(result.Stdout(), "\n")
-	assert.Equal(t, len(ones), 4)
+	assert.Len(t, ones, 4)
 }
 
 func TestRunCommandWithErrors(t *testing.T) {
diff --git a/pkg/testutil/helpers.go b/pkg/testutil/helpers.go
new file mode 100644
index 0000000000..c291148712
--- /dev/null
+++ b/pkg/testutil/helpers.go
@@ -0,0 +1,33 @@
+package testutil
+
+import (
+	"strings"
+	"unicode"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// ErrorContains checks that the error is not nil, and contains the expected
+// substring.
+func ErrorContains(t require.TestingT, err error, expectedError string) {
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), expectedError)
+}
+
+// EqualNormalizedString compare the actual value to the expected value after applying the specified
+// transform function. It fails the test if these two transformed string are not equal.
+// For example `EqualNormalizedString(t, RemoveSpace, "foo\n", "foo")` wouldn't fail the test as
+// spaces (and thus '\n') are removed before comparing the string.
+func EqualNormalizedString(t require.TestingT, transformFun func(rune) rune, actual, expected string) {
+	require.Equal(t, strings.Map(transformFun, expected), strings.Map(transformFun, actual))
+}
+
+// RemoveSpace returns -1 if the specified runes is considered as a space (unicode)
+// and the rune itself otherwise.
+func RemoveSpace(r rune) rune {
+	if unicode.IsSpace(r) {
+		return -1
+	}
+	return r
+}
diff --git a/pkg/testutil/tempfile/tempfile.go b/pkg/testutil/tempfile/tempfile.go
index 48c654d1f4..b375cb9561 100644
--- a/pkg/testutil/tempfile/tempfile.go
+++ b/pkg/testutil/tempfile/tempfile.go
@@ -1,9 +1,10 @@
 package tempfile
 
 import (
-	"github.com/docker/docker/pkg/testutil/assert"
 	"io/ioutil"
 	"os"
+
+	"github.com/stretchr/testify/require"
 )
 
 // TempFile is a temporary file that can be used with unit tests. TempFile
@@ -14,12 +15,12 @@ type TempFile struct {
 }
 
 // NewTempFile returns a new temp file with contents
-func NewTempFile(t assert.TestingT, prefix string, content string) *TempFile {
+func NewTempFile(t require.TestingT, prefix string, content string) *TempFile {
 	file, err := ioutil.TempFile("", prefix+"-")
-	assert.NilError(t, err)
+	require.NoError(t, err)
 
 	_, err = file.Write([]byte(content))
-	assert.NilError(t, err)
+	require.NoError(t, err)
 	file.Close()
 	return &TempFile{File: file}
 }
diff --git a/vendor.conf b/vendor.conf
index c302b9398d..75e68008fb 100644
--- a/vendor.conf
+++ b/vendor.conf
@@ -4,7 +4,7 @@ github.com/Microsoft/hcsshim v0.5.13
 # TODO: get rid of this fork once PR https://github.com/Microsoft/go-winio/pull/43 is merged
 github.com/Microsoft/go-winio 7c7d6b461cb10872c1138a0d7f3acf9a41b5c353 https://github.com/dgageot/go-winio.git
 github.com/Sirupsen/logrus v0.11.0
-github.com/davecgh/go-spew 6d212800a42e8ab5c146b8ace3490ee17e5225f9
+github.com/davecgh/go-spew 346938d642f2ec3594ed81d874461961cd0faa76
 github.com/docker/libtrust 9cbd2a1374f46905c68a4eb3694a130610adc62a
 github.com/go-check/check 4ed411733c5785b40214c70bce814c3a3a689609 https://github.com/cpuguy83/check.git
 github.com/gorilla/context v1.1
@@ -19,6 +19,7 @@ golang.org/x/sys 8f0908ab3b2457e2e15403d3697c9ef5cb4b57a9
 github.com/docker/go-units 9e638d38cf6977a37a8ea0078f3ee75a7cdb2dd1
 github.com/docker/go-connections e15c02316c12de00874640cd76311849de2aeed5
 golang.org/x/text f72d8390a633d5dfb0cc84043294db9f6c935756
+github.com/stretchr/testify 4d4bfba8f1d1027c4fdbe371823030df51419987
 
 github.com/RackSec/srslog 456df3a81436d29ba874f3590eeeee25d666f8a5
 github.com/imdario/mergo 0.2.1
diff --git a/vendor/github.com/davecgh/go-spew/LICENSE b/vendor/github.com/davecgh/go-spew/LICENSE
index bb67332310..c836416192 100644
--- a/vendor/github.com/davecgh/go-spew/LICENSE
+++ b/vendor/github.com/davecgh/go-spew/LICENSE
@@ -1,6 +1,6 @@
 ISC License
 
-Copyright (c) 2012-2013 Dave Collins <dave@davec.name>
+Copyright (c) 2012-2016 Dave Collins <dave@davec.name>
 
 Permission to use, copy, modify, and distribute this software for any
 purpose with or without fee is hereby granted, provided that the above
diff --git a/vendor/github.com/davecgh/go-spew/README.md b/vendor/github.com/davecgh/go-spew/README.md
index 556170ae63..262430449b 100644
--- a/vendor/github.com/davecgh/go-spew/README.md
+++ b/vendor/github.com/davecgh/go-spew/README.md
@@ -1,11 +1,13 @@
 go-spew
 =======
 
-[![Build Status](https://travis-ci.org/davecgh/go-spew.png?branch=master)]
-(https://travis-ci.org/davecgh/go-spew) [![Coverage Status]
-(https://coveralls.io/repos/davecgh/go-spew/badge.png?branch=master)]
+[![Build Status](https://img.shields.io/travis/davecgh/go-spew.svg)]
+(https://travis-ci.org/davecgh/go-spew) [![ISC License]
+(http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org) [![Coverage Status]
+(https://img.shields.io/coveralls/davecgh/go-spew.svg)]
 (https://coveralls.io/r/davecgh/go-spew?branch=master)
 
+
 Go-spew implements a deep pretty printer for Go data structures to aid in
 debugging.  A comprehensive suite of tests with 100% test coverage is provided
 to ensure proper functionality.  See `test_coverage.txt` for the gocov coverage
@@ -19,7 +21,7 @@ post about it
 
 ## Documentation
 
-[![GoDoc](https://godoc.org/github.com/davecgh/go-spew/spew?status.png)]
+[![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)]
 (http://godoc.org/github.com/davecgh/go-spew/spew)
 
 Full `go doc` style documentation for the project can be viewed online without
@@ -160,6 +162,15 @@ options. See the ConfigState documentation for more details.
 	App Engine or with the "safe" build tag specified.
 	Pointer method invocation is enabled by default.
 
+* DisablePointerAddresses
+	DisablePointerAddresses specifies whether to disable the printing of
+	pointer addresses. This is useful when diffing data structures in tests.
+
+* DisableCapacities
+	DisableCapacities specifies whether to disable the printing of capacities
+	for arrays, slices, maps and channels. This is useful when diffing data
+	structures in tests.
+
 * ContinueOnMethod
 	Enables recursion into types after invoking error and Stringer interface
 	methods. Recursion after method invocation is disabled by default.
@@ -191,4 +202,4 @@ using the unsafe package.
 
 ## License
 
-Go-spew is licensed under the liberal ISC License.
+Go-spew is licensed under the [copyfree](http://copyfree.org) ISC License.
diff --git a/vendor/github.com/davecgh/go-spew/spew/bypass.go b/vendor/github.com/davecgh/go-spew/spew/bypass.go
index d42a0bc4af..8a4a6589a2 100644
--- a/vendor/github.com/davecgh/go-spew/spew/bypass.go
+++ b/vendor/github.com/davecgh/go-spew/spew/bypass.go
@@ -1,4 +1,4 @@
-// Copyright (c) 2015 Dave Collins <dave@davec.name>
+// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
 //
 // Permission to use, copy, modify, and distribute this software for any
 // purpose with or without fee is hereby granted, provided that the above
diff --git a/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go b/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go
index e47a4e7951..1fe3cf3d5d 100644
--- a/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go
+++ b/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go
@@ -1,4 +1,4 @@
-// Copyright (c) 2015 Dave Collins <dave@davec.name>
+// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
 //
 // Permission to use, copy, modify, and distribute this software for any
 // purpose with or without fee is hereby granted, provided that the above
diff --git a/vendor/github.com/davecgh/go-spew/spew/common.go b/vendor/github.com/davecgh/go-spew/spew/common.go
index 14f02dc15b..7c519ff47a 100644
--- a/vendor/github.com/davecgh/go-spew/spew/common.go
+++ b/vendor/github.com/davecgh/go-spew/spew/common.go
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013 Dave Collins <dave@davec.name>
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
diff --git a/vendor/github.com/davecgh/go-spew/spew/config.go b/vendor/github.com/davecgh/go-spew/spew/config.go
index 5552827238..2e3d22f312 100644
--- a/vendor/github.com/davecgh/go-spew/spew/config.go
+++ b/vendor/github.com/davecgh/go-spew/spew/config.go
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013 Dave Collins <dave@davec.name>
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -67,6 +67,15 @@ type ConfigState struct {
 	// Google App Engine or with the "safe" build tag specified.
 	DisablePointerMethods bool
 
+	// DisablePointerAddresses specifies whether to disable the printing of
+	// pointer addresses. This is useful when diffing data structures in tests.
+	DisablePointerAddresses bool
+
+	// DisableCapacities specifies whether to disable the printing of capacities
+	// for arrays, slices, maps and channels. This is useful when diffing
+	// data structures in tests.
+	DisableCapacities bool
+
 	// ContinueOnMethod specifies whether or not recursion should continue once
 	// a custom error or Stringer interface is invoked.  The default, false,
 	// means it will print the results of invoking the custom error or Stringer
diff --git a/vendor/github.com/davecgh/go-spew/spew/doc.go b/vendor/github.com/davecgh/go-spew/spew/doc.go
index 5be0c40609..aacaac6f1e 100644
--- a/vendor/github.com/davecgh/go-spew/spew/doc.go
+++ b/vendor/github.com/davecgh/go-spew/spew/doc.go
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013 Dave Collins <dave@davec.name>
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -91,6 +91,15 @@ The following configuration options are available:
 		which only accept pointer receivers from non-pointer variables.
 		Pointer method invocation is enabled by default.
 
+	* DisablePointerAddresses
+		DisablePointerAddresses specifies whether to disable the printing of
+		pointer addresses. This is useful when diffing data structures in tests.
+
+	* DisableCapacities
+		DisableCapacities specifies whether to disable the printing of
+		capacities for arrays, slices, maps and channels. This is useful when
+		diffing data structures in tests.
+
 	* ContinueOnMethod
 		Enables recursion into types after invoking error and Stringer interface
 		methods. Recursion after method invocation is disabled by default.
diff --git a/vendor/github.com/davecgh/go-spew/spew/dump.go b/vendor/github.com/davecgh/go-spew/spew/dump.go
index a0ff95e27e..df1d582a72 100644
--- a/vendor/github.com/davecgh/go-spew/spew/dump.go
+++ b/vendor/github.com/davecgh/go-spew/spew/dump.go
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013 Dave Collins <dave@davec.name>
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -129,7 +129,7 @@ func (d *dumpState) dumpPtr(v reflect.Value) {
 	d.w.Write(closeParenBytes)
 
 	// Display pointer information.
-	if len(pointerChain) > 0 {
+	if !d.cs.DisablePointerAddresses && len(pointerChain) > 0 {
 		d.w.Write(openParenBytes)
 		for i, addr := range pointerChain {
 			if i > 0 {
@@ -282,13 +282,13 @@ func (d *dumpState) dump(v reflect.Value) {
 	case reflect.Map, reflect.String:
 		valueLen = v.Len()
 	}
-	if valueLen != 0 || valueCap != 0 {
+	if valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 {
 		d.w.Write(openParenBytes)
 		if valueLen != 0 {
 			d.w.Write(lenEqualsBytes)
 			printInt(d.w, int64(valueLen), 10)
 		}
-		if valueCap != 0 {
+		if !d.cs.DisableCapacities && valueCap != 0 {
 			if valueLen != 0 {
 				d.w.Write(spaceBytes)
 			}
diff --git a/vendor/github.com/davecgh/go-spew/spew/format.go b/vendor/github.com/davecgh/go-spew/spew/format.go
index ecf3b80e24..c49875bacb 100644
--- a/vendor/github.com/davecgh/go-spew/spew/format.go
+++ b/vendor/github.com/davecgh/go-spew/spew/format.go
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013 Dave Collins <dave@davec.name>
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
diff --git a/vendor/github.com/davecgh/go-spew/spew/spew.go b/vendor/github.com/davecgh/go-spew/spew/spew.go
index d8233f542e..32c0e33882 100644
--- a/vendor/github.com/davecgh/go-spew/spew/spew.go
+++ b/vendor/github.com/davecgh/go-spew/spew/spew.go
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013 Dave Collins <dave@davec.name>
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
diff --git a/vendor/github.com/stretchr/testify/README.md b/vendor/github.com/stretchr/testify/README.md
new file mode 100644
index 0000000000..e57b1811f0
--- /dev/null
+++ b/vendor/github.com/stretchr/testify/README.md
@@ -0,0 +1,332 @@
+Testify - Thou Shalt Write Tests
+================================
+
+[![Build Status](https://travis-ci.org/stretchr/testify.svg)](https://travis-ci.org/stretchr/testify) [![Go Report Card](https://goreportcard.com/badge/github.com/stretchr/testify)](https://goreportcard.com/report/github.com/stretchr/testify) [![GoDoc](https://godoc.org/github.com/stretchr/testify?status.svg)](https://godoc.org/github.com/stretchr/testify)
+
+Go code (golang) set of packages that provide many tools for testifying that your code will behave as you intend.
+
+Features include:
+
+  * [Easy assertions](#assert-package)
+  * [Mocking](#mock-package)
+  * [HTTP response trapping](#http-package)
+  * [Testing suite interfaces and functions](#suite-package)
+
+Get started:
+
+  * Install testify with [one line of code](#installation), or [update it with another](#staying-up-to-date)
+  * For an introduction to writing test code in Go, see http://golang.org/doc/code.html#Testing
+  * Check out the API Documentation http://godoc.org/github.com/stretchr/testify
+  * To make your testing life easier, check out our other project, [gorc](http://github.com/stretchr/gorc)
+  * A little about [Test-Driven Development (TDD)](http://en.wikipedia.org/wiki/Test-driven_development)
+
+
+
+[`assert`](http://godoc.org/github.com/stretchr/testify/assert "API documentation") package
+-------------------------------------------------------------------------------------------
+
+The `assert` package provides some helpful methods that allow you to write better test code in Go.
+
+  * Prints friendly, easy to read failure descriptions
+  * Allows for very readable code
+  * Optionally annotate each assertion with a message
+
+See it in action:
+
+```go
+package yours
+
+import (
+  "testing"
+  "github.com/stretchr/testify/assert"
+)
+
+func TestSomething(t *testing.T) {
+
+  // assert equality
+  assert.Equal(t, 123, 123, "they should be equal")
+
+  // assert inequality
+  assert.NotEqual(t, 123, 456, "they should not be equal")
+
+  // assert for nil (good for errors)
+  assert.Nil(t, object)
+
+  // assert for not nil (good when you expect something)
+  if assert.NotNil(t, object) {
+
+    // now we know that object isn't nil, we are safe to make
+    // further assertions without causing any errors
+    assert.Equal(t, "Something", object.Value)
+
+  }
+
+}
+```
+
+  * Every assert func takes the `testing.T` object as the first argument.  This is how it writes the errors out through the normal `go test` capabilities.
+  * Every assert func returns a bool indicating whether the assertion was successful or not, this is useful for if you want to go on making further assertions under certain conditions.
+
+if you assert many times, use the below:
+
+```go
+package yours
+
+import (
+  "testing"
+  "github.com/stretchr/testify/assert"
+)
+
+func TestSomething(t *testing.T) {
+  assert := assert.New(t)
+
+  // assert equality
+  assert.Equal(123, 123, "they should be equal")
+
+  // assert inequality
+  assert.NotEqual(123, 456, "they should not be equal")
+
+  // assert for nil (good for errors)
+  assert.Nil(object)
+
+  // assert for not nil (good when you expect something)
+  if assert.NotNil(object) {
+
+    // now we know that object isn't nil, we are safe to make
+    // further assertions without causing any errors
+    assert.Equal("Something", object.Value)
+  }
+}
+```
+
+[`require`](http://godoc.org/github.com/stretchr/testify/require "API documentation") package
+---------------------------------------------------------------------------------------------
+
+The `require` package provides same global functions as the `assert` package, but instead of returning a boolean result they terminate current test.
+
+See [t.FailNow](http://golang.org/pkg/testing/#T.FailNow) for details.
+
+
+[`http`](http://godoc.org/github.com/stretchr/testify/http "API documentation") package
+---------------------------------------------------------------------------------------
+
+The `http` package contains test objects useful for testing code that relies on the `net/http` package.  Check out the [(deprecated) API documentation for the `http` package](http://godoc.org/github.com/stretchr/testify/http).
+
+We recommend you use [httptest](http://golang.org/pkg/net/http/httptest) instead.
+
+[`mock`](http://godoc.org/github.com/stretchr/testify/mock "API documentation") package
+----------------------------------------------------------------------------------------
+
+The `mock` package provides a mechanism for easily writing mock objects that can be used in place of real objects when writing test code.
+
+An example test function that tests a piece of code that relies on an external object `testObj`, can setup expectations (testify) and assert that they indeed happened:
+
+```go
+package yours
+
+import (
+  "testing"
+  "github.com/stretchr/testify/mock"
+)
+
+/*
+  Test objects
+*/
+
+// MyMockedObject is a mocked object that implements an interface
+// that describes an object that the code I am testing relies on.
+type MyMockedObject struct{
+  mock.Mock
+}
+
+// DoSomething is a method on MyMockedObject that implements some interface
+// and just records the activity, and returns what the Mock object tells it to.
+//
+// In the real object, this method would do something useful, but since this
+// is a mocked object - we're just going to stub it out.
+//
+// NOTE: This method is not being tested here, code that uses this object is.
+func (m *MyMockedObject) DoSomething(number int) (bool, error) {
+
+  args := m.Called(number)
+  return args.Bool(0), args.Error(1)
+
+}
+
+/*
+  Actual test functions
+*/
+
+// TestSomething is an example of how to use our test object to
+// make assertions about some target code we are testing.
+func TestSomething(t *testing.T) {
+
+  // create an instance of our test object
+  testObj := new(MyMockedObject)
+
+  // setup expectations
+  testObj.On("DoSomething", 123).Return(true, nil)
+
+  // call the code we are testing
+  targetFuncThatDoesSomethingWithObj(testObj)
+
+  // assert that the expectations were met
+  testObj.AssertExpectations(t)
+
+}
+```
+
+For more information on how to write mock code, check out the [API documentation for the `mock` package](http://godoc.org/github.com/stretchr/testify/mock).
+
+You can use the [mockery tool](http://github.com/vektra/mockery) to autogenerate the mock code against an interface as well, making using mocks much quicker.
+
+[`suite`](http://godoc.org/github.com/stretchr/testify/suite "API documentation") package
+-----------------------------------------------------------------------------------------
+
+The `suite` package provides functionality that you might be used to from more common object oriented languages.  With it, you can build a testing suite as a struct, build setup/teardown methods and testing methods on your struct, and run them with 'go test' as per normal.
+
+An example suite is shown below:
+
+```go
+// Basic imports
+import (
+    "testing"
+    "github.com/stretchr/testify/assert"
+    "github.com/stretchr/testify/suite"
+)
+
+// Define the suite, and absorb the built-in basic suite
+// functionality from testify - including a T() method which
+// returns the current testing context
+type ExampleTestSuite struct {
+    suite.Suite
+    VariableThatShouldStartAtFive int
+}
+
+// Make sure that VariableThatShouldStartAtFive is set to five
+// before each test
+func (suite *ExampleTestSuite) SetupTest() {
+    suite.VariableThatShouldStartAtFive = 5
+}
+
+// All methods that begin with "Test" are run as tests within a
+// suite.
+func (suite *ExampleTestSuite) TestExample() {
+    assert.Equal(suite.T(), 5, suite.VariableThatShouldStartAtFive)
+}
+
+// In order for 'go test' to run this suite, we need to create
+// a normal test function and pass our suite to suite.Run
+func TestExampleTestSuite(t *testing.T) {
+    suite.Run(t, new(ExampleTestSuite))
+}
+```
+
+For a more complete example, using all of the functionality provided by the suite package, look at our [example testing suite](https://github.com/stretchr/testify/blob/master/suite/suite_test.go)
+
+For more information on writing suites, check out the [API documentation for the `suite` package](http://godoc.org/github.com/stretchr/testify/suite).
+
+`Suite` object has assertion methods:
+
+```go
+// Basic imports
+import (
+    "testing"
+    "github.com/stretchr/testify/suite"
+)
+
+// Define the suite, and absorb the built-in basic suite
+// functionality from testify - including assertion methods.
+type ExampleTestSuite struct {
+    suite.Suite
+    VariableThatShouldStartAtFive int
+}
+
+// Make sure that VariableThatShouldStartAtFive is set to five
+// before each test
+func (suite *ExampleTestSuite) SetupTest() {
+    suite.VariableThatShouldStartAtFive = 5
+}
+
+// All methods that begin with "Test" are run as tests within a
+// suite.
+func (suite *ExampleTestSuite) TestExample() {
+    suite.Equal(suite.VariableThatShouldStartAtFive, 5)
+}
+
+// In order for 'go test' to run this suite, we need to create
+// a normal test function and pass our suite to suite.Run
+func TestExampleTestSuite(t *testing.T) {
+    suite.Run(t, new(ExampleTestSuite))
+}
+```
+
+------
+
+Installation
+============
+
+To install Testify, use `go get`:
+
+    * Latest version: go get github.com/stretchr/testify
+    * Specific version: go get gopkg.in/stretchr/testify.v1
+
+This will then make the following packages available to you:
+
+    github.com/stretchr/testify/assert
+    github.com/stretchr/testify/mock
+    github.com/stretchr/testify/http
+
+Import the `testify/assert` package into your code using this template:
+
+```go
+package yours
+
+import (
+  "testing"
+  "github.com/stretchr/testify/assert"
+)
+
+func TestSomething(t *testing.T) {
+
+  assert.True(t, true, "True is true!")
+
+}
+```
+
+------
+
+Staying up to date
+==================
+
+To update Testify to the latest version, use `go get -u github.com/stretchr/testify`.
+
+------
+
+Version History
+===============
+
+   * 1.0 - New package versioning strategy adopted.
+
+------
+
+Contributing
+============
+
+Please feel free to submit issues, fork the repository and send pull requests!
+
+When submitting an issue, we ask that you please include a complete test function that demonstrates the issue.  Extra credit for those using Testify to write the test code that demonstrates it.
+
+------
+
+Licence
+=======
+Copyright (c) 2012 - 2013 Mat Ryer and Tyler Bunnell
+
+Please consider promoting this project if you find it useful.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/github.com/stretchr/testify/assert/assertion_forward.go b/vendor/github.com/stretchr/testify/assert/assertion_forward.go
index e6a796046c..aa4311ff84 100644
--- a/vendor/github.com/stretchr/testify/assert/assertion_forward.go
+++ b/vendor/github.com/stretchr/testify/assert/assertion_forward.go
@@ -1,386 +1,351 @@
 /*
 * CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
 * THIS FILE MUST NOT BE EDITED BY HAND
-*/
+ */
 
 package assert
 
 import (
-
 	http "net/http"
 	url "net/url"
 	time "time"
 )
 
-
 // Condition uses a Comparison to assert a complex condition.
 func (a *Assertions) Condition(comp Comparison, msgAndArgs ...interface{}) bool {
 	return Condition(a.t, comp, msgAndArgs...)
 }
 
-
 // Contains asserts that the specified string, list(array, slice...) or map contains the
 // specified substring or element.
-// 
+//
 //    a.Contains("Hello World", "World", "But 'Hello World' does contain 'World'")
 //    a.Contains(["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'")
 //    a.Contains({"Hello": "World"}, "Hello", "But {'Hello': 'World'} does contain 'Hello'")
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool {
 	return Contains(a.t, s, contains, msgAndArgs...)
 }
 
-
 // Empty asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
 // a slice or a channel with len == 0.
-// 
+//
 //  a.Empty(obj)
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool {
 	return Empty(a.t, object, msgAndArgs...)
 }
 
-
 // Equal asserts that two objects are equal.
-// 
+//
 //    a.Equal(123, 123, "123 and 123 should be equal")
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
 func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
 	return Equal(a.t, expected, actual, msgAndArgs...)
 }
 
-
 // EqualError asserts that a function returned an error (i.e. not `nil`)
 // and that it is equal to the provided error.
-// 
+//
 //   actualObj, err := SomeFunction()
-//   if assert.Error(t, err, "An error was expected") {
-// 	   assert.Equal(t, err, expectedError)
-//   }
-// 
+//   a.EqualError(err,  expectedErrorString, "An error was expected")
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) bool {
 	return EqualError(a.t, theError, errString, msgAndArgs...)
 }
 
-
 // EqualValues asserts that two objects are equal or convertable to the same types
 // and equal.
-// 
+//
 //    a.EqualValues(uint32(123), int32(123), "123 and 123 should be equal")
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
 	return EqualValues(a.t, expected, actual, msgAndArgs...)
 }
 
-
 // Error asserts that a function returned an error (i.e. not `nil`).
-// 
+//
 //   actualObj, err := SomeFunction()
 //   if a.Error(err, "An error was expected") {
 // 	   assert.Equal(t, err, expectedError)
 //   }
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) Error(err error, msgAndArgs ...interface{}) bool {
 	return Error(a.t, err, msgAndArgs...)
 }
 
-
 // Exactly asserts that two objects are equal is value and type.
-// 
+//
 //    a.Exactly(int32(123), int64(123), "123 and 123 should NOT be equal")
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
 	return Exactly(a.t, expected, actual, msgAndArgs...)
 }
 
-
 // Fail reports a failure through
 func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) bool {
 	return Fail(a.t, failureMessage, msgAndArgs...)
 }
 
-
 // FailNow fails test
 func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) bool {
 	return FailNow(a.t, failureMessage, msgAndArgs...)
 }
 
-
 // False asserts that the specified value is false.
-// 
+//
 //    a.False(myBool, "myBool should be false")
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool {
 	return False(a.t, value, msgAndArgs...)
 }
 
-
 // HTTPBodyContains asserts that a specified handler returns a
 // body that contains a string.
-// 
+//
 //  a.HTTPBodyContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky")
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool {
 	return HTTPBodyContains(a.t, handler, method, url, values, str)
 }
 
-
 // HTTPBodyNotContains asserts that a specified handler returns a
 // body that does not contain a string.
-// 
+//
 //  a.HTTPBodyNotContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky")
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool {
 	return HTTPBodyNotContains(a.t, handler, method, url, values, str)
 }
 
-
 // HTTPError asserts that a specified handler returns an error status code.
-// 
+//
 //  a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values) bool {
 	return HTTPError(a.t, handler, method, url, values)
 }
 
-
 // HTTPRedirect asserts that a specified handler returns a redirect status code.
-// 
+//
 //  a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values) bool {
 	return HTTPRedirect(a.t, handler, method, url, values)
 }
 
-
 // HTTPSuccess asserts that a specified handler returns a success status code.
-// 
+//
 //  a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values) bool {
 	return HTTPSuccess(a.t, handler, method, url, values)
 }
 
-
 // Implements asserts that an object is implemented by the specified interface.
-// 
+//
 //    a.Implements((*MyInterface)(nil), new(MyObject), "MyObject")
 func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
 	return Implements(a.t, interfaceObject, object, msgAndArgs...)
 }
 
-
 // InDelta asserts that the two numerals are within delta of each other.
-// 
+//
 // 	 a.InDelta(math.Pi, (22 / 7.0), 0.01)
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
 	return InDelta(a.t, expected, actual, delta, msgAndArgs...)
 }
 
-
 // InDeltaSlice is the same as InDelta, except it compares two slices.
 func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
 	return InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...)
 }
 
-
 // InEpsilon asserts that expected and actual have a relative error less than epsilon
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
 	return InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...)
 }
 
-
-// InEpsilonSlice is the same as InEpsilon, except it compares two slices.
-func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
-	return InEpsilonSlice(a.t, expected, actual, delta, msgAndArgs...)
+// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.
+func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
+	return InEpsilonSlice(a.t, expected, actual, epsilon, msgAndArgs...)
 }
 
-
 // IsType asserts that the specified objects are of the same type.
 func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {
 	return IsType(a.t, expectedType, object, msgAndArgs...)
 }
 
-
 // JSONEq asserts that two JSON strings are equivalent.
-// 
+//
 //  a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) bool {
 	return JSONEq(a.t, expected, actual, msgAndArgs...)
 }
 
-
 // Len asserts that the specified object has specific length.
 // Len also fails if the object has a type that len() not accept.
-// 
+//
 //    a.Len(mySlice, 3, "The size of slice is not 3")
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) bool {
 	return Len(a.t, object, length, msgAndArgs...)
 }
 
-
 // Nil asserts that the specified object is nil.
-// 
+//
 //    a.Nil(err, "err should be nothing")
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool {
 	return Nil(a.t, object, msgAndArgs...)
 }
 
-
 // NoError asserts that a function returned no error (i.e. `nil`).
-// 
+//
 //   actualObj, err := SomeFunction()
 //   if a.NoError(err) {
 // 	   assert.Equal(t, actualObj, expectedObj)
 //   }
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) bool {
 	return NoError(a.t, err, msgAndArgs...)
 }
 
-
 // NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
 // specified substring or element.
-// 
+//
 //    a.NotContains("Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")
 //    a.NotContains(["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'")
 //    a.NotContains({"Hello": "World"}, "Earth", "But {'Hello': 'World'} does NOT contain 'Earth'")
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool {
 	return NotContains(a.t, s, contains, msgAndArgs...)
 }
 
-
 // NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
 // a slice or a channel with len == 0.
-// 
+//
 //  if a.NotEmpty(obj) {
 //    assert.Equal(t, "two", obj[1])
 //  }
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) bool {
 	return NotEmpty(a.t, object, msgAndArgs...)
 }
 
-
 // NotEqual asserts that the specified values are NOT equal.
-// 
+//
 //    a.NotEqual(obj1, obj2, "two objects shouldn't be equal")
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
 func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
 	return NotEqual(a.t, expected, actual, msgAndArgs...)
 }
 
-
 // NotNil asserts that the specified object is not nil.
-// 
+//
 //    a.NotNil(err, "err should be something")
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool {
 	return NotNil(a.t, object, msgAndArgs...)
 }
 
-
 // NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
-// 
+//
 //   a.NotPanics(func(){
 //     RemainCalm()
 //   }, "Calling RemainCalm() should NOT panic")
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
 	return NotPanics(a.t, f, msgAndArgs...)
 }
 
-
 // NotRegexp asserts that a specified regexp does not match a string.
-// 
+//
 //  a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
 //  a.NotRegexp("^start", "it's not starting")
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
 	return NotRegexp(a.t, rx, str, msgAndArgs...)
 }
 
-
 // NotZero asserts that i is not the zero value for its type and returns the truth.
 func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) bool {
 	return NotZero(a.t, i, msgAndArgs...)
 }
 
-
 // Panics asserts that the code inside the specified PanicTestFunc panics.
-// 
+//
 //   a.Panics(func(){
 //     GoCrazy()
 //   }, "Calling GoCrazy() should panic")
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
 	return Panics(a.t, f, msgAndArgs...)
 }
 
-
 // Regexp asserts that a specified regexp matches a string.
-// 
+//
 //  a.Regexp(regexp.MustCompile("start"), "it's starting")
 //  a.Regexp("start...$", "it's not starting")
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
 	return Regexp(a.t, rx, str, msgAndArgs...)
 }
 
-
 // True asserts that the specified value is true.
-// 
+//
 //    a.True(myBool, "myBool should be true")
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool {
 	return True(a.t, value, msgAndArgs...)
 }
 
-
 // WithinDuration asserts that the two times are within duration delta of each other.
-// 
+//
 //   a.WithinDuration(time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s")
-// 
+//
 // Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
 	return WithinDuration(a.t, expected, actual, delta, msgAndArgs...)
 }
 
-
 // Zero asserts that i is the zero value for its type and returns the truth.
 func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) bool {
 	return Zero(a.t, i, msgAndArgs...)
diff --git a/vendor/github.com/stretchr/testify/assert/assertions.go b/vendor/github.com/stretchr/testify/assert/assertions.go
index d7c16c5903..d1552e5e3f 100644
--- a/vendor/github.com/stretchr/testify/assert/assertions.go
+++ b/vendor/github.com/stretchr/testify/assert/assertions.go
@@ -65,7 +65,7 @@ func ObjectsAreEqualValues(expected, actual interface{}) bool {
 
 /* CallerInfo is necessary because the assert functions use the testing object
 internally, causing it to print the file:line of the assert method, rather than where
-the problem actually occured in calling code.*/
+the problem actually occurred in calling code.*/
 
 // CallerInfo returns an array of strings containing the file and line number
 // of each stack frame leading from the current test to the assert call that
@@ -82,7 +82,9 @@ func CallerInfo() []string {
 	for i := 0; ; i++ {
 		pc, file, line, ok = runtime.Caller(i)
 		if !ok {
-			return nil
+			// The breaks below failed to terminate the loop, and we ran off the
+			// end of the call stack.
+			break
 		}
 
 		// This is a huge edge case, but it will panic if this is the case, see #180
@@ -90,6 +92,21 @@ func CallerInfo() []string {
 			break
 		}
 
+		f := runtime.FuncForPC(pc)
+		if f == nil {
+			break
+		}
+		name = f.Name()
+
+		// testing.tRunner is the standard library function that calls
+		// tests. Subtests are called directly by tRunner, without going through
+		// the Test/Benchmark/Example function that contains the t.Run calls, so
+		// with subtests we should break when we hit tRunner, without adding it
+		// to the list of callers.
+		if name == "testing.tRunner" {
+			break
+		}
+
 		parts := strings.Split(file, "/")
 		dir := parts[len(parts)-2]
 		file = parts[len(parts)-1]
@@ -97,11 +114,6 @@ func CallerInfo() []string {
 			callers = append(callers, fmt.Sprintf("%s:%d", file, line))
 		}
 
-		f := runtime.FuncForPC(pc)
-		if f == nil {
-			break
-		}
-		name = f.Name()
 		// Drop the package
 		segments := strings.Split(name, ".")
 		name = segments[len(segments)-1]
@@ -141,7 +153,7 @@ func getWhitespaceString() string {
 	parts := strings.Split(file, "/")
 	file = parts[len(parts)-1]
 
-	return strings.Repeat(" ", len(fmt.Sprintf("%s:%d:      ", file, line)))
+	return strings.Repeat(" ", len(fmt.Sprintf("%s:%d:        ", file, line)))
 
 }
 
@@ -158,22 +170,18 @@ func messageFromMsgAndArgs(msgAndArgs ...interface{}) string {
 	return ""
 }
 
-// Indents all lines of the message by appending a number of tabs to each line, in an output format compatible with Go's
-// test printing (see inner comment for specifics)
-func indentMessageLines(message string, tabs int) string {
+// Aligns the provided message so that all lines after the first line start at the same location as the first line.
+// Assumes that the first line starts at the correct location (after carriage return, tab, label, spacer and tab).
+// The longestLabelLen parameter specifies the length of the longest label in the output (required becaues this is the
+// basis on which the alignment occurs).
+func indentMessageLines(message string, longestLabelLen int) string {
 	outBuf := new(bytes.Buffer)
 
 	for i, scanner := 0, bufio.NewScanner(strings.NewReader(message)); scanner.Scan(); i++ {
+		// no need to align first line because it starts at the correct location (after the label)
 		if i != 0 {
-			outBuf.WriteRune('\n')
-		}
-		for ii := 0; ii < tabs; ii++ {
-			outBuf.WriteRune('\t')
-			// Bizarrely, all lines except the first need one fewer tabs prepended, so deliberately advance the counter
-			// by 1 prematurely.
-			if ii == 0 && i > 0 {
-				ii++
-			}
+			// append alignLen+1 spaces to align with "{{longestLabel}}:" before adding tab
+			outBuf.WriteString("\n\r\t" + strings.Repeat(" ", longestLabelLen +1) + "\t")
 		}
 		outBuf.WriteString(scanner.Text())
 	}
@@ -205,29 +213,49 @@ func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool
 
 // Fail reports a failure through
 func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool {
-
-	message := messageFromMsgAndArgs(msgAndArgs...)
-
-	errorTrace := strings.Join(CallerInfo(), "\n\r\t\t\t")
-	if len(message) > 0 {
-		t.Errorf("\r%s\r\tError Trace:\t%s\n"+
-			"\r\tError:%s\n"+
-			"\r\tMessages:\t%s\n\r",
-			getWhitespaceString(),
-			errorTrace,
-			indentMessageLines(failureMessage, 2),
-			message)
-	} else {
-		t.Errorf("\r%s\r\tError Trace:\t%s\n"+
-			"\r\tError:%s\n\r",
-			getWhitespaceString(),
-			errorTrace,
-			indentMessageLines(failureMessage, 2))
+	content := []labeledContent{
+		{"Error Trace", strings.Join(CallerInfo(), "\n\r\t\t\t")},
+		{"Error", failureMessage},
 	}
 
+	message := messageFromMsgAndArgs(msgAndArgs...)
+	if len(message) > 0 {
+		content = append(content, labeledContent{"Messages", message})
+	}
+
+	t.Errorf("\r" + getWhitespaceString() + labeledOutput(content...))
+
 	return false
 }
 
+type labeledContent struct {
+	label string
+	content string
+}
+
+// labeledOutput returns a string consisting of the provided labeledContent. Each labeled output is appended in the following manner:
+//
+//   \r\t{{label}}:{{align_spaces}}\t{{content}}\n
+//
+// The initial carriage return is required to undo/erase any padding added by testing.T.Errorf. The "\t{{label}}:" is for the label.
+// If a label is shorter than the longest label provided, padding spaces are added to make all the labels match in length. Once this
+// alignment is achieved, "\t{{content}}\n" is added for the output.
+//
+// If the content of the labeledOutput contains line breaks, the subsequent lines are aligned so that they start at the same location as the first line.
+func labeledOutput(content ...labeledContent) string {
+	longestLabel := 0
+	for _, v := range content {
+		if len(v.label) > longestLabel {
+			longestLabel = len(v.label)
+		}
+	}
+	var output string
+	for _, v := range content {
+		output += "\r\t" + v.label + ":" + strings.Repeat(" ", longestLabel-len(v.label)) + "\t" + indentMessageLines(v.content, longestLabel) + "\n"
+	}
+	return output
+}
+
 // Implements asserts that an object is implemented by the specified interface.
 //
 //    assert.Implements(t, (*MyInterface)(nil), new(MyObject), "MyObject")
@@ -258,18 +286,39 @@ func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs
 //    assert.Equal(t, 123, 123, "123 and 123 should be equal")
 //
 // Returns whether the assertion was successful (true) or not (false).
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
 func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
 
 	if !ObjectsAreEqual(expected, actual) {
 		diff := diff(expected, actual)
-		return Fail(t, fmt.Sprintf("Not equal: %#v (expected)\n"+
-			"        != %#v (actual)%s", expected, actual, diff), msgAndArgs...)
+		expected, actual = formatUnequalValues(expected, actual)
+		return Fail(t, fmt.Sprintf("Not equal: \n"+
+			"expected: %s\n"+
+			"received: %s%s", expected, actual, diff), msgAndArgs...)
 	}
 
 	return true
 
 }
 
+// formatUnequalValues takes two values of arbitrary types and returns string
+// representations appropriate to be presented to the user.
+//
+// If the values are not of like type, the returned strings will be prefixed
+// with the type name, and the value will be enclosed in parenthesis similar
+// to a type conversion in the Go grammar.
+func formatUnequalValues(expected, actual interface{}) (e string, a string) {
+	if reflect.TypeOf(expected) != reflect.TypeOf(actual) {
+		return fmt.Sprintf("%T(%#v)", expected, expected),
+			fmt.Sprintf("%T(%#v)", actual, actual)
+	}
+
+	return fmt.Sprintf("%#v", expected),
+		fmt.Sprintf("%#v", actual)
+}
+
 // EqualValues asserts that two objects are equal or convertable to the same types
 // and equal.
 //
@@ -279,8 +328,11 @@ func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{})
 func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
 
 	if !ObjectsAreEqualValues(expected, actual) {
-		return Fail(t, fmt.Sprintf("Not equal: %#v (expected)\n"+
-			"        != %#v (actual)", expected, actual), msgAndArgs...)
+		diff := diff(expected, actual)
+		expected, actual = formatUnequalValues(expected, actual)
+		return Fail(t, fmt.Sprintf("Not equal: \n"+
+			"expected: %s\n"+
+			"received: %s%s", expected, actual, diff), msgAndArgs...)
 	}
 
 	return true
@@ -507,6 +559,9 @@ func False(t TestingT, value bool, msgAndArgs ...interface{}) bool {
 //    assert.NotEqual(t, obj1, obj2, "two objects shouldn't be equal")
 //
 // Returns whether the assertion was successful (true) or not (false).
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
 func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
 
 	if ObjectsAreEqual(expected, actual) {
@@ -832,11 +887,11 @@ func InEpsilonSlice(t TestingT, expected, actual interface{}, epsilon float64, m
 //
 // Returns whether the assertion was successful (true) or not (false).
 func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool {
-	if isNil(err) {
-		return true
+	if err != nil {
+		return Fail(t, fmt.Sprintf("Received unexpected error:\n%+v", err), msgAndArgs...)
 	}
 
-	return Fail(t, fmt.Sprintf("Received unexpected error %q", err), msgAndArgs...)
+	return true
 }
 
 // Error asserts that a function returned an error (i.e. not `nil`).
@@ -849,29 +904,33 @@ func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool {
 // Returns whether the assertion was successful (true) or not (false).
 func Error(t TestingT, err error, msgAndArgs ...interface{}) bool {
 
-	message := messageFromMsgAndArgs(msgAndArgs...)
-	return NotNil(t, err, "An error is expected but got nil. %s", message)
+	if err == nil {
+		return Fail(t, "An error is expected but got nil.", msgAndArgs...)
+	}
 
+	return true
 }
 
 // EqualError asserts that a function returned an error (i.e. not `nil`)
 // and that it is equal to the provided error.
 //
 //   actualObj, err := SomeFunction()
-//   if assert.Error(t, err, "An error was expected") {
-//	   assert.Equal(t, err, expectedError)
-//   }
+//   assert.EqualError(t, err,  expectedErrorString, "An error was expected")
 //
 // Returns whether the assertion was successful (true) or not (false).
 func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) bool {
-
-	message := messageFromMsgAndArgs(msgAndArgs...)
-	if !NotNil(t, theError, "An error is expected but got nil. %s", message) {
+	if !Error(t, theError, msgAndArgs...) {
 		return false
 	}
-	s := "An error with value \"%s\" is expected but got \"%s\". %s"
-	return Equal(t, errString, theError.Error(),
-		s, errString, theError.Error(), message)
+	expected := errString
+	actual := theError.Error()
+	// don't need to use deep equals here, we know they are both strings
+	if expected != actual {
+		return Fail(t, fmt.Sprintf("Error message not equal:\n"+
+			"expected: %q\n"+
+			"received: %q", expected, actual), msgAndArgs...)
+	}
+	return true
 }
 
 // matchRegexp return true if a specified regexp matches a string.
@@ -986,9 +1045,8 @@ func diff(expected interface{}, actual interface{}) string {
 		return ""
 	}
 
-	spew.Config.SortKeys = true
-	e := spew.Sdump(expected)
-	a := spew.Sdump(actual)
+	e := spewConfig.Sdump(expected)
+	a := spewConfig.Sdump(actual)
 
 	diff, _ := difflib.GetUnifiedDiffString(difflib.UnifiedDiff{
 		A:        difflib.SplitLines(e),
@@ -1002,3 +1060,10 @@ func diff(expected interface{}, actual interface{}) string {
 
 	return "\n\nDiff:\n" + diff
 }
+
+var spewConfig = spew.ConfigState{
+	Indent:                  " ",
+	DisablePointerAddresses: true,
+	DisableCapacities:       true,
+	SortKeys:                true,
+}
diff --git a/vendor/github.com/stretchr/testify/assert/http_assertions.go b/vendor/github.com/stretchr/testify/assert/http_assertions.go
index e1b9442b5a..fa7ab89b18 100644
--- a/vendor/github.com/stretchr/testify/assert/http_assertions.go
+++ b/vendor/github.com/stretchr/testify/assert/http_assertions.go
@@ -99,7 +99,7 @@ func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method, url strin
 
 	contains := strings.Contains(body, fmt.Sprint(str))
 	if contains {
-		Fail(t, "Expected response body for %s to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body)
+		Fail(t, fmt.Sprintf("Expected response body for \"%s\" to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body))
 	}
 
 	return !contains
diff --git a/vendor/github.com/stretchr/testify/require/doc.go b/vendor/github.com/stretchr/testify/require/doc.go
new file mode 100644
index 0000000000..169de39221
--- /dev/null
+++ b/vendor/github.com/stretchr/testify/require/doc.go
@@ -0,0 +1,28 @@
+// Package require implements the same assertions as the `assert` package but
+// stops test execution when a test fails.
+//
+// Example Usage
+//
+// The following is a complete example using require in a standard test function:
+//    import (
+//      "testing"
+//      "github.com/stretchr/testify/require"
+//    )
+//
+//    func TestSomething(t *testing.T) {
+//
+//      var a string = "Hello"
+//      var b string = "Hello"
+//
+//      require.Equal(t, a, b, "The two words should be the same.")
+//
+//    }
+//
+// Assertions
+//
+// The `require` package have same global functions as in the `assert` package,
+// but instead of returning a boolean result they call `t.FailNow()`.
+//
+// Every assertion function also takes an optional string message as the final argument,
+// allowing custom error messages to be appended to the message the assertion method outputs.
+package require
diff --git a/vendor/github.com/stretchr/testify/require/forward_requirements.go b/vendor/github.com/stretchr/testify/require/forward_requirements.go
new file mode 100644
index 0000000000..d3c2ab9bc7
--- /dev/null
+++ b/vendor/github.com/stretchr/testify/require/forward_requirements.go
@@ -0,0 +1,16 @@
+package require
+
+// Assertions provides assertion methods around the
+// TestingT interface.
+type Assertions struct {
+	t TestingT
+}
+
+// New makes a new Assertions object for the specified TestingT.
+func New(t TestingT) *Assertions {
+	return &Assertions{
+		t: t,
+	}
+}
+
+//go:generate go run ../_codegen/main.go -output-package=require -template=require_forward.go.tmpl
diff --git a/vendor/github.com/stretchr/testify/require/require.go b/vendor/github.com/stretchr/testify/require/require.go
new file mode 100644
index 0000000000..fc567f140a
--- /dev/null
+++ b/vendor/github.com/stretchr/testify/require/require.go
@@ -0,0 +1,429 @@
+/*
+* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
+* THIS FILE MUST NOT BE EDITED BY HAND
+ */
+
+package require
+
+import (
+	assert "github.com/stretchr/testify/assert"
+	http "net/http"
+	url "net/url"
+	time "time"
+)
+
+// Condition uses a Comparison to assert a complex condition.
+func Condition(t TestingT, comp assert.Comparison, msgAndArgs ...interface{}) {
+	if !assert.Condition(t, comp, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// Contains asserts that the specified string, list(array, slice...) or map contains the
+// specified substring or element.
+//
+//    assert.Contains(t, "Hello World", "World", "But 'Hello World' does contain 'World'")
+//    assert.Contains(t, ["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'")
+//    assert.Contains(t, {"Hello": "World"}, "Hello", "But {'Hello': 'World'} does contain 'Hello'")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Contains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) {
+	if !assert.Contains(t, s, contains, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// Empty asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//  assert.Empty(t, obj)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) {
+	if !assert.Empty(t, object, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// Equal asserts that two objects are equal.
+//
+//    assert.Equal(t, 123, 123, "123 and 123 should be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
+func Equal(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if !assert.Equal(t, expected, actual, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// EqualError asserts that a function returned an error (i.e. not `nil`)
+// and that it is equal to the provided error.
+//
+//   actualObj, err := SomeFunction()
+//   assert.EqualError(t, err,  expectedErrorString, "An error was expected")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) {
+	if !assert.EqualError(t, theError, errString, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// EqualValues asserts that two objects are equal or convertable to the same types
+// and equal.
+//
+//    assert.EqualValues(t, uint32(123), int32(123), "123 and 123 should be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func EqualValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if !assert.EqualValues(t, expected, actual, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// Error asserts that a function returned an error (i.e. not `nil`).
+//
+//   actualObj, err := SomeFunction()
+//   if assert.Error(t, err, "An error was expected") {
+// 	   assert.Equal(t, err, expectedError)
+//   }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Error(t TestingT, err error, msgAndArgs ...interface{}) {
+	if !assert.Error(t, err, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// Exactly asserts that two objects are equal is value and type.
+//
+//    assert.Exactly(t, int32(123), int64(123), "123 and 123 should NOT be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Exactly(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if !assert.Exactly(t, expected, actual, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// Fail reports a failure through
+func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) {
+	if !assert.Fail(t, failureMessage, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// FailNow fails test
+func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) {
+	if !assert.FailNow(t, failureMessage, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// False asserts that the specified value is false.
+//
+//    assert.False(t, myBool, "myBool should be false")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func False(t TestingT, value bool, msgAndArgs ...interface{}) {
+	if !assert.False(t, value, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// HTTPBodyContains asserts that a specified handler returns a
+// body that contains a string.
+//
+//  assert.HTTPBodyContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) {
+	if !assert.HTTPBodyContains(t, handler, method, url, values, str) {
+		t.FailNow()
+	}
+}
+
+// HTTPBodyNotContains asserts that a specified handler returns a
+// body that does not contain a string.
+//
+//  assert.HTTPBodyNotContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) {
+	if !assert.HTTPBodyNotContains(t, handler, method, url, values, str) {
+		t.FailNow()
+	}
+}
+
+// HTTPError asserts that a specified handler returns an error status code.
+//
+//  assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPError(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) {
+	if !assert.HTTPError(t, handler, method, url, values) {
+		t.FailNow()
+	}
+}
+
+// HTTPRedirect asserts that a specified handler returns a redirect status code.
+//
+//  assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPRedirect(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) {
+	if !assert.HTTPRedirect(t, handler, method, url, values) {
+		t.FailNow()
+	}
+}
+
+// HTTPSuccess asserts that a specified handler returns a success status code.
+//
+//  assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPSuccess(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) {
+	if !assert.HTTPSuccess(t, handler, method, url, values) {
+		t.FailNow()
+	}
+}
+
+// Implements asserts that an object is implemented by the specified interface.
+//
+//    assert.Implements(t, (*MyInterface)(nil), new(MyObject), "MyObject")
+func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) {
+	if !assert.Implements(t, interfaceObject, object, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// InDelta asserts that the two numerals are within delta of each other.
+//
+// 	 assert.InDelta(t, math.Pi, (22 / 7.0), 0.01)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func InDelta(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
+	if !assert.InDelta(t, expected, actual, delta, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// InDeltaSlice is the same as InDelta, except it compares two slices.
+func InDeltaSlice(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
+	if !assert.InDeltaSlice(t, expected, actual, delta, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// InEpsilon asserts that expected and actual have a relative error less than epsilon
+//
+// Returns whether the assertion was successful (true) or not (false).
+func InEpsilon(t TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
+	if !assert.InEpsilon(t, expected, actual, epsilon, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.
+func InEpsilonSlice(t TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
+	if !assert.InEpsilonSlice(t, expected, actual, epsilon, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// IsType asserts that the specified objects are of the same type.
+func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) {
+	if !assert.IsType(t, expectedType, object, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// JSONEq asserts that two JSON strings are equivalent.
+//
+//  assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) {
+	if !assert.JSONEq(t, expected, actual, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// Len asserts that the specified object has specific length.
+// Len also fails if the object has a type that len() not accept.
+//
+//    assert.Len(t, mySlice, 3, "The size of slice is not 3")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) {
+	if !assert.Len(t, object, length, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// Nil asserts that the specified object is nil.
+//
+//    assert.Nil(t, err, "err should be nothing")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) {
+	if !assert.Nil(t, object, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// NoError asserts that a function returned no error (i.e. `nil`).
+//
+//   actualObj, err := SomeFunction()
+//   if assert.NoError(t, err) {
+// 	   assert.Equal(t, actualObj, expectedObj)
+//   }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NoError(t TestingT, err error, msgAndArgs ...interface{}) {
+	if !assert.NoError(t, err, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
+// specified substring or element.
+//
+//    assert.NotContains(t, "Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")
+//    assert.NotContains(t, ["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'")
+//    assert.NotContains(t, {"Hello": "World"}, "Earth", "But {'Hello': 'World'} does NOT contain 'Earth'")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotContains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) {
+	if !assert.NotContains(t, s, contains, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//  if assert.NotEmpty(t, obj) {
+//    assert.Equal(t, "two", obj[1])
+//  }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) {
+	if !assert.NotEmpty(t, object, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// NotEqual asserts that the specified values are NOT equal.
+//
+//    assert.NotEqual(t, obj1, obj2, "two objects shouldn't be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
+func NotEqual(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	if !assert.NotEqual(t, expected, actual, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// NotNil asserts that the specified object is not nil.
+//
+//    assert.NotNil(t, err, "err should be something")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) {
+	if !assert.NotNil(t, object, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
+//
+//   assert.NotPanics(t, func(){
+//     RemainCalm()
+//   }, "Calling RemainCalm() should NOT panic")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotPanics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
+	if !assert.NotPanics(t, f, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// NotRegexp asserts that a specified regexp does not match a string.
+//
+//  assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
+//  assert.NotRegexp(t, "^start", "it's not starting")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) {
+	if !assert.NotRegexp(t, rx, str, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// NotZero asserts that i is not the zero value for its type and returns the truth.
+func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) {
+	if !assert.NotZero(t, i, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// Panics asserts that the code inside the specified PanicTestFunc panics.
+//
+//   assert.Panics(t, func(){
+//     GoCrazy()
+//   }, "Calling GoCrazy() should panic")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Panics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) {
+	if !assert.Panics(t, f, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// Regexp asserts that a specified regexp matches a string.
+//
+//  assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
+//  assert.Regexp(t, "start...$", "it's not starting")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) {
+	if !assert.Regexp(t, rx, str, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// True asserts that the specified value is true.
+//
+//    assert.True(t, myBool, "myBool should be true")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func True(t TestingT, value bool, msgAndArgs ...interface{}) {
+	if !assert.True(t, value, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// WithinDuration asserts that the two times are within duration delta of each other.
+//
+//   assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func WithinDuration(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) {
+	if !assert.WithinDuration(t, expected, actual, delta, msgAndArgs...) {
+		t.FailNow()
+	}
+}
+
+// Zero asserts that i is the zero value for its type and returns the truth.
+func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) {
+	if !assert.Zero(t, i, msgAndArgs...) {
+		t.FailNow()
+	}
+}
diff --git a/vendor/github.com/stretchr/testify/require/require_forward.go b/vendor/github.com/stretchr/testify/require/require_forward.go
new file mode 100644
index 0000000000..caa18793df
--- /dev/null
+++ b/vendor/github.com/stretchr/testify/require/require_forward.go
@@ -0,0 +1,353 @@
+/*
+* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
+* THIS FILE MUST NOT BE EDITED BY HAND
+ */
+
+package require
+
+import (
+	assert "github.com/stretchr/testify/assert"
+	http "net/http"
+	url "net/url"
+	time "time"
+)
+
+// Condition uses a Comparison to assert a complex condition.
+func (a *Assertions) Condition(comp assert.Comparison, msgAndArgs ...interface{}) {
+	Condition(a.t, comp, msgAndArgs...)
+}
+
+// Contains asserts that the specified string, list(array, slice...) or map contains the
+// specified substring or element.
+//
+//    a.Contains("Hello World", "World", "But 'Hello World' does contain 'World'")
+//    a.Contains(["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'")
+//    a.Contains({"Hello": "World"}, "Hello", "But {'Hello': 'World'} does contain 'Hello'")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) {
+	Contains(a.t, s, contains, msgAndArgs...)
+}
+
+// Empty asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//  a.Empty(obj)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) {
+	Empty(a.t, object, msgAndArgs...)
+}
+
+// Equal asserts that two objects are equal.
+//
+//    a.Equal(123, 123, "123 and 123 should be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
+func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	Equal(a.t, expected, actual, msgAndArgs...)
+}
+
+// EqualError asserts that a function returned an error (i.e. not `nil`)
+// and that it is equal to the provided error.
+//
+//   actualObj, err := SomeFunction()
+//   a.EqualError(err,  expectedErrorString, "An error was expected")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) {
+	EqualError(a.t, theError, errString, msgAndArgs...)
+}
+
+// EqualValues asserts that two objects are equal or convertable to the same types
+// and equal.
+//
+//    a.EqualValues(uint32(123), int32(123), "123 and 123 should be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	EqualValues(a.t, expected, actual, msgAndArgs...)
+}
+
+// Error asserts that a function returned an error (i.e. not `nil`).
+//
+//   actualObj, err := SomeFunction()
+//   if a.Error(err, "An error was expected") {
+// 	   assert.Equal(t, err, expectedError)
+//   }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Error(err error, msgAndArgs ...interface{}) {
+	Error(a.t, err, msgAndArgs...)
+}
+
+// Exactly asserts that two objects are equal is value and type.
+//
+//    a.Exactly(int32(123), int64(123), "123 and 123 should NOT be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	Exactly(a.t, expected, actual, msgAndArgs...)
+}
+
+// Fail reports a failure through
+func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) {
+	Fail(a.t, failureMessage, msgAndArgs...)
+}
+
+// FailNow fails test
+func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) {
+	FailNow(a.t, failureMessage, msgAndArgs...)
+}
+
+// False asserts that the specified value is false.
+//
+//    a.False(myBool, "myBool should be false")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) False(value bool, msgAndArgs ...interface{}) {
+	False(a.t, value, msgAndArgs...)
+}
+
+// HTTPBodyContains asserts that a specified handler returns a
+// body that contains a string.
+//
+//  a.HTTPBodyContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) {
+	HTTPBodyContains(a.t, handler, method, url, values, str)
+}
+
+// HTTPBodyNotContains asserts that a specified handler returns a
+// body that does not contain a string.
+//
+//  a.HTTPBodyNotContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) {
+	HTTPBodyNotContains(a.t, handler, method, url, values, str)
+}
+
+// HTTPError asserts that a specified handler returns an error status code.
+//
+//  a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values) {
+	HTTPError(a.t, handler, method, url, values)
+}
+
+// HTTPRedirect asserts that a specified handler returns a redirect status code.
+//
+//  a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values) {
+	HTTPRedirect(a.t, handler, method, url, values)
+}
+
+// HTTPSuccess asserts that a specified handler returns a success status code.
+//
+//  a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values) {
+	HTTPSuccess(a.t, handler, method, url, values)
+}
+
+// Implements asserts that an object is implemented by the specified interface.
+//
+//    a.Implements((*MyInterface)(nil), new(MyObject), "MyObject")
+func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) {
+	Implements(a.t, interfaceObject, object, msgAndArgs...)
+}
+
+// InDelta asserts that the two numerals are within delta of each other.
+//
+// 	 a.InDelta(math.Pi, (22 / 7.0), 0.01)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
+	InDelta(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// InDeltaSlice is the same as InDelta, except it compares two slices.
+func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) {
+	InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// InEpsilon asserts that expected and actual have a relative error less than epsilon
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
+	InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...)
+}
+
+// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.
+func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) {
+	InEpsilonSlice(a.t, expected, actual, epsilon, msgAndArgs...)
+}
+
+// IsType asserts that the specified objects are of the same type.
+func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) {
+	IsType(a.t, expectedType, object, msgAndArgs...)
+}
+
+// JSONEq asserts that two JSON strings are equivalent.
+//
+//  a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) {
+	JSONEq(a.t, expected, actual, msgAndArgs...)
+}
+
+// Len asserts that the specified object has specific length.
+// Len also fails if the object has a type that len() not accept.
+//
+//    a.Len(mySlice, 3, "The size of slice is not 3")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) {
+	Len(a.t, object, length, msgAndArgs...)
+}
+
+// Nil asserts that the specified object is nil.
+//
+//    a.Nil(err, "err should be nothing")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) {
+	Nil(a.t, object, msgAndArgs...)
+}
+
+// NoError asserts that a function returned no error (i.e. `nil`).
+//
+//   actualObj, err := SomeFunction()
+//   if a.NoError(err) {
+// 	   assert.Equal(t, actualObj, expectedObj)
+//   }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) {
+	NoError(a.t, err, msgAndArgs...)
+}
+
+// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
+// specified substring or element.
+//
+//    a.NotContains("Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")
+//    a.NotContains(["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'")
+//    a.NotContains({"Hello": "World"}, "Earth", "But {'Hello': 'World'} does NOT contain 'Earth'")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) {
+	NotContains(a.t, s, contains, msgAndArgs...)
+}
+
+// NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//  if a.NotEmpty(obj) {
+//    assert.Equal(t, "two", obj[1])
+//  }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) {
+	NotEmpty(a.t, object, msgAndArgs...)
+}
+
+// NotEqual asserts that the specified values are NOT equal.
+//
+//    a.NotEqual(obj1, obj2, "two objects shouldn't be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
+func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) {
+	NotEqual(a.t, expected, actual, msgAndArgs...)
+}
+
+// NotNil asserts that the specified object is not nil.
+//
+//    a.NotNil(err, "err should be something")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) {
+	NotNil(a.t, object, msgAndArgs...)
+}
+
+// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
+//
+//   a.NotPanics(func(){
+//     RemainCalm()
+//   }, "Calling RemainCalm() should NOT panic")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotPanics(f assert.PanicTestFunc, msgAndArgs ...interface{}) {
+	NotPanics(a.t, f, msgAndArgs...)
+}
+
+// NotRegexp asserts that a specified regexp does not match a string.
+//
+//  a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
+//  a.NotRegexp("^start", "it's not starting")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) {
+	NotRegexp(a.t, rx, str, msgAndArgs...)
+}
+
+// NotZero asserts that i is not the zero value for its type and returns the truth.
+func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) {
+	NotZero(a.t, i, msgAndArgs...)
+}
+
+// Panics asserts that the code inside the specified PanicTestFunc panics.
+//
+//   a.Panics(func(){
+//     GoCrazy()
+//   }, "Calling GoCrazy() should panic")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Panics(f assert.PanicTestFunc, msgAndArgs ...interface{}) {
+	Panics(a.t, f, msgAndArgs...)
+}
+
+// Regexp asserts that a specified regexp matches a string.
+//
+//  a.Regexp(regexp.MustCompile("start"), "it's starting")
+//  a.Regexp("start...$", "it's not starting")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) {
+	Regexp(a.t, rx, str, msgAndArgs...)
+}
+
+// True asserts that the specified value is true.
+//
+//    a.True(myBool, "myBool should be true")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) True(value bool, msgAndArgs ...interface{}) {
+	True(a.t, value, msgAndArgs...)
+}
+
+// WithinDuration asserts that the two times are within duration delta of each other.
+//
+//   a.WithinDuration(time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) {
+	WithinDuration(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// Zero asserts that i is the zero value for its type and returns the truth.
+func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) {
+	Zero(a.t, i, msgAndArgs...)
+}
diff --git a/vendor/github.com/stretchr/testify/require/requirements.go b/vendor/github.com/stretchr/testify/require/requirements.go
new file mode 100644
index 0000000000..41147562d8
--- /dev/null
+++ b/vendor/github.com/stretchr/testify/require/requirements.go
@@ -0,0 +1,9 @@
+package require
+
+// TestingT is an interface wrapper around *testing.T
+type TestingT interface {
+	Errorf(format string, args ...interface{})
+	FailNow()
+}
+
+//go:generate go run ../_codegen/main.go -output-package=require -template=require.go.tmpl