@@ -25,7 +25,7 @@ func TestDiskUsage(t *testing.T) {

 	defer d.Cleanup(t)

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

 	defer d.Stop(t)

-	client := d.NewClientT(t)

+	apiClient := d.NewClientT(t)

 	var stepDU types.DiskUsage

 	for _, step := range []struct {

@@ -35,7 +35,7 @@ func TestDiskUsage(t *testing.T) {

 		{

 			doc: "empty",

 			next: func(t *testing.T, _ types.DiskUsage) types.DiskUsage {

-				du, err := client.DiskUsage(ctx, types.DiskUsageOptions{})

+				du, err := apiClient.DiskUsage(ctx, types.DiskUsageOptions{})

 				assert.NilError(t, err)

 				expectedLayersSize := int64(0)

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

 			next: func(t *testing.T, _ types.DiskUsage) types.DiskUsage {

 				d.LoadBusybox(ctx, t)

-				du, err := client.DiskUsage(ctx, types.DiskUsageOptions{})

+				du, err := apiClient.DiskUsage(ctx, types.DiskUsageOptions{})

 				assert.NilError(t, err)

 				assert.Assert(t, du.LayersSize > 0)

 				assert.Equal(t, len(du.Images), 1)

@@ -84,9 +84,9 @@ func TestDiskUsage(t *testing.T) {

 		{

 			doc: "after container.Run",

 			next: func(t *testing.T, prev types.DiskUsage) types.DiskUsage {

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

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

-				du, err := client.DiskUsage(ctx, types.DiskUsageOptions{})

+				du, err := apiClient.DiskUsage(ctx, types.DiskUsageOptions{})

 				assert.NilError(t, err)

 				assert.Equal(t, len(du.Containers), 1)

 				assert.Equal(t, len(du.Containers[0].Names), 1)

@@ -263,7 +263,7 @@ func TestDiskUsage(t *testing.T) {

 					ctx := testutil.StartSpan(ctx, t)

 					// TODO: Run in parallel once https://github.com/moby/moby/pull/42560 is merged.

-					du, err := client.DiskUsage(ctx, tc.options)

+					du, err := apiClient.DiskUsage(ctx, tc.options)

 					assert.NilError(t, err)

 					assert.DeepEqual(t, du, tc.expected)

 				})

@@ -28,23 +28,23 @@ import (

 func TestEventsExecDie(t *testing.T) {

 	skip.If(t, testEnv.DaemonInfo.OSType == "windows", "FIXME. Suspect may need to wait until container is running before exec")

 	ctx := setupTest(t)

-	client := testEnv.APIClient()

+	apiClient := testEnv.APIClient()

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

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

-	id, err := client.ContainerExecCreate(ctx, cID, containertypes.ExecOptions{

+	id, err := apiClient.ContainerExecCreate(ctx, cID, containertypes.ExecOptions{

 		Cmd: []string{"echo", "hello"},

 	})

 	assert.NilError(t, err)

-	msg, errs := client.Events(ctx, events.ListOptions{

+	msg, errs := apiClient.Events(ctx, events.ListOptions{

 		Filters: filters.NewArgs(

 			filters.Arg("container", cID),

 			filters.Arg("event", string(events.ActionExecDie)),

 		),

 	})

-	err = client.ContainerExecStart(ctx, id.ID, containertypes.ExecStartOptions{

+	err = apiClient.ContainerExecStart(ctx, id.ID, containertypes.ExecStartOptions{

 		Detach: true,

 		Tty:    false,

 	})

@@ -71,12 +71,12 @@ func TestEventsExecDie(t *testing.T) {

 func TestEventsBackwardsCompatible(t *testing.T) {

 	skip.If(t, testEnv.DaemonInfo.OSType == "windows", "Windows doesn't support back-compat messages")

 	ctx := setupTest(t)

-	client := testEnv.APIClient()

+	apiClient := testEnv.APIClient()

-	since := request.DaemonTime(ctx, t, client, testEnv)

+	since := request.DaemonTime(ctx, t, apiClient, testEnv)

 	ts := strconv.FormatInt(since.Unix(), 10)

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

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

 	// In case there is no events, the API should have responded immediately (not blocking),

 	// The test here makes sure the response time is less than 3 sec.

@@ -125,9 +125,9 @@ func TestEventsVolumeCreate(t *testing.T) {

 	ctx, cancel := context.WithCancel(ctx)

 	defer cancel()

-	client := testEnv.APIClient()

+	apiClient := testEnv.APIClient()

-	since := request.DaemonUnixTime(ctx, t, client, testEnv)

+	since := request.DaemonUnixTime(ctx, t, apiClient, testEnv)

 	volName := t.Name()

 	getEvents := func(messages <-chan events.Message, errs <-chan error) ([]events.Message, error) {

 		var evts []events.Message

@@ -147,7 +147,7 @@ func TestEventsVolumeCreate(t *testing.T) {

 		}

 	}

-	_, err := client.VolumeCreate(ctx, volume.CreateOptions{Name: volName})

+	_, err := apiClient.VolumeCreate(ctx, volume.CreateOptions{Name: volName})

 	assert.NilError(t, err)

 	filter := filters.NewArgs(

@@ -155,9 +155,9 @@ func TestEventsVolumeCreate(t *testing.T) {

 		filters.Arg("event", "create"),

 		filters.Arg("volume", volName),

 	)

-	messages, errs := client.Events(ctx, events.ListOptions{

+	messages, errs := apiClient.Events(ctx, events.ListOptions{

 		Since:   since,

-		Until:   request.DaemonUnixTime(ctx, t, client, testEnv),

+		Until:   request.DaemonUnixTime(ctx, t, apiClient, testEnv),

 		Filters: filter,

 	})

@@ -165,15 +165,15 @@ func TestEventsVolumeCreate(t *testing.T) {

 	assert.NilError(t, err)

 	assert.Equal(t, len(volEvents), 1, "expected volume create event when creating a volume")

-	container.Create(ctx, t, client, container.WithMount(mount.Mount{

+	container.Create(ctx, t, apiClient, container.WithMount(mount.Mount{

 		Type:   mount.TypeVolume,

 		Source: volName,

 		Target: "/tmp/foo",

 	}))

-	messages, errs = client.Events(ctx, events.ListOptions{

+	messages, errs = apiClient.Events(ctx, events.ListOptions{

 		Since:   since,

-		Until:   request.DaemonUnixTime(ctx, t, client, testEnv),

+		Until:   request.DaemonUnixTime(ctx, t, apiClient, testEnv),

 		Filters: filter,

 	})

@@ -11,9 +11,9 @@ import (

 func TestInfoBinaryCommits(t *testing.T) {

 	ctx := setupTest(t)

-	client := testEnv.APIClient()

+	apiClient := testEnv.APIClient()

-	info, err := client.Info(ctx)

+	info, err := apiClient.Info(ctx)

 	assert.NilError(t, err)

 	assert.Check(t, "N/A" != info.ContainerdCommit.ID)

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

 func TestInfoAPI(t *testing.T) {

 	ctx := setupTest(t)

-	client := testEnv.APIClient()

+	apiClient := testEnv.APIClient()

-	info, err := client.Info(ctx)

+	info, err := apiClient.Info(ctx)

 	assert.NilError(t, err)

 	// TODO(thaJeztah): make sure we have other tests that run a local daemon and check other fields based on known state.

@@ -17,13 +17,12 @@ func TestLoginFailsWithBadCredentials(t *testing.T) {

 	skip.If(t, !requirement.HasHubConnectivity(t))

 	ctx := setupTest(t)

-	client := testEnv.APIClient()

+	apiClient := testEnv.APIClient()

-	config := registry.AuthConfig{

+	_, err := apiClient.RegistryLogin(ctx, registry.AuthConfig{

 		Username: "no-user",

 		Password: "no-password",

-	}

-	_, err := client.RegistryLogin(ctx, config)

+	})

 	assert.Assert(t, err != nil)

 	assert.Check(t, is.ErrorContains(err, "unauthorized: incorrect username or password"))

 	assert.Check(t, is.ErrorContains(err, fmt.Sprintf("https://%s/v2/", registrypkg.DefaultRegistryHost)))

@@ -62,34 +62,34 @@ func TestPingSwarmHeader(t *testing.T) {

 	d := daemon.New(t)

 	d.Start(t)

 	defer d.Stop(t)

-	client := d.NewClientT(t)

-	defer client.Close()

+	apiClient := d.NewClientT(t)

+	defer apiClient.Close()

 	t.Run("before swarm init", func(t *testing.T) {

 		ctx := testutil.StartSpan(ctx, t)

-		p, err := client.Ping(ctx)

+		p, err := apiClient.Ping(ctx)

 		assert.NilError(t, err)

 		assert.Equal(t, p.SwarmStatus.NodeState, swarm.LocalNodeStateInactive)

 		assert.Equal(t, p.SwarmStatus.ControlAvailable, false)

 	})

-	_, err := client.SwarmInit(ctx, swarm.InitRequest{ListenAddr: "127.0.0.1", AdvertiseAddr: "127.0.0.1:2377"})

+	_, err := apiClient.SwarmInit(ctx, swarm.InitRequest{ListenAddr: "127.0.0.1", AdvertiseAddr: "127.0.0.1:2377"})

 	assert.NilError(t, err)

 	t.Run("after swarm init", func(t *testing.T) {

 		ctx := testutil.StartSpan(ctx, t)

-		p, err := client.Ping(ctx)

+		p, err := apiClient.Ping(ctx)

 		assert.NilError(t, err)

 		assert.Equal(t, p.SwarmStatus.NodeState, swarm.LocalNodeStateActive)

 		assert.Equal(t, p.SwarmStatus.ControlAvailable, true)

 	})

-	err = client.SwarmLeave(ctx, true)

+	err = apiClient.SwarmLeave(ctx, true)

 	assert.NilError(t, err)

 	t.Run("after swarm leave", func(t *testing.T) {

 		ctx := testutil.StartSpan(ctx, t)

-		p, err := client.Ping(ctx)

+		p, err := apiClient.Ping(ctx)

 		assert.NilError(t, err)

 		assert.Equal(t, p.SwarmStatus.NodeState, swarm.LocalNodeStateInactive)

 		assert.Equal(t, p.SwarmStatus.ControlAvailable, false)

@@ -102,8 +102,8 @@ func TestPingBuilderHeader(t *testing.T) {

 	ctx := setupTest(t)

 	d := daemon.New(t)

-	client := d.NewClientT(t)

-	defer client.Close()

+	apiClient := d.NewClientT(t)

+	defer apiClient.Close()

 	t.Run("default config", func(t *testing.T) {

 		testutil.StartSpan(ctx, t)

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

 			expected = types.BuilderV1

 		}

-		p, err := client.Ping(ctx)

+		p, err := apiClient.Ping(ctx)

 		assert.NilError(t, err)

 		assert.Equal(t, p.BuilderVersion, expected)

 	})

@@ -129,7 +129,7 @@ func TestPingBuilderHeader(t *testing.T) {

 		defer d.Stop(t)

 		expected := types.BuilderV1

-		p, err := client.Ping(ctx)

+		p, err := apiClient.Ping(ctx)

 		assert.NilError(t, err)

 		assert.Equal(t, p.BuilderVersion, expected)

 	})

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

 func TestVersion(t *testing.T) {

 	ctx := setupTest(t)

-	client := testEnv.APIClient()

+	apiClient := testEnv.APIClient()

-	version, err := client.ServerVersion(ctx)

+	version, err := apiClient.ServerVersion(ctx)

 	assert.NilError(t, err)

 	assert.Check(t, version.APIVersion != "")