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

 )

 // CheckpointCreate creates a checkpoint from the given container with the given name

-func (cli *Client) CheckpointCreate(ctx context.Context, container string, options checkpoint.CreateOptions) error {

-	resp, err := cli.post(ctx, "/containers/"+container+"/checkpoints", nil, options, nil)

+func (cli *Client) CheckpointCreate(ctx context.Context, containerID string, options checkpoint.CreateOptions) error {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return err

+	}

+

+	resp, err := cli.post(ctx, "/containers/"+containerID+"/checkpoints", nil, options, nil)

 	ensureReaderClosed(resp)

 	return err

 }

@@ -26,6 +26,14 @@ func TestCheckpointCreateError(t *testing.T) {

 	})

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	err = client.CheckpointCreate(context.Background(), "", checkpoint.CreateOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	err = client.CheckpointCreate(context.Background(), "    ", checkpoint.CreateOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestCheckpointCreate(t *testing.T) {

@@ -36,7 +44,7 @@ func TestCheckpointCreate(t *testing.T) {

 	client := &Client{

 		client: newMockClient(func(req *http.Request) (*http.Response, error) {

 			if !strings.HasPrefix(req.URL.Path, expectedURL) {

-				return nil, fmt.Errorf("Expected URL '%s', got '%s'", expectedURL, req.URL)

+				return nil, fmt.Errorf("expected URL '%s', got '%s'", expectedURL, req.URL)

 			}

 			if req.Method != http.MethodPost {

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

 // CheckpointDelete deletes the checkpoint with the given name from the given container

 func (cli *Client) CheckpointDelete(ctx context.Context, containerID string, options checkpoint.DeleteOptions) error {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return err

+	}

+

 	query := url.Values{}

 	if options.CheckpointDir != "" {

 		query.Set("dir", options.CheckpointDir)

@@ -25,6 +25,14 @@ func TestCheckpointDeleteError(t *testing.T) {

 	})

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	err = client.CheckpointDelete(context.Background(), "", checkpoint.DeleteOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	err = client.CheckpointDelete(context.Background(), "    ", checkpoint.DeleteOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestCheckpointDelete(t *testing.T) {

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

 // ConfigInspectWithRaw returns the config information with raw data

 func (cli *Client) ConfigInspectWithRaw(ctx context.Context, id string) (swarm.Config, []byte, error) {

-	if id == "" {

-		return swarm.Config{}, nil, objectNotFoundError{object: "config", id: id}

+	id, err := trimID("contig", id)

+	if err != nil {

+		return swarm.Config{}, nil, err

 	}

 	if err := cli.NewVersionError(ctx, "1.30", "config inspect"); err != nil {

 		return swarm.Config{}, nil, err

@@ -33,7 +33,12 @@ func TestConfigInspectWithEmptyID(t *testing.T) {

 		}),

 	}

 	_, _, err := client.ConfigInspectWithRaw(context.Background(), "")

-	assert.Check(t, is.ErrorType(err, errdefs.IsNotFound))

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	_, _, err = client.ConfigInspectWithRaw(context.Background(), "    ")

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestConfigInspectUnsupported(t *testing.T) {

@@ -4,6 +4,10 @@ import "context"

 // ConfigRemove removes a config.

 func (cli *Client) ConfigRemove(ctx context.Context, id string) error {

+	id, err := trimID("config", id)

+	if err != nil {

+		return err

+	}

 	if err := cli.NewVersionError(ctx, "1.30", "config remove"); err != nil {

 		return err

 	}

@@ -31,6 +31,14 @@ func TestConfigRemoveError(t *testing.T) {

 	err := client.ConfigRemove(context.Background(), "config_id")

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	err = client.ConfigRemove(context.Background(), "")

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	err = client.ConfigRemove(context.Background(), "    ")

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestConfigRemove(t *testing.T) {

@@ -9,6 +9,10 @@ import (

 // ConfigUpdate attempts to update a config

 func (cli *Client) ConfigUpdate(ctx context.Context, id string, version swarm.Version, config swarm.ConfigSpec) error {

+	id, err := trimID("config", id)

+	if err != nil {

+		return err

+	}

 	if err := cli.NewVersionError(ctx, "1.30", "config update"); err != nil {

 		return err

 	}

@@ -32,6 +32,14 @@ func TestConfigUpdateError(t *testing.T) {

 	err := client.ConfigUpdate(context.Background(), "config_id", swarm.Version{}, swarm.ConfigSpec{})

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	err = client.ConfigUpdate(context.Background(), "", swarm.Version{}, swarm.ConfigSpec{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	err = client.ConfigUpdate(context.Background(), "    ", swarm.Version{}, swarm.ConfigSpec{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestConfigUpdate(t *testing.T) {

@@ -33,7 +33,12 @@ import (

 //

 // You can use github.com/docker/docker/pkg/stdcopy.StdCopy to demultiplex this

 // stream.

-func (cli *Client) ContainerAttach(ctx context.Context, container string, options container.AttachOptions) (types.HijackedResponse, error) {

+func (cli *Client) ContainerAttach(ctx context.Context, containerID string, options container.AttachOptions) (types.HijackedResponse, error) {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return types.HijackedResponse{}, err

+	}

+

 	query := url.Values{}

 	if options.Stream {

 		query.Set("stream", "1")

@@ -54,7 +59,7 @@ func (cli *Client) ContainerAttach(ctx context.Context, container string, option

 		query.Set("logs", "1")

 	}

-	return cli.postHijacked(ctx, "/containers/"+container+"/attach", query, nil, http.Header{

+	return cli.postHijacked(ctx, "/containers/"+containerID+"/attach", query, nil, http.Header{

 		"Content-Type": {"text/plain"},

 	})

 }

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

 )

 // ContainerCommit applies changes to a container and creates a new tagged image.

-func (cli *Client) ContainerCommit(ctx context.Context, container string, options container.CommitOptions) (types.IDResponse, error) {

+func (cli *Client) ContainerCommit(ctx context.Context, containerID string, options container.CommitOptions) (types.IDResponse, error) {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return types.IDResponse{}, err

+	}

+

 	var repository, tag string

 	if options.Reference != "" {

 		ref, err := reference.ParseNormalizedNamed(options.Reference)

@@ -32,7 +37,7 @@ func (cli *Client) ContainerCommit(ctx context.Context, container string, option

 	}

 	query := url.Values{}

-	query.Set("container", container)

+	query.Set("container", containerID)

 	query.Set("repo", repository)

 	query.Set("tag", tag)

 	query.Set("comment", options.Comment)

@@ -23,6 +23,14 @@ func TestContainerCommitError(t *testing.T) {

 	}

 	_, err := client.ContainerCommit(context.Background(), "nothing", container.CommitOptions{})

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	_, err = client.ContainerCommit(context.Background(), "", container.CommitOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	_, err = client.ContainerCommit(context.Background(), "    ", container.CommitOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestContainerCommit(t *testing.T) {

@@ -16,11 +16,15 @@ import (

 // ContainerStatPath returns stat information about a path inside the container filesystem.

 func (cli *Client) ContainerStatPath(ctx context.Context, containerID, path string) (container.PathStat, error) {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return container.PathStat{}, err

+	}

+

 	query := url.Values{}

 	query.Set("path", filepath.ToSlash(path)) // Normalize the paths used in the API.

-	urlStr := "/containers/" + containerID + "/archive"

-	response, err := cli.head(ctx, urlStr, query, nil)

+	response, err := cli.head(ctx, "/containers/"+containerID+"/archive", query, nil)

 	defer ensureReaderClosed(response)

 	if err != nil {

 		return container.PathStat{}, err

@@ -31,6 +35,11 @@ func (cli *Client) ContainerStatPath(ctx context.Context, containerID, path stri

 // CopyToContainer copies content into the container filesystem.

 // Note that `content` must be a Reader for a TAR archive

 func (cli *Client) CopyToContainer(ctx context.Context, containerID, dstPath string, content io.Reader, options container.CopyToContainerOptions) error {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return err

+	}

+

 	query := url.Values{}

 	query.Set("path", filepath.ToSlash(dstPath)) // Normalize the paths used in the API.

 	// Do not allow for an existing directory to be overwritten by a non-directory and vice versa.

@@ -42,9 +51,7 @@ func (cli *Client) CopyToContainer(ctx context.Context, containerID, dstPath str

 		query.Set("copyUIDGID", "true")

 	}

-	apiPath := "/containers/" + containerID + "/archive"

-

-	response, err := cli.putRaw(ctx, apiPath, query, content, nil)

+	response, err := cli.putRaw(ctx, "/containers/"+containerID+"/archive", query, content, nil)

 	defer ensureReaderClosed(response)

 	if err != nil {

 		return err

@@ -56,11 +63,15 @@ func (cli *Client) CopyToContainer(ctx context.Context, containerID, dstPath str

 // CopyFromContainer gets the content from the container and returns it as a Reader

 // for a TAR archive to manipulate it in the host. It's up to the caller to close the reader.

 func (cli *Client) CopyFromContainer(ctx context.Context, containerID, srcPath string) (io.ReadCloser, container.PathStat, error) {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return nil, container.PathStat{}, err

+	}

+

 	query := make(url.Values, 1)

 	query.Set("path", filepath.ToSlash(srcPath)) // Normalize the paths used in the API.

-	apiPath := "/containers/" + containerID + "/archive"

-	response, err := cli.get(ctx, apiPath, query, nil)

+	response, err := cli.get(ctx, "/containers/"+containerID+"/archive", query, nil)

 	if err != nil {

 		return nil, container.PathStat{}, err

 	}

@@ -23,6 +23,14 @@ func TestContainerStatPathError(t *testing.T) {

 	}

 	_, err := client.ContainerStatPath(context.Background(), "container_id", "path")

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	_, err = client.ContainerStatPath(context.Background(), "", "path")

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	_, err = client.ContainerStatPath(context.Background(), "    ", "path")

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestContainerStatPathNotFoundError(t *testing.T) {

@@ -99,6 +107,14 @@ func TestCopyToContainerError(t *testing.T) {

 	}

 	err := client.CopyToContainer(context.Background(), "container_id", "path/to/file", bytes.NewReader([]byte("")), container.CopyToContainerOptions{})

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	err = client.CopyToContainer(context.Background(), "", "path/to/file", bytes.NewReader([]byte("")), container.CopyToContainerOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	err = client.CopyToContainer(context.Background(), "    ", "path/to/file", bytes.NewReader([]byte("")), container.CopyToContainerOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestCopyToContainerNotFoundError(t *testing.T) {

@@ -173,6 +189,14 @@ func TestCopyFromContainerError(t *testing.T) {

 	}

 	_, _, err := client.CopyFromContainer(context.Background(), "container_id", "path/to/file")

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	_, _, err = client.CopyFromContainer(context.Background(), "", "path/to/file")

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	_, _, err = client.CopyFromContainer(context.Background(), "    ", "path/to/file")

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestCopyFromContainerNotFoundError(t *testing.T) {

@@ -10,14 +10,21 @@ import (

 // ContainerDiff shows differences in a container filesystem since it was started.

 func (cli *Client) ContainerDiff(ctx context.Context, containerID string) ([]container.FilesystemChange, error) {

-	var changes []container.FilesystemChange

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return nil, err

+	}

 	serverResp, err := cli.get(ctx, "/containers/"+containerID+"/changes", url.Values{}, nil)

 	defer ensureReaderClosed(serverResp)

 	if err != nil {

-		return changes, err

+		return nil, err

 	}

+	var changes []container.FilesystemChange

 	err = json.NewDecoder(serverResp.body).Decode(&changes)

+	if err != nil {

+		return nil, err

+	}

 	return changes, err

 }

@@ -22,6 +22,14 @@ func TestContainerDiffError(t *testing.T) {

 	}

 	_, err := client.ContainerDiff(context.Background(), "nothing")

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	_, err = client.ContainerDiff(context.Background(), "")

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	_, err = client.ContainerDiff(context.Background(), "    ")

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestContainerDiff(t *testing.T) {

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

 )

 // ContainerExecCreate creates a new exec configuration to run an exec process.

-func (cli *Client) ContainerExecCreate(ctx context.Context, container string, options container.ExecOptions) (types.IDResponse, error) {

-	var response types.IDResponse

+func (cli *Client) ContainerExecCreate(ctx context.Context, containerID string, options container.ExecOptions) (types.IDResponse, error) {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return types.IDResponse{}, err

+	}

 	// Make sure we negotiated (if the client is configured to do so),

 	// as code below contains API-version specific handling of options.

@@ -20,21 +23,23 @@ func (cli *Client) ContainerExecCreate(ctx context.Context, container string, op

 	// Normally, version-negotiation (if enabled) would not happen until

 	// the API request is made.

 	if err := cli.checkVersion(ctx); err != nil {

-		return response, err

+		return types.IDResponse{}, err

 	}

 	if err := cli.NewVersionError(ctx, "1.25", "env"); len(options.Env) != 0 && err != nil {

-		return response, err

+		return types.IDResponse{}, err

 	}

 	if versions.LessThan(cli.ClientVersion(), "1.42") {

 		options.ConsoleSize = nil

 	}

-	resp, err := cli.post(ctx, "/containers/"+container+"/exec", nil, options, nil)

+	resp, err := cli.post(ctx, "/containers/"+containerID+"/exec", nil, options, nil)

 	defer ensureReaderClosed(resp)

 	if err != nil {

-		return response, err

+		return types.IDResponse{}, err

 	}

+

+	var response types.IDResponse

 	err = json.NewDecoder(resp.body).Decode(&response)

 	return response, err

 }

@@ -21,8 +21,17 @@ func TestContainerExecCreateError(t *testing.T) {

 	client := &Client{

 		client: newMockClient(errorMock(http.StatusInternalServerError, "Server error")),

 	}

+

 	_, err := client.ContainerExecCreate(context.Background(), "container_id", container.ExecOptions{})

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	_, err = client.ContainerExecCreate(context.Background(), "", container.ExecOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	_, err = client.ContainerExecCreate(context.Background(), "    ", container.ExecOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 // TestContainerExecCreateConnectionError verifies that connection errors occurring

@@ -33,7 +42,7 @@ func TestContainerExecCreateConnectionError(t *testing.T) {

 	client, err := NewClientWithOpts(WithAPIVersionNegotiation(), WithHost("tcp://no-such-host.invalid"))

 	assert.NilError(t, err)

-	_, err = client.ContainerExecCreate(context.Background(), "", container.ExecOptions{})

+	_, err = client.ContainerExecCreate(context.Background(), "container_id", container.ExecOptions{})

 	assert.Check(t, is.ErrorType(err, IsErrConnectionFailed))

 }

@@ -10,6 +10,11 @@ import (

 // and returns them as an io.ReadCloser. It's up to the caller

 // to close the stream.

 func (cli *Client) ContainerExport(ctx context.Context, containerID string) (io.ReadCloser, error) {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return nil, err

+	}

+

 	serverResp, err := cli.get(ctx, "/containers/"+containerID+"/export", url.Values{}, nil)

 	if err != nil {

 		return nil, err

@@ -20,6 +20,14 @@ func TestContainerExportError(t *testing.T) {

 	}

 	_, err := client.ContainerExport(context.Background(), "nothing")

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	_, err = client.ContainerExport(context.Background(), "")

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	_, err = client.ContainerExport(context.Background(), "    ")

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestContainerExport(t *testing.T) {

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

 // ContainerInspect returns the container information.

 func (cli *Client) ContainerInspect(ctx context.Context, containerID string) (container.InspectResponse, error) {

-	if containerID == "" {

-		return container.InspectResponse{}, objectNotFoundError{object: "container", id: containerID}

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return container.InspectResponse{}, err

 	}

+

 	serverResp, err := cli.get(ctx, "/containers/"+containerID+"/json", nil, nil)

 	defer ensureReaderClosed(serverResp)

 	if err != nil {

@@ -28,9 +30,11 @@ func (cli *Client) ContainerInspect(ctx context.Context, containerID string) (co

 // ContainerInspectWithRaw returns the container information and its raw representation.

 func (cli *Client) ContainerInspectWithRaw(ctx context.Context, containerID string, getSize bool) (container.InspectResponse, []byte, error) {

-	if containerID == "" {

-		return container.InspectResponse{}, nil, objectNotFoundError{object: "container", id: containerID}

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return container.InspectResponse{}, nil, err

 	}

+

 	query := url.Values{}

 	if getSize {

 		query.Set("size", "1")

@@ -24,6 +24,14 @@ func TestContainerInspectError(t *testing.T) {

 	_, err := client.ContainerInspect(context.Background(), "nothing")

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	_, err = client.ContainerInspect(context.Background(), "")

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	_, err = client.ContainerInspect(context.Background(), "    ")

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestContainerInspectContainerNotFound(t *testing.T) {

@@ -42,7 +50,12 @@ func TestContainerInspectWithEmptyID(t *testing.T) {

 		}),

 	}

 	_, _, err := client.ContainerInspectWithRaw(context.Background(), "", true)

-	assert.Check(t, is.ErrorType(err, errdefs.IsNotFound))

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	_, _, err = client.ContainerInspectWithRaw(context.Background(), "    ", true)

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestContainerInspect(t *testing.T) {

@@ -7,6 +7,11 @@ import (

 // ContainerKill terminates the container process but does not remove the container from the docker host.

 func (cli *Client) ContainerKill(ctx context.Context, containerID, signal string) error {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return err

+	}

+

 	query := url.Values{}

 	if signal != "" {

 		query.Set("signal", signal)

@@ -20,6 +20,14 @@ func TestContainerKillError(t *testing.T) {

 	}

 	err := client.ContainerKill(context.Background(), "nothing", "SIGKILL")

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	err = client.ContainerKill(context.Background(), "", "")

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	err = client.ContainerKill(context.Background(), "    ", "")

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestContainerKill(t *testing.T) {

@@ -33,7 +33,12 @@ import (

 //

 // You can use github.com/docker/docker/pkg/stdcopy.StdCopy to demultiplex this

 // stream.

-func (cli *Client) ContainerLogs(ctx context.Context, container string, options container.LogsOptions) (io.ReadCloser, error) {

+func (cli *Client) ContainerLogs(ctx context.Context, containerID string, options container.LogsOptions) (io.ReadCloser, error) {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return nil, err

+	}

+

 	query := url.Values{}

 	if options.ShowStdout {

 		query.Set("stdout", "1")

@@ -72,7 +77,7 @@ func (cli *Client) ContainerLogs(ctx context.Context, container string, options

 	}

 	query.Set("tail", options.Tail)

-	resp, err := cli.get(ctx, "/containers/"+container+"/logs", query, nil)

+	resp, err := cli.get(ctx, "/containers/"+containerID+"/logs", query, nil)

 	if err != nil {

 		return nil, err

 	}

@@ -24,6 +24,14 @@ func TestContainerLogsNotFoundError(t *testing.T) {

 	}

 	_, err := client.ContainerLogs(context.Background(), "container_id", container.LogsOptions{})

 	assert.Check(t, is.ErrorType(err, errdefs.IsNotFound))

+

+	_, err = client.ContainerLogs(context.Background(), "", container.LogsOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	_, err = client.ContainerLogs(context.Background(), "    ", container.LogsOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestContainerLogsError(t *testing.T) {

@@ -4,6 +4,11 @@ import "context"

 // ContainerPause pauses the main process of a given container without terminating it.

 func (cli *Client) ContainerPause(ctx context.Context, containerID string) error {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return err

+	}

+

 	resp, err := cli.post(ctx, "/containers/"+containerID+"/pause", nil, nil, nil)

 	ensureReaderClosed(resp)

 	return err

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

 // ContainerRemove kills and removes a container from the docker host.

 func (cli *Client) ContainerRemove(ctx context.Context, containerID string, options container.RemoveOptions) error {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return err

+	}

+

 	query := url.Values{}

 	if options.RemoveVolumes {

 		query.Set("v", "1")

@@ -21,6 +21,14 @@ func TestContainerRemoveError(t *testing.T) {

 	}

 	err := client.ContainerRemove(context.Background(), "container_id", container.RemoveOptions{})

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	err = client.ContainerRemove(context.Background(), "", container.RemoveOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	err = client.ContainerRemove(context.Background(), "    ", container.RemoveOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestContainerRemoveNotFoundError(t *testing.T) {

@@ -7,6 +7,11 @@ import (

 // ContainerRename changes the name of a given container.

 func (cli *Client) ContainerRename(ctx context.Context, containerID, newContainerName string) error {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return err

+	}

+

 	query := url.Values{}

 	query.Set("name", newContainerName)

 	resp, err := cli.post(ctx, "/containers/"+containerID+"/rename", query, nil, nil)

@@ -20,6 +20,14 @@ func TestContainerRenameError(t *testing.T) {

 	}

 	err := client.ContainerRename(context.Background(), "nothing", "newNothing")

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	err = client.ContainerRename(context.Background(), "", "newNothing")

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	err = client.ContainerRename(context.Background(), "    ", "newNothing")

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestContainerRename(t *testing.T) {

@@ -10,11 +10,19 @@ import (

 // ContainerResize changes the size of the tty for a container.

 func (cli *Client) ContainerResize(ctx context.Context, containerID string, options container.ResizeOptions) error {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return err

+	}

 	return cli.resize(ctx, "/containers/"+containerID, options.Height, options.Width)

 }

 // ContainerExecResize changes the size of the tty for an exec process running inside a container.

 func (cli *Client) ContainerExecResize(ctx context.Context, execID string, options container.ResizeOptions) error {

+	execID, err := trimID("exec", execID)

+	if err != nil {

+		return err

+	}

 	return cli.resize(ctx, "/exec/"+execID, options.Height, options.Width)

 }

@@ -20,6 +20,14 @@ func TestContainerResizeError(t *testing.T) {

 	}

 	err := client.ContainerResize(context.Background(), "container_id", container.ResizeOptions{})

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	err = client.ContainerResize(context.Background(), "", container.ResizeOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	err = client.ContainerResize(context.Background(), "    ", container.ResizeOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestContainerExecResizeError(t *testing.T) {

@@ -13,6 +13,11 @@ import (

 // It makes the daemon wait for the container to be up again for

 // a specific amount of time, given the timeout.

 func (cli *Client) ContainerRestart(ctx context.Context, containerID string, options container.StopOptions) error {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return err

+	}

+

 	query := url.Values{}

 	if options.Timeout != nil {

 		query.Set("t", strconv.Itoa(*options.Timeout))

@@ -21,6 +21,14 @@ func TestContainerRestartError(t *testing.T) {

 	}

 	err := client.ContainerRestart(context.Background(), "nothing", container.StopOptions{})

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	err = client.ContainerRestart(context.Background(), "", container.StopOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	err = client.ContainerRestart(context.Background(), "    ", container.StopOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 // TestContainerRestartConnectionError verifies that connection errors occurring

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

 // ContainerStart sends a request to the docker daemon to start a container.

 func (cli *Client) ContainerStart(ctx context.Context, containerID string, options container.StartOptions) error {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return err

+	}

+

 	query := url.Values{}

 	if len(options.CheckpointID) != 0 {

 		query.Set("checkpoint", options.CheckpointID)

@@ -22,6 +22,14 @@ func TestContainerStartError(t *testing.T) {

 	}

 	err := client.ContainerStart(context.Background(), "nothing", container.StartOptions{})

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	err = client.ContainerStart(context.Background(), "", container.StartOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	err = client.ContainerStart(context.Background(), "    ", container.StartOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestContainerStart(t *testing.T) {

@@ -10,6 +10,11 @@ import (

 // ContainerStats returns near realtime stats for a given container.

 // It's up to the caller to close the io.ReadCloser returned.

 func (cli *Client) ContainerStats(ctx context.Context, containerID string, stream bool) (container.StatsResponseReader, error) {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return container.StatsResponseReader{}, err

+	}

+

 	query := url.Values{}

 	query.Set("stream", "0")

 	if stream {

@@ -30,6 +35,11 @@ func (cli *Client) ContainerStats(ctx context.Context, containerID string, strea

 // ContainerStatsOneShot gets a single stat entry from a container.

 // It differs from `ContainerStats` in that the API should not wait to prime the stats

 func (cli *Client) ContainerStatsOneShot(ctx context.Context, containerID string) (container.StatsResponseReader, error) {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return container.StatsResponseReader{}, err

+	}

+

 	query := url.Values{}

 	query.Set("stream", "0")

 	query.Set("one-shot", "1")

@@ -20,6 +20,14 @@ func TestContainerStatsError(t *testing.T) {

 	}

 	_, err := client.ContainerStats(context.Background(), "nothing", false)

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	_, err = client.ContainerStats(context.Background(), "", false)

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	_, err = client.ContainerStats(context.Background(), "    ", false)

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 func TestContainerStats(t *testing.T) {

@@ -17,6 +17,11 @@ import (

 // otherwise the engine default. A negative timeout value can be specified,

 // meaning no timeout, i.e. no forceful termination is performed.

 func (cli *Client) ContainerStop(ctx context.Context, containerID string, options container.StopOptions) error {

+	containerID, err := trimID("container", containerID)

+	if err != nil {

+		return err

+	}

+

 	query := url.Values{}

 	if options.Timeout != nil {

 		query.Set("t", strconv.Itoa(*options.Timeout))

@@ -19,8 +19,16 @@ func TestContainerStopError(t *testing.T) {

 	client := &Client{

 		client: newMockClient(errorMock(http.StatusInternalServerError, "Server error")),

 	}

-	err := client.ContainerStop(context.Background(), "nothing", container.StopOptions{})

+	err := client.ContainerStop(context.Background(), "container_id", container.StopOptions{})

 	assert.Check(t, is.ErrorType(err, errdefs.IsSystem))

+

+	err = client.ContainerStop(context.Background(), "", container.StopOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

+

+	err = client.ContainerStop(context.Background(), "    ", container.StopOptions{})

+	assert.Check(t, is.ErrorType(err, errdefs.IsInvalidParameter))

+	assert.Check(t, is.ErrorContains(err, "value is empty"))

 }

 // TestContainerStopConnectionError verifies that connection errors occurring

@@ -31,7 +39,7 @@ func TestContainerStopConnectionError(t *testing.T) {

 	client, err := NewClientWithOpts(WithAPIVersionNegotiation(), WithHost("tcp://no-such-host.invalid"))

 	assert.NilError(t, err)