all: use exec.Command.String in test logs

There is no need to manually construct a human-friendly string for
a exec.Command. The String method does that for us.

Change-Id: Iff1033478000bade9cbdc079f6143a7690374258
Reviewed-on: https://go-review.googlesource.com/c/go/+/659475
Reviewed-by: Ian Lance Taylor <iant@google.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

diff --git a/src/cmd/cgo/internal/testerrors/errors_test.go b/src/cmd/cgo/internal/testerrors/errors_test.go
index 1a0de6da03d34bcb9b97f772aa73e29e473811fd..80d2c402cec0c2be8f0b8cc0da0cf83d99b234ea 100644 (file)
--- a/src/cmd/cgo/internal/testerrors/errors_test.go
+++ b/src/cmd/cgo/internal/testerrors/errors_test.go
@@ -108,7 +108,7 @@ func sizeofLongDouble(t *testing.T) int {
        cmd := exec.Command(testenv.GoToolPath(t), "run", path("long_double_size.go"))
        out, err := cmd.CombinedOutput()
        if err != nil {
-               t.Fatalf("%#q: %v:\n%s", strings.Join(cmd.Args, " "), err, out)
+               t.Fatalf("%#q: %v:\n%s", cmd, err, out)
        }
 
        i, err := strconv.Atoi(strings.TrimSpace(string(out)))
@@ -162,7 +162,7 @@ func TestToleratesOptimizationFlag(t *testing.T) {
                        cmd.Env = append(os.Environ(), "CGO_CFLAGS="+cflags)
                        out, err := cmd.CombinedOutput()
                        if err != nil {
-                               t.Errorf("%#q: %v:\n%s", strings.Join(cmd.Args, " "), err, out)
+                               t.Errorf("%#q: %v:\n%s", cmd, err, out)
                        }
                })
        }
@@ -176,7 +176,7 @@ func TestMallocCrashesOnNil(t *testing.T) {
        cmd := exec.Command(testenv.GoToolPath(t), "run", path("malloc.go"))
        out, err := cmd.CombinedOutput()
        if err == nil {
-               t.Logf("%#q:\n%s", strings.Join(cmd.Args, " "), out)
+               t.Logf("%#q:\n%s", cmd, out)
                t.Fatalf("succeeded unexpectedly")
        }
 }

diff --git a/src/cmd/cgo/internal/testgodefs/testgodefs_test.go b/src/cmd/cgo/internal/testgodefs/testgodefs_test.go
index 0ee953f57fe6764ed41042c5346d2ff6ef9db6d4..d68fd4fc14a47ed10474ed48217597b6e626a250 100644 (file)
--- a/src/cmd/cgo/internal/testgodefs/testgodefs_test.go
+++ b/src/cmd/cgo/internal/testgodefs/testgodefs_test.go
@@ -60,7 +60,7 @@ func TestGoDefs(t *testing.T) {
 
                out, err := cmd.Output()
                if err != nil {
-                       t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, cmd.Stderr)
+                       t.Fatalf("%#q: %v\n%s", cmd, err, cmd.Stderr)
                }
 
                fn := fp + "_defs.go"
@@ -111,6 +111,6 @@ func TestGoDefs(t *testing.T) {
        cmd.Env = append(os.Environ(), "GOPATH="+gopath)
        cmd.Dir = dir
        if out, err := cmd.CombinedOutput(); err != nil {
-               t.Fatalf("%s [%s]: %v\n%s", strings.Join(cmd.Args, " "), dir, err, out)
+               t.Fatalf("%#q [%s]: %v\n%s", cmd, dir, err, out)
        }
 }

diff --git a/src/cmd/cgo/internal/testplugin/plugin_test.go b/src/cmd/cgo/internal/testplugin/plugin_test.go
index 85dfd31123b5dedd27aa83544caf692bc3805395..a8d4c0ea58efdb6b0c09c9814e00d1a9aad60336 100644 (file)
--- a/src/cmd/cgo/internal/testplugin/plugin_test.go
+++ b/src/cmd/cgo/internal/testplugin/plugin_test.go
@@ -194,10 +194,10 @@ func run(t *testing.T, bin string, args ...string) string {
        out, err := cmd.Output()
        if err != nil {
                if t == nil {
-                       log.Panicf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, cmd.Stderr)
+                       log.Panicf("%#q: %v\n%s", cmd, err, cmd.Stderr)
                } else {
                        t.Helper()
-                       t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, cmd.Stderr)
+                       t.Fatalf("%#q: %v\n%s", cmd, err, cmd.Stderr)
                }
        }
 
