rename "image" vars to prevent conflicts with imports

We have many "image" packages, so these vars easily conflict/shadow
imports. Let's rename them (and in some cases use a const) to
prevent that.

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

api/server/router/distribution/distribution_routes.go

@@ -24,10 +24,10 @@ func (s *distributionRouter) getDistributionInfo(ctx context.Context, w http.Res
 
 	w.Header().Set("Content-Type", "application/json")
 
-	image := vars["name"]
+	imgName := vars["name"]
 
 	// TODO why is reference.ParseAnyReference() / reference.ParseNormalizedNamed() not using the reference.ErrTagInvalidFormat (and so on) errors?
-	ref, err := reference.ParseAnyReference(image)
+	ref, err := reference.ParseAnyReference(imgName)
 	if err != nil {
 		return errdefs.InvalidParameter(err)
 	}
@@ -37,7 +37,7 @@ func (s *distributionRouter) getDistributionInfo(ctx context.Context, w http.Res
 			// full image ID
 			return errors.Errorf("no manifest found for full image ID")
 		}
-		return errdefs.InvalidParameter(errors.Errorf("unknown image reference format: %s", image))
+		return errdefs.InvalidParameter(errors.Errorf("unknown image reference format: %s", imgName))
 	}
 
 	// For a search it is not an error if no auth was given. Ignore invalid

api/server/router/image/image_routes.go

