@@ -67,8 +67,7 @@ func (d *Daemon) CheckServiceUpdateState(service string) func(*check.C) (interfa

 // CheckPluginRunning returns the runtime state of the plugin

 func (d *Daemon) CheckPluginRunning(plugin string) func(c *check.C) (interface{}, check.CommentInterface) {

 	return func(c *check.C) (interface{}, check.CommentInterface) {

-		apiclient, err := d.NewClient()

-		assert.NilError(c, err)

+		apiclient := d.NewClientT(c)

 		resp, _, err := apiclient.PluginInspectWithRaw(context.Background(), plugin)

 		if client.IsErrNotFound(err) {

 			return false, check.Commentf("%v", err)

@@ -81,8 +80,7 @@ func (d *Daemon) CheckPluginRunning(plugin string) func(c *check.C) (interface{}

 // CheckPluginImage returns the runtime state of the plugin

 func (d *Daemon) CheckPluginImage(plugin string) func(c *check.C) (interface{}, check.CommentInterface) {

 	return func(c *check.C) (interface{}, check.CommentInterface) {

-		apiclient, err := d.NewClient()

-		assert.NilError(c, err)

+		apiclient := d.NewClientT(c)

 		resp, _, err := apiclient.PluginInspectWithRaw(context.Background(), plugin)

 		if client.IsErrNotFound(err) {

 			return false, check.Commentf("%v", err)

@@ -102,8 +100,7 @@ func (d *Daemon) CheckServiceTasks(service string) func(*check.C) (interface{},

 // CheckRunningTaskNetworks returns the number of times each network is referenced from a task.

 func (d *Daemon) CheckRunningTaskNetworks(c *check.C) (interface{}, check.CommentInterface) {

-	cli, err := d.NewClient()

-	c.Assert(err, checker.IsNil)

+	cli := d.NewClientT(c)

 	defer cli.Close()

 	filterArgs := filters.NewArgs()

@@ -127,8 +124,7 @@ func (d *Daemon) CheckRunningTaskNetworks(c *check.C) (interface{}, check.Commen

 // CheckRunningTaskImages returns the times each image is running as a task.

 func (d *Daemon) CheckRunningTaskImages(c *check.C) (interface{}, check.CommentInterface) {

-	cli, err := d.NewClient()

-	c.Assert(err, checker.IsNil)

+	cli := d.NewClientT(c)

 	defer cli.Close()

 	filterArgs := filters.NewArgs()

@@ -177,8 +173,7 @@ func (d *Daemon) CheckControlAvailable(c *check.C) (interface{}, check.CommentIn

 // CheckLeader returns whether there is a leader on the swarm or not

 func (d *Daemon) CheckLeader(c *check.C) (interface{}, check.CommentInterface) {

-	cli, err := d.NewClient()

-	c.Assert(err, checker.IsNil)

+	cli := d.NewClientT(c)

 	defer cli.Close()

 	errList := check.Commentf("could not get node list")

@@ -66,20 +66,19 @@ func (s *DockerSwarmSuite) TestAPISwarmServicesCreate(c *check.C) {

 	id := d.CreateService(c, simpleTestService, setInstances(instances))

 	waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, instances)

-	cli, err := d.NewClient()

-	c.Assert(err, checker.IsNil)

-	defer cli.Close()

+	client := d.NewClientT(c)

+	defer client.Close()

 	options := types.ServiceInspectOptions{InsertDefaults: true}

 	// insertDefaults inserts UpdateConfig when service is fetched by ID

-	resp, _, err := cli.ServiceInspectWithRaw(context.Background(), id, options)

+	resp, _, err := client.ServiceInspectWithRaw(context.Background(), id, options)

 	out := fmt.Sprintf("%+v", resp)

 	c.Assert(err, checker.IsNil)

 	c.Assert(out, checker.Contains, "UpdateConfig")

 	// insertDefaults inserts UpdateConfig when service is fetched by ID

-	resp, _, err = cli.ServiceInspectWithRaw(context.Background(), "top", options)

+	resp, _, err = client.ServiceInspectWithRaw(context.Background(), "top", options)

 	out = fmt.Sprintf("%+v", resp)

 	c.Assert(err, checker.IsNil)

 	c.Assert(string(out), checker.Contains, "UpdateConfig")

@@ -377,13 +377,12 @@ func (s *DockerSwarmSuite) TestAPISwarmRaftQuorum(c *check.C) {

 	var service swarm.Service

 	simpleTestService(&service)

 	service.Spec.Name = "top2"

-	cli, err := d1.NewClient()

-	c.Assert(err, checker.IsNil)

+	cli := d1.NewClientT(c)

 	defer cli.Close()

 	// d1 will eventually step down from leader because there is no longer an active quorum, wait for that to happen

 	waitAndAssert(c, defaultReconciliationTimeout, func(c *check.C) (interface{}, check.CommentInterface) {

-		_, err = cli.ServiceCreate(context.Background(), service.Spec, types.ServiceCreateOptions{})

+		_, err := cli.ServiceCreate(context.Background(), service.Spec, types.ServiceCreateOptions{})

 		return err.Error(), nil

 	}, checker.Contains, "Make sure more than half of the managers are online.")

@@ -849,10 +848,9 @@ func (s *DockerSwarmSuite) TestAPISwarmServicesUpdateWithName(c *check.C) {

 	instances = 5

 	setInstances(instances)(service)

-	cli, err := d.NewClient()

-	c.Assert(err, checker.IsNil)

+	cli := d.NewClientT(c)

 	defer cli.Close()

-	_, err = cli.ServiceUpdate(context.Background(), service.Spec.Name, service.Version, service.Spec, types.ServiceUpdateOptions{})

+	_, err := cli.ServiceUpdate(context.Background(), service.Spec.Name, service.Version, service.Spec, types.ServiceUpdateOptions{})

 	c.Assert(err, checker.IsNil)

 	waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, instances)

 }

@@ -884,8 +882,7 @@ func (s *DockerSwarmSuite) TestAPISwarmErrorHandling(c *check.C) {

 // This test makes sure the fixes correctly output scopes instead.

 func (s *DockerSwarmSuite) TestAPIDuplicateNetworks(c *check.C) {

 	d := s.AddDaemon(c, true, true)

-	cli, err := d.NewClient()

-	c.Assert(err, checker.IsNil)

+	cli := d.NewClientT(c)

 	defer cli.Close()

 	name := "foo"

@@ -1014,8 +1011,7 @@ func (s *DockerSwarmSuite) TestAPINetworkInspectWithScope(c *check.C) {

 	name := "test-scoped-network"

 	ctx := context.Background()

-	apiclient, err := d.NewClient()

-	assert.NilError(c, err)

+	apiclient := d.NewClientT(c)

 	resp, err := apiclient.NetworkCreate(ctx, name, types.NetworkCreate{Driver: "overlay"})

 	assert.NilError(c, err)

@@ -425,8 +425,7 @@ func (s *DockerSwarmSuite) TestOverlayAttachableOnSwarmLeave(c *check.C) {

 	c.Assert(err, checker.IsNil, check.Commentf("%s", out))

 	// Leave the swarm

-	err = d.SwarmLeave(true)

-	c.Assert(err, checker.IsNil)

+	c.Assert(d.SwarmLeave(true), checker.IsNil)

 	// Check the container is disconnected

 	out, err = d.Cmd("inspect", "c1", "--format", "{{.NetworkSettings.Networks."+nwName+"}}")

@@ -1612,8 +1611,7 @@ func (s *DockerSwarmSuite) TestNetworkInspectWithDuplicateNames(c *check.C) {

 		Driver:         "bridge",

 	}

-	cli, err := d.NewClient()

-	c.Assert(err, checker.IsNil)

+	cli := d.NewClientT(c)

 	defer cli.Close()

 	n1, err := cli.NetworkCreate(context.Background(), name, options)

@@ -36,18 +36,17 @@ func TestContainerStartOnDaemonRestart(t *testing.T) {

 	d.StartWithBusybox(t, "--iptables=false")

 	defer d.Stop(t)

-	client, err := d.NewClient()

-	assert.Check(t, err, "error creating client")

+	c := d.NewClientT(t)

 	ctx := context.Background()

-	cID := container.Create(t, ctx, client)

-	defer client.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{Force: true})

+	cID := container.Create(t, ctx, c)

+	defer c.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{Force: true})

-	err = client.ContainerStart(ctx, cID, types.ContainerStartOptions{})

+	err := c.ContainerStart(ctx, cID, types.ContainerStartOptions{})

 	assert.Check(t, err, "error starting test container")

-	inspect, err := client.ContainerInspect(ctx, cID)

+	inspect, err := c.ContainerInspect(ctx, cID)

 	assert.Check(t, err, "error getting inspect data")

 	ppid := getContainerdShimPid(t, inspect)

@@ -63,7 +62,7 @@ func TestContainerStartOnDaemonRestart(t *testing.T) {

 	d.Start(t, "--iptables=false")

-	err = client.ContainerStart(ctx, cID, types.ContainerStartOptions{})

+	err = c.ContainerStart(ctx, cID, types.ContainerStartOptions{})

 	assert.Check(t, err, "failed to start test container")

 }

@@ -62,17 +62,16 @@ func TestExportContainerAfterDaemonRestart(t *testing.T) {

 	skip.If(t, testEnv.IsRemoteDaemon())

 	d := daemon.New(t)

-	client, err := d.NewClient()

-	assert.NilError(t, err)

+	c := d.NewClientT(t)

 	d.StartWithBusybox(t)

 	defer d.Stop(t)

 	ctx := context.Background()

-	ctrID := container.Create(t, ctx, client)

+	ctrID := container.Create(t, ctx, c)

 	d.Restart(t)

-	_, err = client.ContainerExport(ctx, ctrID)

+	_, err := c.ContainerExport(ctx, ctrID)

 	assert.NilError(t, err)

 }

@@ -228,8 +228,7 @@ func testDaemonIpcPrivateShareable(t *testing.T, mustBeShared bool, arg ...strin

 	d.StartWithBusybox(t, arg...)

 	defer d.Stop(t)

-	client, err := d.NewClient()

-	assert.Check(t, err, "error creating client")

+	c := d.NewClientT(t)

 	cfg := containertypes.Config{

 		Image: "busybox",

@@ -237,16 +236,16 @@ func testDaemonIpcPrivateShareable(t *testing.T, mustBeShared bool, arg ...strin

 	}

 	ctx := context.Background()

-	resp, err := client.ContainerCreate(ctx, &cfg, &containertypes.HostConfig{}, nil, "")

+	resp, err := c.ContainerCreate(ctx, &cfg, &containertypes.HostConfig{}, nil, "")

 	assert.NilError(t, err)

 	assert.Check(t, is.Equal(len(resp.Warnings), 0))

-	err = client.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{})

+	err = c.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{})

 	assert.NilError(t, err)

 	// get major:minor pair for /dev/shm from container's /proc/self/mountinfo

 	cmd := "awk '($5 == \"/dev/shm\") {printf $3}' /proc/self/mountinfo"

-	result, err := container.Exec(ctx, client, resp.ID, []string{"sh", "-c", cmd})

+	result, err := container.Exec(ctx, c, resp.ID, []string{"sh", "-c", cmd})

 	assert.NilError(t, err)

 	mm := result.Combined()

 	assert.Check(t, is.Equal(true, regexp.MustCompile("^[0-9]+:[0-9]+$").MatchString(mm)))

@@ -26,7 +26,7 @@ func TestDaemonRestartKillContainers(t *testing.T) {

 		xStart              bool

 	}

-	for _, c := range []testCase{

+	for _, tc := range []testCase{

 		{

 			desc:                "container without restart policy",

 			config:              &container.Config{Image: "busybox", Cmd: []string{"top"}},

@@ -57,16 +57,15 @@ func TestDaemonRestartKillContainers(t *testing.T) {

 					d.Stop(t)

 				},

 			} {

-				t.Run(fmt.Sprintf("live-restore=%v/%s/%s", liveRestoreEnabled, c.desc, fnName), func(t *testing.T) {

-					c := c

+				t.Run(fmt.Sprintf("live-restore=%v/%s/%s", liveRestoreEnabled, tc.desc, fnName), func(t *testing.T) {

+					c := tc

 					liveRestoreEnabled := liveRestoreEnabled

 					stopDaemon := stopDaemon

 					t.Parallel()

 					d := daemon.New(t)

-					client, err := d.NewClient()

-					assert.NilError(t, err)

+					client := d.NewClientT(t)

 					args := []string{"--iptables=false"}

 					if liveRestoreEnabled {

@@ -32,19 +32,18 @@ func TestDockerNetworkIpvlanPersistance(t *testing.T) {

 	n.CreateMasterDummy(t, master)

 	defer n.DeleteInterface(t, master)

-	client, err := d.NewClient()

-	assert.NilError(t, err)

+	c := d.NewClientT(t)

 	// create a network specifying the desired sub-interface name

 	netName := "di-persist"

-	net.CreateNoError(t, context.Background(), client, netName,

+	net.CreateNoError(t, context.Background(), c, netName,

 		net.WithIPvlan("di-dummy0.70", ""),

 	)

-	assert.Check(t, n.IsNetworkAvailable(client, netName))

+	assert.Check(t, n.IsNetworkAvailable(c, netName))

 	// Restart docker daemon to test the config has persisted to disk

 	d.Restart(t)

-	assert.Check(t, n.IsNetworkAvailable(client, netName))

+	assert.Check(t, n.IsNetworkAvailable(c, netName))

 }

 func TestDockerNetworkIpvlan(t *testing.T) {

@@ -87,11 +86,9 @@ func TestDockerNetworkIpvlan(t *testing.T) {

 	} {

 		d := daemon.New(t, daemon.WithExperimental)

 		d.StartWithBusybox(t)

+		c := d.NewClientT(t)

-		client, err := d.NewClient()

-		assert.NilError(t, err)

-

-		t.Run(tc.name, tc.test(client))

+		t.Run(tc.name, tc.test(c))

 		d.Stop(t)

 		// FIXME(vdemeester) clean network

@@ -30,16 +30,15 @@ func TestDockerNetworkMacvlanPersistance(t *testing.T) {

 	n.CreateMasterDummy(t, master)

 	defer n.DeleteInterface(t, master)

-	client, err := d.NewClient()

-	assert.NilError(t, err)

+	c := d.NewClientT(t)

 	netName := "dm-persist"

-	net.CreateNoError(t, context.Background(), client, netName,

+	net.CreateNoError(t, context.Background(), c, netName,

 		net.WithMacvlan("dm-dummy0.60"),

 	)

-	assert.Check(t, n.IsNetworkAvailable(client, netName))

+	assert.Check(t, n.IsNetworkAvailable(c, netName))

 	d.Restart(t)

-	assert.Check(t, n.IsNetworkAvailable(client, netName))

+	assert.Check(t, n.IsNetworkAvailable(c, netName))

 }

 func TestDockerNetworkMacvlan(t *testing.T) {

@@ -69,11 +68,9 @@ func TestDockerNetworkMacvlan(t *testing.T) {

 	} {

 		d := daemon.New(t)

 		d.StartWithBusybox(t)

+		c := d.NewClientT(t)

-		client, err := d.NewClient()

-		assert.NilError(t, err)

-

-		t.Run(tc.name, tc.test(client))

+		t.Run(tc.name, tc.test(c))

 		d.Stop(t)

 		// FIXME(vdemeester) clean network

@@ -26,21 +26,20 @@ func TestRunContainerWithBridgeNone(t *testing.T) {

 	d.StartWithBusybox(t, "-b", "none")

 	defer d.Stop(t)

-	client, err := d.NewClient()

-	assert.Check(t, err, "error creating client")

-

+	c := d.NewClientT(t)

 	ctx := context.Background()

-	id1 := container.Run(t, ctx, client)

-	defer client.ContainerRemove(ctx, id1, types.ContainerRemoveOptions{Force: true})

-	result, err := container.Exec(ctx, client, id1, []string{"ip", "l"})

+	id1 := container.Run(t, ctx, c)

+	defer c.ContainerRemove(ctx, id1, types.ContainerRemoveOptions{Force: true})

+

+	result, err := container.Exec(ctx, c, id1, []string{"ip", "l"})

 	assert.NilError(t, err)

 	assert.Check(t, is.Equal(false, strings.Contains(result.Combined(), "eth0")), "There shouldn't be eth0 in container in default(bridge) mode when bridge network is disabled")

-	id2 := container.Run(t, ctx, client, container.WithNetworkMode("bridge"))

-	defer client.ContainerRemove(ctx, id2, types.ContainerRemoveOptions{Force: true})

+	id2 := container.Run(t, ctx, c, container.WithNetworkMode("bridge"))

+	defer c.ContainerRemove(ctx, id2, types.ContainerRemoveOptions{Force: true})

-	result, err = container.Exec(ctx, client, id2, []string{"ip", "l"})

+	result, err = container.Exec(ctx, c, id2, []string{"ip", "l"})

 	assert.NilError(t, err)

 	assert.Check(t, is.Equal(false, strings.Contains(result.Combined(), "eth0")), "There shouldn't be eth0 in container in bridge mode when bridge network is disabled")

@@ -51,10 +50,10 @@ func TestRunContainerWithBridgeNone(t *testing.T) {

 	err = cmd.Run()

 	assert.NilError(t, err, "Failed to get current process network namespace: %+v", err)

-	id3 := container.Run(t, ctx, client, container.WithNetworkMode("host"))

-	defer client.ContainerRemove(ctx, id3, types.ContainerRemoveOptions{Force: true})

+	id3 := container.Run(t, ctx, c, container.WithNetworkMode("host"))

+	defer c.ContainerRemove(ctx, id3, types.ContainerRemoveOptions{Force: true})

-	result, err = container.Exec(ctx, client, id3, []string{"sh", "-c", nsCommand})

+	result, err = container.Exec(ctx, c, id3, []string{"sh", "-c", nsCommand})

 	assert.NilError(t, err)

 	assert.Check(t, is.Equal(stdout.String(), result.Combined()), "The network namspace of container should be the same with host when --net=host and bridge network is disabled")

 }

@@ -32,15 +32,16 @@ func TestDaemonRestartWithLiveRestore(t *testing.T) {

 	d := daemon.New(t)

 	defer d.Stop(t)

 	d.Start(t)

-	d.Restart(t, "--live-restore=true",

+	d.Restart(t,

+		"--live-restore=true",

 		"--default-address-pool", "base=175.30.0.0/16,size=16",

-		"--default-address-pool", "base=175.33.0.0/16,size=24")

+		"--default-address-pool", "base=175.33.0.0/16,size=24",

+	)

 	// Verify bridge network's subnet

-	cli, err := d.NewClient()

-	assert.Assert(t, err)

-	defer cli.Close()

-	out, err := cli.NetworkInspect(context.Background(), "bridge", types.NetworkInspectOptions{})

+	c := d.NewClientT(t)

+	defer c.Close()

+	out, err := c.NetworkInspect(context.Background(), "bridge", types.NetworkInspectOptions{})

 	assert.NilError(t, err)

 	// Make sure docker0 doesn't get override with new IP in live restore case

 	assert.Equal(t, out.IPAM.Config[0].Subnet, "172.18.0.0/16")

@@ -57,31 +58,32 @@ func TestDaemonDefaultNetworkPools(t *testing.T) {

 	defer d.Stop(t)

 	d.Start(t,

 		"--default-address-pool", "base=175.30.0.0/16,size=16",

-		"--default-address-pool", "base=175.33.0.0/16,size=24")

+		"--default-address-pool", "base=175.33.0.0/16,size=24",

+	)

+

+	c := d.NewClientT(t)

+	defer c.Close()

 	// Verify bridge network's subnet

-	cli, err := d.NewClient()

-	assert.Assert(t, err)

-	defer cli.Close()

-	out, err := cli.NetworkInspect(context.Background(), "bridge", types.NetworkInspectOptions{})

+	out, err := c.NetworkInspect(context.Background(), "bridge", types.NetworkInspectOptions{})

 	assert.NilError(t, err)

 	assert.Equal(t, out.IPAM.Config[0].Subnet, "175.30.0.0/16")

 	// Create a bridge network and verify its subnet is the second default pool

 	name := "elango" + t.Name()

-	network.CreateNoError(t, context.Background(), cli, name,

+	network.CreateNoError(t, context.Background(), c, name,

 		network.WithDriver("bridge"),

 	)

-	out, err = cli.NetworkInspect(context.Background(), name, types.NetworkInspectOptions{})

+	out, err = c.NetworkInspect(context.Background(), name, types.NetworkInspectOptions{})

 	assert.NilError(t, err)

 	assert.Equal(t, out.IPAM.Config[0].Subnet, "175.33.0.0/24")

 	// Create a bridge network and verify its subnet is the third default pool

 	name = "saanvi" + t.Name()

-	network.CreateNoError(t, context.Background(), cli, name,

+	network.CreateNoError(t, context.Background(), c, name,

 		network.WithDriver("bridge"),

 	)

-	out, err = cli.NetworkInspect(context.Background(), name, types.NetworkInspectOptions{})

+	out, err = c.NetworkInspect(context.Background(), name, types.NetworkInspectOptions{})

 	assert.NilError(t, err)

 	assert.Equal(t, out.IPAM.Config[0].Subnet, "175.33.1.0/24")

 	delInterface(t, defaultNetworkBridge)

@@ -96,17 +98,17 @@ func TestDaemonRestartWithExistingNetwork(t *testing.T) {

 	d := daemon.New(t)

 	d.Start(t)

 	defer d.Stop(t)

-	// Verify bridge network's subnet

-	cli, err := d.NewClient()

-	assert.Assert(t, err)

-	defer cli.Close()

+	c := d.NewClientT(t)

+	defer c.Close()

 	// Create a bridge network

 	name := "elango" + t.Name()

-	network.CreateNoError(t, context.Background(), cli, name,

+	network.CreateNoError(t, context.Background(), c, name,

 		network.WithDriver("bridge"),

 	)

-	out, err := cli.NetworkInspect(context.Background(), name, types.NetworkInspectOptions{})

+

+	// Verify bridge network's subnet

+	out, err := c.NetworkInspect(context.Background(), name, types.NetworkInspectOptions{})

 	assert.NilError(t, err)

 	networkip := out.IPAM.Config[0].Subnet

@@ -115,7 +117,7 @@ func TestDaemonRestartWithExistingNetwork(t *testing.T) {

 		"--default-address-pool", "base=175.30.0.0/16,size=16",

 		"--default-address-pool", "base=175.33.0.0/16,size=24")

-	out1, err := cli.NetworkInspect(context.Background(), name, types.NetworkInspectOptions{})

+	out1, err := c.NetworkInspect(context.Background(), name, types.NetworkInspectOptions{})

 	assert.NilError(t, err)

 	assert.Equal(t, out1.IPAM.Config[0].Subnet, networkip)

 	delInterface(t, defaultNetworkBridge)

@@ -129,40 +131,41 @@ func TestDaemonRestartWithExistingNetworkWithDefaultPoolRange(t *testing.T) {

 	d := daemon.New(t)

 	d.Start(t)

 	defer d.Stop(t)

-	// Verify bridge network's subnet

-	cli, err := d.NewClient()

-	assert.Assert(t, err)

-	defer cli.Close()

+	c := d.NewClientT(t)

+	defer c.Close()

 	// Create a bridge network

 	name := "elango" + t.Name()

-	network.CreateNoError(t, context.Background(), cli, name,

+	network.CreateNoError(t, context.Background(), c, name,

 		network.WithDriver("bridge"),

 	)

-	out, err := cli.NetworkInspect(context.Background(), name, types.NetworkInspectOptions{})

+

+	// Verify bridge network's subnet

+	out, err := c.NetworkInspect(context.Background(), name, types.NetworkInspectOptions{})

 	assert.NilError(t, err)

 	networkip := out.IPAM.Config[0].Subnet

 	// Create a bridge network

 	name = "sthira" + t.Name()

-	network.CreateNoError(t, context.Background(), cli, name,

+	network.CreateNoError(t, context.Background(), c, name,

 		network.WithDriver("bridge"),

 	)

-	out, err = cli.NetworkInspect(context.Background(), name, types.NetworkInspectOptions{})

+	out, err = c.NetworkInspect(context.Background(), name, types.NetworkInspectOptions{})

 	assert.NilError(t, err)

 	networkip2 := out.IPAM.Config[0].Subnet

 	// Restart daemon with default address pool option

 	d.Restart(t,

 		"--default-address-pool", "base=175.18.0.0/16,size=16",

-		"--default-address-pool", "base=175.19.0.0/16,size=24")

+		"--default-address-pool", "base=175.19.0.0/16,size=24",

+	)

 	// Create a bridge network

 	name = "saanvi" + t.Name()

-	network.CreateNoError(t, context.Background(), cli, name,

+	network.CreateNoError(t, context.Background(), c, name,

 		network.WithDriver("bridge"),

 	)

-	out1, err := cli.NetworkInspect(context.Background(), name, types.NetworkInspectOptions{})

+	out1, err := c.NetworkInspect(context.Background(), name, types.NetworkInspectOptions{})

 	assert.NilError(t, err)

 	assert.Check(t, out1.IPAM.Config[0].Subnet != networkip)

@@ -177,15 +180,17 @@ func TestDaemonWithBipAndDefaultNetworkPool(t *testing.T) {

 	defaultNetworkBridge := "docker0"

 	d := daemon.New(t)

 	defer d.Stop(t)

-	d.Start(t, "--bip=172.60.0.1/16",

+	d.Start(t,

+		"--bip=172.60.0.1/16",

 		"--default-address-pool", "base=175.30.0.0/16,size=16",

-		"--default-address-pool", "base=175.33.0.0/16,size=24")

+		"--default-address-pool", "base=175.33.0.0/16,size=24",

+	)

+

+	c := d.NewClientT(t)

+	defer c.Close()

 	// Verify bridge network's subnet

-	cli, err := d.NewClient()

-	assert.Assert(t, err)

-	defer cli.Close()

-	out, err := cli.NetworkInspect(context.Background(), "bridge", types.NetworkInspectOptions{})

+	out, err := c.NetworkInspect(context.Background(), "bridge", types.NetworkInspectOptions{})

 	assert.NilError(t, err)

 	// Make sure BIP IP doesn't get override with new default address pool .

 	assert.Equal(t, out.IPAM.Config[0].Subnet, "172.60.0.1/16")

@@ -197,8 +202,8 @@ func TestServiceWithPredefinedNetwork(t *testing.T) {

 	defer setupTest(t)()

 	d := swarm.NewSwarm(t, testEnv)

 	defer d.Stop(t)

-	client := d.NewClientT(t)

-	defer client.Close()

+	c := d.NewClientT(t)

+	defer c.Close()

 	hostName := "host"

 	var instances uint64 = 1

@@ -210,12 +215,12 @@ func TestServiceWithPredefinedNetwork(t *testing.T) {

 		swarm.ServiceWithNetwork(hostName),

 	)

-	poll.WaitOn(t, serviceRunningCount(client, serviceID, instances), swarm.ServicePoll)

+	poll.WaitOn(t, serviceRunningCount(c, serviceID, instances), swarm.ServicePoll)

-	_, _, err := client.ServiceInspectWithRaw(context.Background(), serviceID, types.ServiceInspectOptions{})

+	_, _, err := c.ServiceInspectWithRaw(context.Background(), serviceID, types.ServiceInspectOptions{})

 	assert.NilError(t, err)

-	err = client.ServiceRemove(context.Background(), serviceID)

+	err = c.ServiceRemove(context.Background(), serviceID)

 	assert.NilError(t, err)

 }

@@ -226,10 +231,10 @@ func TestServiceRemoveKeepsIngressNetwork(t *testing.T) {

 	defer setupTest(t)()

 	d := swarm.NewSwarm(t, testEnv)

 	defer d.Stop(t)

-	client := d.NewClientT(t)

-	defer client.Close()

+	c := d.NewClientT(t)

+	defer c.Close()

-	poll.WaitOn(t, swarmIngressReady(client), swarm.NetworkPoll)

+	poll.WaitOn(t, swarmIngressReady(c), swarm.NetworkPoll)

 	var instances uint64 = 1

@@ -247,20 +252,20 @@ func TestServiceRemoveKeepsIngressNetwork(t *testing.T) {

 		}),

 	)

-	poll.WaitOn(t, serviceRunningCount(client, serviceID, instances), swarm.ServicePoll)

+	poll.WaitOn(t, serviceRunningCount(c, serviceID, instances), swarm.ServicePoll)

-	_, _, err := client.ServiceInspectWithRaw(context.Background(), serviceID, types.ServiceInspectOptions{})

+	_, _, err := c.ServiceInspectWithRaw(context.Background(), serviceID, types.ServiceInspectOptions{})

 	assert.NilError(t, err)

-	err = client.ServiceRemove(context.Background(), serviceID)

+	err = c.ServiceRemove(context.Background(), serviceID)

 	assert.NilError(t, err)

-	poll.WaitOn(t, serviceIsRemoved(client, serviceID), swarm.ServicePoll)

-	poll.WaitOn(t, noServices(client), swarm.ServicePoll)

+	poll.WaitOn(t, serviceIsRemoved(c, serviceID), swarm.ServicePoll)

+	poll.WaitOn(t, noServices(c), swarm.ServicePoll)

 	// Ensure that "ingress" is not removed or corrupted

 	time.Sleep(10 * time.Second)

-	netInfo, err := client.NetworkInspect(context.Background(), ingressNet, types.NetworkInspectOptions{

+	netInfo, err := c.NetworkInspect(context.Background(), ingressNet, types.NetworkInspectOptions{

 		Verbose: true,

 		Scope:   "swarm",

 	})

@@ -330,12 +335,12 @@ func TestServiceWithDataPathPortInit(t *testing.T) {

 	ops = append(ops, daemon.WithSwarmDataPathPort(datapathPort))

 	d := swarm.NewSwarm(t, testEnv, ops...)

-	cli := d.NewClientT(t)

-	defer cli.Close()

+	c := d.NewClientT(t)

+	defer c.Close()

 	// Create a overlay network

 	name := "saanvisthira" + t.Name()

-	network.CreateNoError(t, context.Background(), cli, name,

+	network.CreateNoError(t, context.Background(), c, name,

 		network.WithDriver("overlay"))

 	var instances uint64 = 1

@@ -344,11 +349,11 @@ func TestServiceWithDataPathPortInit(t *testing.T) {

 		swarm.ServiceWithNetwork(name),

 	)

-	poll.WaitOn(t, serviceRunningCount(cli, serviceID, instances), swarm.ServicePoll)

+	poll.WaitOn(t, serviceRunningCount(c, serviceID, instances), swarm.ServicePoll)

 	info := d.Info(t)

 	assert.Equal(t, info.Swarm.Cluster.DataPathPort, datapathPort)

-	err := cli.ServiceRemove(context.Background(), serviceID)

+	err := c.ServiceRemove(context.Background(), serviceID)

 	assert.NilError(t, err)

 	d.SwarmLeave(true)

 	d.Stop(t)

@@ -357,11 +362,11 @@ func TestServiceWithDataPathPortInit(t *testing.T) {

 	// call without datapath port option.

 	ops = []func(*daemon.Daemon){}

 	d = swarm.NewSwarm(t, testEnv, ops...)

-	cli = d.NewClientT(t)

+	c = d.NewClientT(t)

 	// Create a overlay network

 	name = "saanvisthira" + t.Name()

-	network.CreateNoError(t, context.Background(), cli, name,

+	network.CreateNoError(t, context.Background(), c, name,

 		network.WithDriver("overlay"))

 	serviceID = swarm.CreateService(t, d,

@@ -369,12 +374,12 @@ func TestServiceWithDataPathPortInit(t *testing.T) {

 		swarm.ServiceWithNetwork(name),

 	)

-	poll.WaitOn(t, serviceRunningCount(cli, serviceID, instances), swarm.ServicePoll)

+	poll.WaitOn(t, serviceRunningCount(c, serviceID, instances), swarm.ServicePoll)

 	info = d.Info(t)

 	var defaultDataPathPort uint32 = 4789

 	assert.Equal(t, info.Swarm.Cluster.DataPathPort, defaultDataPathPort)

-	err = cli.ServiceRemove(context.Background(), serviceID)

+	err = c.ServiceRemove(context.Background(), serviceID)

 	assert.NilError(t, err)

 	d.SwarmLeave(true)

 	defer d.Stop(t)

@@ -87,18 +87,16 @@ func TestAuthZPluginAllowRequest(t *testing.T) {

 	ctrl.resRes.Allow = true

 	d.StartWithBusybox(t, "--authorization-plugin="+testAuthZPlugin)

-	client, err := d.NewClient()

-	assert.NilError(t, err)

-

+	c := d.NewClientT(t)

 	ctx := context.Background()

 	// Ensure command successful

-	cID := container.Run(t, ctx, client)

+	cID := container.Run(t, ctx, c)

 	assertURIRecorded(t, ctrl.requestsURIs, "/containers/create")

 	assertURIRecorded(t, ctrl.requestsURIs, fmt.Sprintf("/containers/%s/start", cID))

-	_, err = client.ServerVersion(ctx)

+	_, err := c.ServerVersion(ctx)

 	assert.NilError(t, err)

 	assert.Equal(t, 1, ctrl.versionReqCount)

 	assert.Equal(t, 1, ctrl.versionResCount)

@@ -126,10 +124,10 @@ func TestAuthZPluginTLS(t *testing.T) {

 	ctrl.reqRes.Allow = true

 	ctrl.resRes.Allow = true

-	client, err := newTLSAPIClient(testDaemonHTTPSAddr, cacertPath, clientCertPath, clientKeyPath)

+	c, err := newTLSAPIClient(testDaemonHTTPSAddr, cacertPath, clientCertPath, clientKeyPath)

 	assert.NilError(t, err)

-	_, err = client.ServerVersion(context.Background())

+	_, err = c.ServerVersion(context.Background())

 	assert.NilError(t, err)

 	assert.Equal(t, "client", ctrl.reqUser)

@@ -153,11 +151,10 @@ func TestAuthZPluginDenyRequest(t *testing.T) {

 	ctrl.reqRes.Allow = false

 	ctrl.reqRes.Msg = unauthorizedMessage

-	client, err := d.NewClient()

-	assert.NilError(t, err)

+	c := d.NewClientT(t)

 	// Ensure command is blocked

-	_, err = client.ServerVersion(context.Background())

+	_, err := c.ServerVersion(context.Background())

 	assert.Assert(t, err != nil)

 	assert.Equal(t, 1, ctrl.versionReqCount)

 	assert.Equal(t, 0, ctrl.versionResCount)

@@ -179,10 +176,10 @@ func TestAuthZPluginAPIDenyResponse(t *testing.T) {

 	conn, err := net.DialTimeout(daemonURL.Scheme, daemonURL.Path, time.Second*10)

 	assert.NilError(t, err)

-	client := httputil.NewClientConn(conn, nil)

+	c := httputil.NewClientConn(conn, nil)

 	req, err := http.NewRequest("GET", "/version", nil)

 	assert.NilError(t, err)

-	resp, err := client.Do(req)

+	resp, err := c.Do(req)

 	assert.NilError(t, err)

 	assert.DeepEqual(t, http.StatusForbidden, resp.StatusCode)

@@ -195,11 +192,10 @@ func TestAuthZPluginDenyResponse(t *testing.T) {

 	ctrl.resRes.Allow = false

 	ctrl.resRes.Msg = unauthorizedMessage

-	client, err := d.NewClient()

-	assert.NilError(t, err)

+	c := d.NewClientT(t)

 	// Ensure command is blocked

-	_, err = client.ServerVersion(context.Background())

+	_, err := c.ServerVersion(context.Background())

 	assert.Assert(t, err != nil)

 	assert.Equal(t, 1, ctrl.versionReqCount)

 	assert.Equal(t, 1, ctrl.versionResCount)

@@ -219,20 +215,18 @@ func TestAuthZPluginAllowEventStream(t *testing.T) {

 	ctrl.resRes.Allow = true

 	d.StartWithBusybox(t, "--authorization-plugin="+testAuthZPlugin)

-	client, err := d.NewClient()

-	assert.NilError(t, err)

-

+	c := d.NewClientT(t)

 	ctx := context.Background()

-	startTime := strconv.FormatInt(systemTime(t, client, testEnv).Unix(), 10)

-	events, errs, cancel := systemEventsSince(client, startTime)

+	startTime := strconv.FormatInt(systemTime(t, c, testEnv).Unix(), 10)

+	events, errs, cancel := systemEventsSince(c, startTime)

 	defer cancel()

 	// Create a container and wait for the creation events

-	cID := container.Run(t, ctx, client)

+	cID := container.Run(t, ctx, c)

 	for i := 0; i < 100; i++ {

-		c, err := client.ContainerInspect(ctx, cID)

+		c, err := c.ContainerInspect(ctx, cID)

 		assert.NilError(t, err)

 		if c.State.Running {

 			break

@@ -304,11 +298,10 @@ func TestAuthZPluginErrorResponse(t *testing.T) {

 	ctrl.reqRes.Allow = true

 	ctrl.resRes.Err = errorMessage

-	client, err := d.NewClient()

-	assert.NilError(t, err)

+	c := d.NewClientT(t)

 	// Ensure command is blocked

-	_, err = client.ServerVersion(context.Background())

+	_, err := c.ServerVersion(context.Background())

 	assert.Assert(t, err != nil)

 	assert.Equal(t, fmt.Sprintf("Error response from daemon: plugin %s failed with error: %s: %s", testAuthZPlugin, authorization.AuthZApiResponse, errorMessage), err.Error())

 }

@@ -318,11 +311,10 @@ func TestAuthZPluginErrorRequest(t *testing.T) {

 	d.Start(t, "--authorization-plugin="+testAuthZPlugin)

 	ctrl.reqRes.Err = errorMessage

-	client, err := d.NewClient()

-	assert.NilError(t, err)

+	c := d.NewClientT(t)

 	// Ensure command is blocked

-	_, err = client.ServerVersion(context.Background())

+	_, err := c.ServerVersion(context.Background())

 	assert.Assert(t, err != nil)

 	assert.Equal(t, fmt.Sprintf("Error response from daemon: plugin %s failed with error: %s: %s", testAuthZPlugin, authorization.AuthZApiRequest, errorMessage), err.Error())

 }

@@ -334,10 +326,9 @@ func TestAuthZPluginEnsureNoDuplicatePluginRegistration(t *testing.T) {

 	ctrl.reqRes.Allow = true

 	ctrl.resRes.Allow = true

-	client, err := d.NewClient()

-	assert.NilError(t, err)

+	c := d.NewClientT(t)

-	_, err = client.ServerVersion(context.Background())

+	_, err := c.ServerVersion(context.Background())

 	assert.NilError(t, err)

 	// assert plugin is only called once..

@@ -351,9 +342,7 @@ func TestAuthZPluginEnsureLoadImportWorking(t *testing.T) {

 	ctrl.resRes.Allow = true

 	d.StartWithBusybox(t, "--authorization-plugin="+testAuthZPlugin, "--authorization-plugin="+testAuthZPlugin)

-	client, err := d.NewClient()

-	assert.NilError(t, err)

-

+	c := d.NewClientT(t)

 	ctx := context.Background()

 	tmp, err := ioutil.TempDir("", "test-authz-load-import")

@@ -362,16 +351,16 @@ func TestAuthZPluginEnsureLoadImportWorking(t *testing.T) {

 	savedImagePath := filepath.Join(tmp, "save.tar")

-	err = imageSave(client, savedImagePath, "busybox")

+	err = imageSave(c, savedImagePath, "busybox")

 	assert.NilError(t, err)

-	err = imageLoad(client, savedImagePath)

+	err = imageLoad(c, savedImagePath)

 	assert.NilError(t, err)

 	exportedImagePath := filepath.Join(tmp, "export.tar")

-	cID := container.Run(t, ctx, client)

+	cID := container.Run(t, ctx, c)

-	responseReader, err := client.ContainerExport(context.Background(), cID)

+	responseReader, err := c.ContainerExport(context.Background(), cID)

 	assert.NilError(t, err)

 	defer responseReader.Close()

 	file, err := os.Create(exportedImagePath)

@@ -380,7 +369,7 @@ func TestAuthZPluginEnsureLoadImportWorking(t *testing.T) {

 	_, err = io.Copy(file, responseReader)

 	assert.NilError(t, err)

-	err = imageImport(client, exportedImagePath)

+	err = imageImport(c, exportedImagePath)

 	assert.NilError(t, err)

 }

@@ -406,12 +395,11 @@ func TestAuthzPluginEnsureContainerCopyToFrom(t *testing.T) {

 		written += n

 	}

+	c := d.NewClientT(t)

 	ctx := context.Background()

-	client, err := d.NewClient()

-	assert.Assert(t, err)

-	cID := container.Run(t, ctx, client)

-	defer client.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{Force: true})

+	cID := container.Run(t, ctx, c)

+	defer c.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{Force: true})

 	_, err = f.Seek(0, io.SeekStart)

 	assert.Assert(t, err)

@@ -425,10 +413,10 @@ func TestAuthzPluginEnsureContainerCopyToFrom(t *testing.T) {

 	dstDir, preparedArchive, err := archive.PrepareArchiveCopy(srcArchive, srcInfo, archive.CopyInfo{Path: "/test"})

 	assert.Assert(t, err)