@@ -245,7 +245,7 @@ func TestIssue18676(t *testing.T) {
        cmd := exec.CommandContext(ctx, "./issue18676.exe")
        out, err := cmd.CombinedOutput()
        if err != nil {
-               t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, out)
+               t.Fatalf("%#q: %v\n%s", cmd, err, out)
        }
 }
 

diff --git a/src/cmd/cgo/internal/testsanitizers/asan_test.go b/src/cmd/cgo/internal/testsanitizers/asan_test.go
index 19810aafb654b17a4f2e7cfff6b3633f6630f8b4..f7f53da334e72fc812e97d8ad077a609d76401e2 100644 (file)
--- a/src/cmd/cgo/internal/testsanitizers/asan_test.go
+++ b/src/cmd/cgo/internal/testsanitizers/asan_test.go
@@ -71,11 +71,11 @@ func TestASAN(t *testing.T) {
                                                !strings.Contains(out, noSymbolizer) &&
                                                compilerSupportsLocation() {
 
-                                               t.Errorf("%#q exited without expected location of the error\n%s; got failure\n%s", strings.Join(cmd.Args, " "), tc.errorLocation, out)
+                                               t.Errorf("%#q exited without expected location of the error\n%s; got failure\n%s", cmd, tc.errorLocation, out)
                                        }
                                        return
                                }
-                               t.Fatalf("%#q exited without expected memory access error\n%s; got failure\n%s", strings.Join(cmd.Args, " "), tc.memoryAccessError, out)
+                               t.Fatalf("%#q exited without expected memory access error\n%s; got failure\n%s", cmd, tc.memoryAccessError, out)
                        }
                        mustRun(t, cmd)
                })

diff --git a/src/cmd/cgo/internal/testsanitizers/cc_test.go b/src/cmd/cgo/internal/testsanitizers/cc_test.go
index 7233b6a7756b88c78a90983c4fda44c06750fd0a..8052f34f368cedf3135ada37a87c9f88759bc871 100644 (file)
--- a/src/cmd/cgo/internal/testsanitizers/cc_test.go
+++ b/src/cmd/cgo/internal/testsanitizers/cc_test.go
@@ -494,7 +494,7 @@ func (c *config) checkCSanitizer() (skip bool, err error) {
                                bytes.Contains(out, []byte("unsupported"))) {
                        return true, errors.New(string(out))
                }
-               return true, fmt.Errorf("%#q failed: %v\n%s", strings.Join(cmd.Args, " "), err, out)
+               return true, fmt.Errorf("%#q failed: %v\n%s", cmd, err, out)
        }
 
        if c.sanitizer == "fuzzer" {
@@ -504,10 +504,10 @@ func (c *config) checkCSanitizer() (skip bool, err error) {
 
        if out, err := exec.Command(dst).CombinedOutput(); err != nil {
                if os.IsNotExist(err) {
-                       return true, fmt.Errorf("%#q failed to produce executable: %v", strings.Join(cmd.Args, " "), err)
+                       return true, fmt.Errorf("%#q failed to produce executable: %v", cmd, err)
                }
                snippet, _, _ := bytes.Cut(out, []byte("\n"))
-               return true, fmt.Errorf("%#q generated broken executable: %v\n%s", strings.Join(cmd.Args, " "), err, snippet)
+               return true, fmt.Errorf("%#q generated broken executable: %v\n%s", cmd, err, snippet)
        }
 
        return false, nil
@@ -542,13 +542,12 @@ func (c *config) checkRuntime() (skip bool, err error) {
                return false, err
        }
        cmd.Args = append(cmd.Args, "-dM", "-E", "../../../../runtime/cgo/libcgo.h")
-       cmdStr := strings.Join(cmd.Args, " ")
        out, err := cmd.CombinedOutput()
        if err != nil {
-               return false, fmt.Errorf("%#q exited with %v\n%s", cmdStr, err, out)
+               return false, fmt.Errorf("%#q exited with %v\n%s", cmd, err, out)
        }
        if !bytes.Contains(out, []byte("#define CGO_TSAN")) {
-               return true, fmt.Errorf("%#q did not define CGO_TSAN", cmdStr)
+               return true, fmt.Errorf("%#q did not define CGO_TSAN", cmd)
        }
        return false, nil
 }

diff --git a/src/cmd/cgo/internal/testsanitizers/msan_test.go b/src/cmd/cgo/internal/testsanitizers/msan_test.go
index 83d66f6660d7bfdfaf55c83c692bad006db8e753..554cceaff88669e04f345e0af98dda449108c485 100644 (file)
--- a/src/cmd/cgo/internal/testsanitizers/msan_test.go
+++ b/src/cmd/cgo/internal/testsanitizers/msan_test.go
@@ -79,7 +79,7 @@ func TestMSAN(t *testing.T) {
                                if err != nil {
                                        return
                                }
-                               t.Fatalf("%#q exited without error; want MSAN failure\n%s", strings.Join(cmd.Args, " "), out)
+                               t.Fatalf("%#q exited without error; want MSAN failure\n%s", cmd, out)
                        }
                        mustRun(t, cmd)
                })