@@ -72,9 +72,9 @@ func (ir *imageRouter) postImagesCreate(ctx context.Context, w http.ResponseWrit
 		// Special case: "pull -a" may send an image name with a
 		// trailing :. This is ugly, but let's not break API
 		// compatibility.
-		image := strings.TrimSuffix(img, ":")
+		imgName := strings.TrimSuffix(img, ":")
 
-		ref, err := reference.ParseNormalizedNamed(image)
+		ref, err := reference.ParseNormalizedNamed(imgName)
 		if err != nil {
 			return errdefs.InvalidParameter(err)
 		}

client/distribution_inspect.go

@@ -10,11 +10,11 @@ import (
 )
 
 // DistributionInspect returns the image digest with the full manifest.
-func (cli *Client) DistributionInspect(ctx context.Context, image, encodedRegistryAuth string) (registry.DistributionInspect, error) {
+func (cli *Client) DistributionInspect(ctx context.Context, imageRef, encodedRegistryAuth string) (registry.DistributionInspect, error) {
 	// Contact the registry to retrieve digest and platform information
 	var distributionInspect registry.DistributionInspect
-	if image == "" {
-		return distributionInspect, objectNotFoundError{object: "distribution", id: image}
+	if imageRef == "" {
+		return distributionInspect, objectNotFoundError{object: "distribution", id: imageRef}
 	}
 
 	if err := cli.NewVersionError(ctx, "1.30", "distribution inspect"); err != nil {
@@ -28,7 +28,7 @@ func (cli *Client) DistributionInspect(ctx context.Context, image, encodedRegist
 		}
 	}
 
-	resp, err := cli.get(ctx, "/distribution/"+image+"/json", url.Values{}, headers)
+	resp, err := cli.get(ctx, "/distribution/"+imageRef+"/json", url.Values{}, headers)
 	defer ensureReaderClosed(resp)
 	if err != nil {
 		return distributionInspect, err

daemon/cluster/convert/service_test.go

@@ -109,11 +109,11 @@ func TestServiceConvertToGRPCGenericRuntimePlugin(t *testing.T) {
 }
 
 func TestServiceConvertToGRPCContainerRuntime(t *testing.T) {
-	image := "alpine:latest"
+	const imgName = "alpine:latest"
 	s := swarmtypes.ServiceSpec{
 		TaskTemplate: swarmtypes.TaskSpec{
 			ContainerSpec: &swarmtypes.ContainerSpec{
-				Image: image,
+				Image: imgName,
 			},
 		},
 		Mode: swarmtypes.ServiceMode{
@@ -131,8 +131,8 @@ func TestServiceConvertToGRPCContainerRuntime(t *testing.T) {
 		t.Fatal("expected type swarmapi.TaskSpec_Container")
 	}
 
-	if v.Container.Image != image {
-		t.Fatalf("expected image %s; received %s", image, v.Container.Image)
+	if v.Container.Image != imgName {
+		t.Fatalf("expected image %s; received %s", imgName, v.Container.Image)
 	}
 }
 

integration-cli/docker_api_images_test.go

@@ -132,8 +132,8 @@ func (s *DockerAPISuite) TestAPIImagesSizeCompatibility(c *testing.T) {
 	images, err := apiclient.ImageList(testutil.GetContext(c), types.ImageListOptions{})
 	assert.NilError(c, err)
 	assert.Assert(c, len(images) != 0)
-	for _, image := range images {
-		assert.Assert(c, image.Size != int64(-1))
+	for _, img := range images {
+		assert.Assert(c, img.Size != int64(-1))
 	}
 
 	apiclient, err = client.NewClientWithOpts(client.FromEnv, client.WithVersion("v1.24"))
@@ -143,7 +143,7 @@ func (s *DockerAPISuite) TestAPIImagesSizeCompatibility(c *testing.T) {
 	v124Images, err := apiclient.ImageList(testutil.GetContext(c), types.ImageListOptions{})
 	assert.NilError(c, err)
 	assert.Assert(c, len(v124Images) != 0)
-	for _, image := range v124Images {
-		assert.Assert(c, image.Size != int64(-1))
+	for _, img := range v124Images {
+		assert.Assert(c, img.Size != int64(-1))
 	}
 }

integration-cli/docker_cli_build_test.go

@@ -6044,22 +6044,22 @@ func (s *DockerCLIBuildSuite) TestBuildWindowsEnvCaseInsensitive(c *testing.T) {
 
 // Test case for 29667
 func (s *DockerCLIBuildSuite) TestBuildWorkdirImageCmd(c *testing.T) {
-	image := "testworkdirimagecmd"
-	buildImageSuccessfully(c, image, build.WithDockerfile(`
+	imgName := "testworkdirimagecmd"
+	buildImageSuccessfully(c, imgName, build.WithDockerfile(`
 FROM busybox
 WORKDIR /foo/bar
 `))
-	out := cli.DockerCmd(c, "inspect", "--format", "{{ json .Config.Cmd }}", image).Stdout()
+	out := cli.DockerCmd(c, "inspect", "--format", "{{ json .Config.Cmd }}", imgName).Stdout()
 	assert.Equal(c, strings.TrimSpace(out), `["sh"]`)
 
-	image = "testworkdirlabelimagecmd"
-	buildImageSuccessfully(c, image, build.WithDockerfile(`
+	imgName = "testworkdirlabelimagecmd"
+	buildImageSuccessfully(c, imgName, build.WithDockerfile(`
 FROM busybox
 WORKDIR /foo/bar
 LABEL a=b
 `))
 
-	out = cli.DockerCmd(c, "inspect", "--format", "{{ json .Config.Cmd }}", image).Stdout()
+	out = cli.DockerCmd(c, "inspect", "--format", "{{ json .Config.Cmd }}", imgName).Stdout()
 	assert.Equal(c, strings.TrimSpace(out), `["sh"]`)
 }
 

integration-cli/docker_cli_create_test.go

@@ -195,12 +195,12 @@ func (s *DockerCLICreateSuite) TestCreateLabelFromImage(c *testing.T) {
 }
 
 func (s *DockerCLICreateSuite) TestCreateHostnameWithNumber(c *testing.T) {
-	image := "busybox"
+	imgName := "busybox"
 	// Busybox on Windows does not implement hostname command
 	if testEnv.DaemonInfo.OSType == "windows" {
-		image = testEnv.PlatformDefaults.BaseImage
+		imgName = testEnv.PlatformDefaults.BaseImage
 	}
-	out := cli.DockerCmd(c, "run", "-h", "web.0", image, "hostname").Combined()
+	out := cli.DockerCmd(c, "run", "-h", "web.0", imgName, "hostname").Combined()
 	assert.Equal(c, strings.TrimSpace(out), "web.0", "hostname not set, expected `web.0`, got: %s", out)
 }
 

integration-cli/docker_cli_events_test.go

@@ -67,9 +67,9 @@ func (s *DockerCLIEventSuite) TestEventsTimestampFormats(c *testing.T) {
 }
 
 func (s *DockerCLIEventSuite) TestEventsUntag(c *testing.T) {
-	image := "busybox"
-	cli.DockerCmd(c, "tag", image, "utest:tag1")
-	cli.DockerCmd(c, "tag", image, "utest:tag2")
+	const imgName = "busybox"
+	cli.DockerCmd(c, "tag", imgName, "utest:tag1")
+	cli.DockerCmd(c, "tag", imgName, "utest:tag2")
 	cli.DockerCmd(c, "rmi", "utest:tag1")
 	cli.DockerCmd(c, "rmi", "utest:tag2")
 
@@ -143,8 +143,8 @@ func (s *DockerCLIEventSuite) TestEventsContainerEventsSinceUnixEpoch(c *testing
 func (s *DockerCLIEventSuite) TestEventsImageTag(c *testing.T) {
 	time.Sleep(1 * time.Second) // because API has seconds granularity
 	since := daemonUnixTime(c)
-	image := "testimageevents:tag"
-	cli.DockerCmd(c, "tag", "busybox", image)
+	const imgName = "testimageevents:tag"
+	cli.DockerCmd(c, "tag", "busybox", imgName)
 
 	out := cli.DockerCmd(c, "events", "--since", since, "--until", daemonUnixTime(c)).Stdout()
 
@@ -153,7 +153,7 @@ func (s *DockerCLIEventSuite) TestEventsImageTag(c *testing.T) {
 	event := strings.TrimSpace(events[0])
 
 	matches := eventstestutils.ScanMap(event)
-	assert.Assert(c, matchEventID(matches, image), "matches: %v\nout:\n%s", matches, out)
+	assert.Assert(c, matchEventID(matches, imgName), "matches: %v\nout:\n%s", matches, out)
 	assert.Equal(c, matches["action"], "tag")
 }
 

integration-cli/docker_cli_images_test.go

@@ -227,8 +227,8 @@ func (s *DockerCLIImagesSuite) TestImagesFilterSpaceTrimCase(c *testing.T) {
 		if idx < 4 && !reflect.DeepEqual(listing, imageListings[idx+1]) {
 			for idx, errListing := range imageListings {
 				fmt.Printf("out %d\n", idx)
-				for _, image := range errListing {
-					fmt.Print(image)
+				for _, img := range errListing {
+					fmt.Print(img)
 				}
 				fmt.Print("")
 			}

integration-cli/docker_cli_import_test.go

@@ -40,8 +40,8 @@ func (s *DockerCLIImportSuite) TestImportDisplay(c *testing.T) {
 
 	assert.Assert(c, strings.Count(out, "\n") == 1, "display is expected 1 '\\n' but didn't")
 
-	image := strings.TrimSpace(out)
-	out = cli.DockerCmd(c, "run", "--rm", image, "true").Combined()
+	imgRef := strings.TrimSpace(out)
+	out = cli.DockerCmd(c, "run", "--rm", imgRef, "true").Combined()
 	assert.Equal(c, out, "", "command output should've been nothing.")
 }
 
@@ -71,9 +71,9 @@ func (s *DockerCLIImportSuite) TestImportFile(c *testing.T) {
 
 	out := cli.DockerCmd(c, "import", temporaryFile.Name()).Combined()
 	assert.Assert(c, strings.Count(out, "\n") == 1, "display is expected 1 '\\n' but didn't")
-	image := strings.TrimSpace(out)
+	imgRef := strings.TrimSpace(out)
 
-	out = cli.DockerCmd(c, "run", "--rm", image, "true").Combined()
+	out = cli.DockerCmd(c, "run", "--rm", imgRef, "true").Combined()
 	assert.Equal(c, out, "", "command output should've been nothing.")
 }
 
@@ -94,9 +94,9 @@ func (s *DockerCLIImportSuite) TestImportGzipped(c *testing.T) {
 	temporaryFile.Close()
 	out := cli.DockerCmd(c, "import", temporaryFile.Name()).Combined()
 	assert.Assert(c, strings.Count(out, "\n") == 1, "display is expected 1 '\\n' but didn't")
-	image := strings.TrimSpace(out)
+	imgRef := strings.TrimSpace(out)
 
-	out = cli.DockerCmd(c, "run", "--rm", image, "true").Combined()
+	out = cli.DockerCmd(c, "run", "--rm", imgRef, "true").Combined()
 	assert.Equal(c, out, "", "command output should've been nothing.")
 }
 
@@ -116,9 +116,9 @@ func (s *DockerCLIImportSuite) TestImportFileWithMessage(c *testing.T) {
 	message := "Testing commit message"
 	out := cli.DockerCmd(c, "import", "-m", message, temporaryFile.Name()).Combined()
 	assert.Assert(c, strings.Count(out, "\n") == 1, "display is expected 1 '\\n' but didn't")
-	image := strings.TrimSpace(out)
+	imgRef := strings.TrimSpace(out)
 
-	out = cli.DockerCmd(c, "history", image).Combined()
+	out = cli.DockerCmd(c, "history", imgRef).Combined()
 	split := strings.Split(out, "\n")
 
 	assert.Equal(c, len(split), 3, "expected 3 lines from image history")
@@ -127,7 +127,7 @@ func (s *DockerCLIImportSuite) TestImportFileWithMessage(c *testing.T) {
 
 	assert.Equal(c, message, split[3], "didn't get expected value in commit message")
 
-	out = cli.DockerCmd(c, "run", "--rm", image, "true").Combined()
+	out = cli.DockerCmd(c, "run", "--rm", imgRef, "true").Combined()
 	assert.Equal(c, out, "", "command output should've been nothing")
 }
 
@@ -147,8 +147,8 @@ func (s *DockerCLIImportSuite) TestImportWithQuotedChanges(c *testing.T) {
 	cli.Docker(cli.Args("export", "test-import"), cli.WithStdout(bufio.NewWriter(temporaryFile))).Assert(c, icmd.Success)
 
 	result := cli.DockerCmd(c, "import", "-c", `ENTRYPOINT ["/bin/sh", "-c"]`, temporaryFile.Name())
-	image := strings.TrimSpace(result.Stdout())
+	imgRef := strings.TrimSpace(result.Stdout())
 
-	result = cli.DockerCmd(c, "run", "--rm", image, "true")
+	result = cli.DockerCmd(c, "run", "--rm", imgRef, "true")
 	result.Assert(c, icmd.Expected{Out: icmd.None})
 }

integration-cli/docker_cli_rmi_test.go

@@ -179,17 +179,17 @@ func (s *DockerCLIRmiSuite) TestRmiTagWithExistingContainers(c *testing.T) {
 }
 
 func (s *DockerCLIRmiSuite) TestRmiForceWithExistingContainers(c *testing.T) {
-	image := "busybox-clone"
+	const imgName = "busybox-clone"
 
 	icmd.RunCmd(icmd.Cmd{
-		Command: []string{dockerBinary, "build", "--no-cache", "-t", image, "-"},
+		Command: []string{dockerBinary, "build", "--no-cache", "-t", imgName, "-"},
 		Stdin: strings.NewReader(`FROM busybox
 MAINTAINER foo`),
 	}).Assert(c, icmd.Success)
 
-	cli.DockerCmd(c, "run", "--name", "test-force-rmi", image, "/bin/true")
+	cli.DockerCmd(c, "run", "--name", "test-force-rmi", imgName, "/bin/true")
 
-	cli.DockerCmd(c, "rmi", "-f", image)
+	cli.DockerCmd(c, "rmi", "-f", imgName)
 }
 
 func (s *DockerCLIRmiSuite) TestRmiWithMultipleRepositories(c *testing.T) {
@@ -260,7 +260,7 @@ func (s *DockerCLIRmiSuite) TestRmiContainerImageNotFound(c *testing.T) {
 
 // #13422
 func (s *DockerCLIRmiSuite) TestRmiUntagHistoryLayer(c *testing.T) {
-	image := "tmp1"
+	const imgName = "tmp1"
 	// Build an image for testing.
 	dockerfile := `FROM busybox
 MAINTAINER foo
@@ -268,8 +268,8 @@ RUN echo 0 #layer0
 RUN echo 1 #layer1
 RUN echo 2 #layer2
 `
-	buildImageSuccessfully(c, image, build.WithoutCache, build.WithDockerfile(dockerfile))
-	out := cli.DockerCmd(c, "history", "-q", image).Stdout()
+	buildImageSuccessfully(c, imgName, build.WithoutCache, build.WithDockerfile(dockerfile))
+	out := cli.DockerCmd(c, "history", "-q", imgName).Stdout()
 	ids := strings.Split(out, "\n")
 	idToTag := ids[2]
 
@@ -277,7 +277,7 @@ RUN echo 2 #layer2
 	newTag := "tmp2"
 	cli.DockerCmd(c, "tag", idToTag, newTag)
 	// Create a container based on "tmp1".
-	cli.DockerCmd(c, "run", "-d", image, "true")
+	cli.DockerCmd(c, "run", "-d", imgName, "true")
 
 	// See if the "tmp2" can be untagged.
 	out = cli.DockerCmd(c, "rmi", newTag).Combined()

integration-cli/docker_cli_run_test.go

@@ -145,19 +145,19 @@ func (s *DockerCLIRunSuite) TestRunDetachedContainerIDPrinting(c *testing.T) {
 // the working directory should be set correctly
 func (s *DockerCLIRunSuite) TestRunWorkingDirectory(c *testing.T) {
 	dir := "/root"
-	image := "busybox"
+	const imgName = "busybox"
 	if testEnv.DaemonInfo.OSType == "windows" {
 		dir = `C:/Windows`
 	}
 
 	// First with -w
-	out := cli.DockerCmd(c, "run", "-w", dir, image, "pwd").Stdout()
+	out := cli.DockerCmd(c, "run", "-w", dir, imgName, "pwd").Stdout()
 	if strings.TrimSpace(out) != dir {
 		c.Errorf("-w failed to set working directory")
 	}
 
 	// Then with --workdir
-	out = cli.DockerCmd(c, "run", "--workdir", dir, image, "pwd").Stdout()
+	out = cli.DockerCmd(c, "run", "--workdir", dir, imgName, "pwd").Stdout()
 	if strings.TrimSpace(out) != dir {
 		c.Errorf("--workdir failed to set working directory")
 	}
@@ -166,14 +166,14 @@ func (s *DockerCLIRunSuite) TestRunWorkingDirectory(c *testing.T) {
 // pinging Google's DNS resolver should fail when we disable the networking
 func (s *DockerCLIRunSuite) TestRunWithoutNetworking(c *testing.T) {
 	count := "-c"
-	image := "busybox"
+	imgName := "busybox"
 	if testEnv.DaemonInfo.OSType == "windows" {
 		count = "-n"
-		image = testEnv.PlatformDefaults.BaseImage
+		imgName = testEnv.PlatformDefaults.BaseImage
 	}
 
 	// First using the long form --net
-	out, exitCode, err := dockerCmdWithError("run", "--net=none", image, "ping", count, "1", "8.8.8.8")
+	out, exitCode, err := dockerCmdWithError("run", "--net=none", imgName, "ping", count, "1", "8.8.8.8")
 	if err != nil && exitCode != 1 {
 		c.Fatal(out, err)
 	}
@@ -623,18 +623,18 @@ func (s *DockerCLIRunSuite) TestRunCreateVolumeWithSymlink(c *testing.T) {
 	testRequires(c, DaemonIsLinux)
 	workingDirectory, err := os.MkdirTemp("", "TestRunCreateVolumeWithSymlink")
 	assert.NilError(c, err)
-	image := "docker-test-createvolumewithsymlink"
+	const imgName = "docker-test-createvolumewithsymlink"
 
-	buildCmd := exec.Command(dockerBinary, "build", "-t", image, "-")
+	buildCmd := exec.Command(dockerBinary, "build", "-t", imgName, "-")
 	buildCmd.Stdin = strings.NewReader(`FROM busybox
 		RUN ln -s home /bar`)
 	buildCmd.Dir = workingDirectory
 	err = buildCmd.Run()
 	if err != nil {
-		c.Fatalf("could not build '%s': %v", image, err)
+		c.Fatalf("could not build '%s': %v", imgName, err)
 	}
 
-	_, exitCode, err := dockerCmdWithError("run", "-v", "/bar/foo", "--name", "test-createvolumewithsymlink", image, "sh", "-c", "mount | grep -q /home/foo")
+	_, exitCode, err := dockerCmdWithError("run", "-v", "/bar/foo", "--name", "test-createvolumewithsymlink", imgName, "sh", "-c", "mount | grep -q /home/foo")
 	if err != nil || exitCode != 0 {
 		c.Fatalf("[run] err: %v, exitcode: %d", err, exitCode)
 	}
@@ -1934,9 +1934,9 @@ func (s *DockerCLIRunSuite) TestRunCidFileCleanupIfEmpty(c *testing.T) {
 	tmpCidFile := path.Join(tmpDir, "cid")
 
 	// This must be an image that has no CMD or ENTRYPOINT set
-	image := loadSpecialImage(c, specialimage.EmptyFS)
+	imgRef := loadSpecialImage(c, specialimage.EmptyFS)
 
-	out, _, err := dockerCmdWithError("run", "--cidfile", tmpCidFile, image)
+	out, _, err := dockerCmdWithError("run", "--cidfile", tmpCidFile, imgRef)
 	if err == nil {
 		c.Fatalf("Run without command must fail. out=%s", out)
 	} else if !strings.Contains(out, "no command specified") {

integration-cli/docker_cli_swarm_unix_test.go

@@ -65,7 +65,7 @@ func (s *DockerSwarmSuite) TestSwarmNetworkPluginV2(c *testing.T) {
 	d2 := s.AddDaemon(ctx, c, true, false)
 
 	// install plugin on d1 and d2
-	pluginName := "aragunathan/global-net-plugin:latest"
+	const pluginName = "aragunathan/global-net-plugin:latest"
 
 	_, err := d1.Cmd("plugin", "install", pluginName, "--grant-all-permissions")
 	assert.NilError(c, err)
@@ -74,12 +74,12 @@ func (s *DockerSwarmSuite) TestSwarmNetworkPluginV2(c *testing.T) {
 	assert.NilError(c, err)
 
 	// create network
-	networkName := "globalnet"
+	const networkName = "globalnet"
 	_, err = d1.Cmd("network", "create", "--driver", pluginName, networkName)
 	assert.NilError(c, err)
 
 	// create a global service to ensure that both nodes will have an instance
-	serviceName := "my-service"
+	const serviceName = "my-service"
 	_, err = d1.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", serviceName, "--mode=global", "--network", networkName, "busybox", "top")
 	assert.NilError(c, err)
 
@@ -100,10 +100,10 @@ func (s *DockerSwarmSuite) TestSwarmNetworkPluginV2(c *testing.T) {
 
 	time.Sleep(20 * time.Second)
 
-	image := "busybox:latest"
+	const imgName = "busybox:latest"
 	// create a new global service again.
-	_, err = d1.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", serviceName, "--mode=global", "--network", networkName, image, "top")
+	_, err = d1.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", serviceName, "--mode=global", "--network", networkName, imgName, "top")
 	assert.NilError(c, err)
 
-	poll.WaitOn(c, pollCheck(c, d1.CheckRunningTaskImages(ctx), checker.DeepEquals(map[string]int{image: 1})), poll.WithTimeout(defaultReconciliationTimeout))
+	poll.WaitOn(c, pollCheck(c, d1.CheckRunningTaskImages(ctx), checker.DeepEquals(map[string]int{imgName: 1})), poll.WithTimeout(defaultReconciliationTimeout))
 }

integration-cli/docker_cli_volume_test.go

@@ -469,13 +469,13 @@ func (s *DockerCLIVolumeSuite) TestVolumeCliInspectWithVolumeOpts(c *testing.T)
 func (s *DockerCLIVolumeSuite) TestDuplicateMountpointsForVolumesFrom(c *testing.T) {
 	testRequires(c, DaemonIsLinux)
 
-	const image = "vimage"
-	buildImageSuccessfully(c, image, build.WithDockerfile(`
+	const imgName = "vimage"
+	buildImageSuccessfully(c, imgName, build.WithDockerfile(`
 		FROM busybox
 		VOLUME ["/tmp/data"]`))
 
-	cli.DockerCmd(c, "run", "--name=data1", image, "true")
-	cli.DockerCmd(c, "run", "--name=data2", image, "true")
+	cli.DockerCmd(c, "run", "--name=data1", imgName, "true")
+	cli.DockerCmd(c, "run", "--name=data2", imgName, "true")
 
 	data1 := cli.DockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "data1").Stdout()
 	data1 = strings.TrimSpace(data1)
@@ -510,13 +510,13 @@ func (s *DockerCLIVolumeSuite) TestDuplicateMountpointsForVolumesFrom(c *testing
 func (s *DockerCLIVolumeSuite) TestDuplicateMountpointsForVolumesFromAndBind(c *testing.T) {
 	testRequires(c, DaemonIsLinux)
 
-	const image = "vimage"
-	buildImageSuccessfully(c, image, build.WithDockerfile(`
+	const imgName = "vimage"
+	buildImageSuccessfully(c, imgName, build.WithDockerfile(`
                 FROM busybox
                 VOLUME ["/tmp/data"]`))
 
-	cli.DockerCmd(c, "run", "--name=data1", image, "true")
-	cli.DockerCmd(c, "run", "--name=data2", image, "true")
+	cli.DockerCmd(c, "run", "--name=data1", imgName, "true")
+	cli.DockerCmd(c, "run", "--name=data2", imgName, "true")
 
 	data1 := cli.DockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "data1").Stdout()
 	data1 = strings.TrimSpace(data1)
@@ -552,13 +552,13 @@ func (s *DockerCLIVolumeSuite) TestDuplicateMountpointsForVolumesFromAndBind(c *
 func (s *DockerCLIVolumeSuite) TestDuplicateMountpointsForVolumesFromAndMounts(c *testing.T) {
 	testRequires(c, testEnv.IsLocalDaemon, DaemonIsLinux)
 
-	const image = "vimage"
-	buildImageSuccessfully(c, image, build.WithDockerfile(`
+	const imgName = "vimage"
+	buildImageSuccessfully(c, imgName, build.WithDockerfile(`
                 FROM busybox
                 VOLUME ["/tmp/data"]`))
 
-	cli.DockerCmd(c, "run", "--name=data1", image, "true")
-	cli.DockerCmd(c, "run", "--name=data2", image, "true")
+	cli.DockerCmd(c, "run", "--name=data1", imgName, "true")
+	cli.DockerCmd(c, "run", "--name=data2", imgName, "true")
 
 	data1 := cli.DockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "data1").Stdout()
 	data1 = strings.TrimSpace(data1)

integration/build/build_test.go

@@ -219,15 +219,15 @@ func TestBuildMultiStageParentConfig(t *testing.T) {
 	resp.Body.Close()
 	assert.NilError(t, err)
 
-	image, _, err := apiclient.ImageInspectWithRaw(ctx, imgName)
+	img, _, err := apiclient.ImageInspectWithRaw(ctx, imgName)
 	assert.NilError(t, err)
 
 	expected := "/foo/sub2"
 	if testEnv.DaemonInfo.OSType == "windows" {
 		expected = `C:\foo\sub2`
 	}
-	assert.Check(t, is.Equal(expected, image.Config.WorkingDir))
-	assert.Check(t, is.Contains(image.Config.Env, "WHO=parent"))
+	assert.Check(t, is.Equal(expected, img.Config.WorkingDir))
+	assert.Check(t, is.Contains(img.Config.Env, "WHO=parent"))
 }
 
 // Test cases in #36996
@@ -268,12 +268,12 @@ func TestBuildLabelWithTargets(t *testing.T) {
 	resp.Body.Close()
 	assert.NilError(t, err)
 
-	image, _, err := apiclient.ImageInspectWithRaw(ctx, imgName)
+	img, _, err := apiclient.ImageInspectWithRaw(ctx, imgName)
 	assert.NilError(t, err)
 
 	testLabels["label-a"] = "inline-a"
 	for k, v := range testLabels {
-		x, ok := image.Config.Labels[k]
+		x, ok := img.Config.Labels[k]
 		assert.Assert(t, ok)
 		assert.Assert(t, x == v)
 	}
@@ -295,12 +295,12 @@ func TestBuildLabelWithTargets(t *testing.T) {
 	resp.Body.Close()
 	assert.NilError(t, err)
 
-	image, _, err = apiclient.ImageInspectWithRaw(ctx, imgName)
+	img, _, err = apiclient.ImageInspectWithRaw(ctx, imgName)
 	assert.NilError(t, err)
 
 	testLabels["label-b"] = "inline-b"
 	for k, v := range testLabels {
-		x, ok := image.Config.Labels[k]
+		x, ok := img.Config.Labels[k]
 		assert.Assert(t, ok)
 		assert.Assert(t, x == v)
 	}
@@ -376,9 +376,9 @@ RUN cat somefile`
 	assert.NilError(t, err)
 	assert.Assert(t, is.Equal(3, len(imageIDs)))
 
-	image, _, err := apiclient.ImageInspectWithRaw(ctx, imageIDs[2])
+	img, _, err := apiclient.ImageInspectWithRaw(ctx, imageIDs[2])
 	assert.NilError(t, err)
-	assert.Check(t, is.Contains(image.Config.Env, "bar=baz"))
+	assert.Check(t, is.Contains(img.Config.Env, "bar=baz"))
 }
 
 // #35403 #36122

integration/image/remove_unix_test.go

@@ -58,7 +58,7 @@ func TestRemoveImageGarbageCollector(t *testing.T) {
 		LayerStore: layerStore,
 	})
 
-	img := "test-garbage-collector"
+	const imgName = "test-garbage-collector"
 
 	// Build a image with multiple layers
 	dockerfile := `FROM busybox
@@ -70,13 +70,13 @@ func TestRemoveImageGarbageCollector(t *testing.T) {
 		types.ImageBuildOptions{
 			Remove:      true,
 			ForceRemove: true,
-			Tags:        []string{img},
+			Tags:        []string{imgName},
 		})
 	assert.NilError(t, err)
 	_, err = io.Copy(io.Discard, resp.Body)
 	resp.Body.Close()
 	assert.NilError(t, err)
-	image, _, err := client.ImageInspectWithRaw(ctx, img)
+	image, _, err := client.ImageInspectWithRaw(ctx, imgName)
 	assert.NilError(t, err)
 
 	// Mark latest image layer to immutable
@@ -90,7 +90,7 @@ func TestRemoveImageGarbageCollector(t *testing.T) {
 
 	// Try to remove the image, it should generate error
 	// but marking layer back to mutable before checking errors (so we don't break CI server)
-	_, err = client.ImageRemove(ctx, img, types.ImageRemoveOptions{})
+	_, err = client.ImageRemove(ctx, imgName, types.ImageRemoveOptions{})
 	attr = 0x00000000
 	argp = uintptr(unsafe.Pointer(&attr))
 	_, _, errno = syscall.Syscall(syscall.SYS_IOCTL, file.Fd(), fsflags, argp)

runconfig/config_test.go

@@ -23,18 +23,18 @@ type f struct {
 func TestDecodeContainerConfig(t *testing.T) {
 	var (
 		fixtures []f
-		image    string
+		imgName  string
 	)
 
 	if runtime.GOOS != "windows" {
-		image = "ubuntu"
+		imgName = "ubuntu"
 		fixtures = []f{
 			{"fixtures/unix/container_config_1_14.json", strslice.StrSlice{}},
 			{"fixtures/unix/container_config_1_17.json", strslice.StrSlice{"bash"}},
 			{"fixtures/unix/container_config_1_19.json", strslice.StrSlice{"bash"}},
 		}
 	} else {
-		image = "windows"
+		imgName = "windows"
 		fixtures = []f{
 			{"fixtures/windows/container_config_1_19.json", strslice.StrSlice{"cmd"}},
 		}
@@ -53,8 +53,8 @@ func TestDecodeContainerConfig(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			if c.Image != image {
-				t.Fatalf("Expected %s image, found %s", image, c.Image)
+			if c.Image != imgName {
+				t.Fatalf("Expected %s image, found %s", imgName, c.Image)
 			}
 
 			if len(c.Entrypoint) != len(f.entrypoint) {

testutil/environment/clean.go

@@ -100,13 +100,13 @@ func deleteAllImages(ctx context.Context, t testing.TB, apiclient client.ImageAP
 	images, err := apiclient.ImageList(ctx, types.ImageListOptions{})
 	assert.Check(t, err, "failed to list images")
 
-	for _, image := range images {
-		tags := tagsFromImageSummary(image)
-		if _, ok := protectedImages[image.ID]; ok {
+	for _, img := range images {
+		tags := tagsFromImageSummary(img)
+		if _, ok := protectedImages[img.ID]; ok {
 			continue
 		}
 		if len(tags) == 0 {
-			removeImage(ctx, t, apiclient, image.ID)
+			removeImage(ctx, t, apiclient, img.ID)
 			continue
 		}
 		for _, tag := range tags {

testutil/environment/protect.go

@@ -89,8 +89,8 @@ func getExistingContainers(ctx context.Context, t testing.TB, testEnv *Execution
 // ProtectImage adds the specified image(s) to be protected in case of clean
 func (e *Execution) ProtectImage(t testing.TB, images ...string) {
 	t.Helper()
-	for _, image := range images {
-		e.protectedElements.images[image] = struct{}{}
+	for _, img := range images {
+		e.protectedElements.images[img] = struct{}{}
 	}
 }