diff --git a/src/cmd/cgo/internal/testshared/shared_test.go b/src/cmd/cgo/internal/testshared/shared_test.go
index a2214ac5b96d1a815299defc88489370ea3d598c..e92746037614823761ba4be11425481d5a0de01b 100644 (file)
--- a/src/cmd/cgo/internal/testshared/shared_test.go
+++ b/src/cmd/cgo/internal/testshared/shared_test.go
@@ -79,10 +79,10 @@ func goCmd(t *testing.T, args ...string) string {
        if err != nil {
                if t != nil {
                        t.Helper()
-                       t.Fatalf("executing %q failed %v:\n%s\n%s", c, err, stderr, output)
+                       t.Fatalf("executing %#q failed %v:\n%s\n%s", c, err, stderr, output)
                } else {
                        // Panic instead of using log.Fatalf so that deferred cleanup may run in testMain.
-                       log.Panicf("executing %q failed %v:\n%s\n%s", c, err, stderr, output)
+                       log.Panicf("executing %#q failed %v:\n%s\n%s", c, err, stderr, output)
                }
        }
        if testing.Verbose() && t != nil {

diff --git a/src/cmd/cgo/internal/testso/so_test.go b/src/cmd/cgo/internal/testso/so_test.go
index 2be7807f773044ab7f333fb45d5cd7e5bc6168bb..48eb97c8ded27d720d43f0a3c6c9888317a32c51 100644 (file)
--- a/src/cmd/cgo/internal/testso/so_test.go
+++ b/src/cmd/cgo/internal/testso/so_test.go
@@ -52,11 +52,11 @@ func testSO(t *testing.T, dir string) {
        cmd.Env = append(os.Environ(), "GOPATH="+GOPATH)
        out, err := cmd.Output()
        if err != nil {
-               t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, cmd.Stderr)
+               t.Fatalf("%#q: %v\n%s", cmd, err, cmd.Stderr)
        }
        lines := strings.Split(string(out), "\n")
        if len(lines) != 3 || lines[2] != "" {
-               t.Fatalf("Unexpected output from %s:\n%s", strings.Join(cmd.Args, " "), lines)
+               t.Fatalf("Unexpected output from %q:\n%s", cmd, lines)
        }
 
        cc := lines[0]
@@ -90,9 +90,9 @@ func testSO(t *testing.T, dir string) {
        cmd.Env = append(os.Environ(), "GOPATH="+GOPATH)
        out, err = cmd.CombinedOutput()
        if err != nil {
-               t.Fatalf("%s: %s\n%s", strings.Join(cmd.Args, " "), err, out)
+               t.Fatalf("%#q: %s\n%s", cmd, err, out)
        }
-       t.Logf("%s:\n%s", strings.Join(cmd.Args, " "), out)
+       t.Logf("%#q:\n%s", cmd, out)
 
        if runtime.GOOS == "aix" {
                // Shared object must be wrapped by an archive
@@ -100,7 +100,7 @@ func testSO(t *testing.T, dir string) {
                cmd.Dir = modRoot
                out, err = cmd.CombinedOutput()
                if err != nil {
-                       t.Fatalf("%s: %s\n%s", strings.Join(cmd.Args, " "), err, out)
+                       t.Fatalf("%#q: %s\n%s", cmd, err, out)
                }
        }
 
@@ -109,9 +109,9 @@ func testSO(t *testing.T, dir string) {
        cmd.Env = append(os.Environ(), "GOPATH="+GOPATH)
        out, err = cmd.CombinedOutput()
        if err != nil {
-               t.Fatalf("%s: %s\n%s", strings.Join(cmd.Args, " "), err, out)
+               t.Fatalf("%#q: %s\n%s", cmd, err, out)
        }
-       t.Logf("%s:\n%s", strings.Join(cmd.Args, " "), out)
+       t.Logf("%#q:\n%s", cmd, out)
 
        cmd = exec.Command("./main.exe")
        cmd.Dir = modRoot
@@ -131,7 +131,7 @@ func testSO(t *testing.T, dir string) {
        }
        out, err = cmd.CombinedOutput()
        if err != nil {
-               t.Fatalf("%s: %s\n%s", strings.Join(cmd.Args, " "), err, out)
+               t.Fatalf("%#q: %s\n%s", cmd, err, out)
        }
-       t.Logf("%s:\n%s", strings.Join(cmd.Args, " "), out)
+       t.Logf("%#q:\n%s", cmd, out)
 }

diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index a380e46c5dadd4f70ac42ec283e33a7539714c00..e939768a2f480991e0fdb837691ed20bb33a9158 100644 (file)
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -1098,7 +1098,7 @@ func (t *tester) dirCmd(dir string, cmdline ...interface{}) *exec.Cmd {
        cmd.Stdout = os.Stdout
        cmd.Stderr = os.Stderr
        if vflag > 1 {
-               errprintf("%s\n", strings.Join(cmd.Args, " "))
+               errprintf("%#q\n", cmd)
        }
        return cmd
 }
@@ -1450,7 +1450,7 @@ func (t *tester) runPending(nextTest *distTest) {
                        }
                }
                if vflag > 1 {
-                       errprintf("%s\n", strings.Join(w.cmd.Args, " "))
+                       errprintf("%#q\n", w.cmd)
                }
                ended++
                <-w.end

diff --git a/src/cmd/internal/moddeps/moddeps_test.go b/src/cmd/internal/moddeps/moddeps_test.go
index 2def029325be558f9da0998b3ba520ae98326269..0467b0ebbf000cbd31f189653d574abe267d31d7 100644 (file)
--- a/src/cmd/internal/moddeps/moddeps_test.go
+++ b/src/cmd/internal/moddeps/moddeps_test.go
@@ -62,7 +62,7 @@ func TestAllDependencies(t *testing.T) {
                                cmd.Stderr = new(strings.Builder)
                                _, err := cmd.Output()
                                if err != nil {
-                                       t.Errorf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, cmd.Stderr)
+                                       t.Errorf("%#q: %v\n%s", cmd, err, cmd.Stderr)
                                        t.Logf("(Run 'go mod vendor' in %s to ensure that dependencies have been vendored.)", m.Dir)
                                }
                                return
@@ -76,10 +76,10 @@ func TestAllDependencies(t *testing.T) {
                        cmd.Stderr = new(strings.Builder)
                        out, err := cmd.Output()
                        if err != nil {
-                               t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, cmd.Stderr)
+                               t.Fatalf("%#q: %v\n%s", cmd, err, cmd.Stderr)
                        }
                        if strings.TrimSpace(string(out)) != m.Path {
-                               t.Errorf("'%s' reported active modules other than %s:\n%s", strings.Join(cmd.Args, " "), m.Path, out)
+                               t.Errorf("%#q reported active modules other than %s:\n%s", cmd, m.Path, out)
                                t.Logf("(Run 'go mod tidy' in %s to ensure that no extraneous dependencies were added, or 'go mod vendor' to copy in imported packages.)", m.Dir)
                        }
                })

diff --git a/src/os/exec/read3.go b/src/os/exec/read3.go
index 8327d73e514bea7836de9efb303c60686a49c9d3..3ccf1cacc83f2d96b422da7603345fa95952458b 100644 (file)
--- a/src/os/exec/read3.go
+++ b/src/os/exec/read3.go
@@ -20,7 +20,6 @@ import (
        "os/exec"
        "os/exec/internal/fdtest"
        "runtime"
-       "strings"
 )
 
 func main() {
@@ -81,7 +80,7 @@ func main() {
                cmd := exec.Command(ofcmd, args...)
                out, err := cmd.CombinedOutput()
                if err != nil {
-                       fmt.Fprintf(os.Stderr, "%s failed: %v\n", strings.Join(cmd.Args, " "), err)
+                       fmt.Fprintf(os.Stderr, "%#q failed: %v\n", cmd, err)
                }
                fmt.Printf("%s", out)
                os.Exit(1)

diff --git a/src/runtime/testdata/testprog/numcpu_freebsd.go b/src/runtime/testdata/testprog/numcpu_freebsd.go
index 310c21244cfa5436e2a624fcf953aff971ba359c..a51c04a4835316e8fbc637e127db8b3b41cdcb50 100644 (file)
--- a/src/runtime/testdata/testprog/numcpu_freebsd.go
+++ b/src/runtime/testdata/testprog/numcpu_freebsd.go
@@ -45,7 +45,7 @@ func FreeBSDNumCPU() {
        cmd := exec.Command("sysctl", "-n", "kern.smp.active")
        output, err := cmd.CombinedOutput()
        if err != nil {
-               fmt.Printf("fail to launch '%s', error: %s, output: %s\n", strings.Join(cmd.Args, " "), err, output)
+               fmt.Printf("fail to launch %#q, error: %s, output: %s\n", cmd, err, output)
                return
        }
        if !bytes.Equal(output, []byte("1\n")) {
@@ -80,19 +80,18 @@ func getList() ([]string, error) {
 
        // Launch cpuset to print a list of available CPUs: pid <PID> mask: 0, 1, 2, 3.
        cmd := exec.Command("cpuset", "-g", "-p", strconv.Itoa(pid))
-       cmdline := strings.Join(cmd.Args, " ")
        output, err := cmd.CombinedOutput()
        if err != nil {
-               return nil, fmt.Errorf("fail to execute '%s': %s", cmdline, err)
+               return nil, fmt.Errorf("fail to execute %#q: %s", cmd, err)
        }
        output, _, ok := bytes.Cut(output, []byte("\n"))
        if !ok {
-               return nil, fmt.Errorf("invalid output from '%s', '\\n' not found: %s", cmdline, output)
+               return nil, fmt.Errorf("invalid output from %#q, '\\n' not found: %s", cmd, output)
        }
 
        _, cpus, ok := bytes.Cut(output, []byte(":"))
        if !ok {
-               return nil, fmt.Errorf("invalid output from '%s', ':' not found: %s", cmdline, output)
+               return nil, fmt.Errorf("invalid output from %#q, ':' not found: %s", cmd, output)
        }
 
        var list []string
@@ -104,7 +103,7 @@ func getList() ([]string, error) {
                list = append(list, index)
        }
        if len(list) == 0 {
-               return nil, fmt.Errorf("empty CPU list from '%s': %s", cmdline, output)
+               return nil, fmt.Errorf("empty CPU list from %#q: %s", cmd, output)
        }
        return list, nil
 }
@@ -121,17 +120,16 @@ func checkNCPU(list []string) error {
        }
        // Launch FreeBSDNumCPUHelper() with specified CPUs list.
        cmd := exec.Command("cpuset", "-l", cListString, os.Args[0], "FreeBSDNumCPUHelper")
-       cmdline := strings.Join(cmd.Args, " ")
        output, err := cmd.CombinedOutput()
        if err != nil {
-               return fmt.Errorf("fail to launch child '%s', error: %s, output: %s", cmdline, err, output)
+               return fmt.Errorf("fail to launch child %#q, error: %s, output: %s", cmd, err, output)
        }
 
        // NumCPU from FreeBSDNumCPUHelper come with '\n'.
        output = bytes.TrimSpace(output)
        n, err := strconv.Atoi(string(output))
        if err != nil {
-               return fmt.Errorf("fail to parse output from child '%s', error: %s, output: %s", cmdline, err, output)
+               return fmt.Errorf("fail to parse output from child %#q, error: %s, output: %s", cmd, err, output)
        }
        if n != len(list) {
                return fmt.Errorf("runtime.NumCPU() expected to %d, got %d when run with CPU list %s", len(list), n, cListString)