executable_test.go

Documentation: os

		 1  // Copyright 2016 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package os_test
		 6  
		 7  import (
		 8  	"fmt"
		 9  	"internal/testenv"
		10  	"os"
		11  	osexec "os/exec"
		12  	"path/filepath"
		13  	"runtime"
		14  	"testing"
		15  )
		16  
		17  const executable_EnvVar = "OSTEST_OUTPUT_EXECPATH"
		18  
		19  func TestExecutable(t *testing.T) {
		20  	testenv.MustHaveExec(t)
		21  	ep, err := os.Executable()
		22  	if err != nil {
		23  		t.Fatalf("Executable failed: %v", err)
		24  	}
		25  	// we want fn to be of the form "dir/prog"
		26  	dir := filepath.Dir(filepath.Dir(ep))
		27  	fn, err := filepath.Rel(dir, ep)
		28  	if err != nil {
		29  		t.Fatalf("filepath.Rel: %v", err)
		30  	}
		31  
		32  	cmd := &osexec.Cmd{}
		33  	// make child start with a relative program path
		34  	cmd.Dir = dir
		35  	cmd.Path = fn
		36  	// forge argv[0] for child, so that we can verify we could correctly
		37  	// get real path of the executable without influenced by argv[0].
		38  	cmd.Args = []string{"-", "-test.run=XXXX"}
		39  	if runtime.GOOS == "openbsd" || runtime.GOOS == "aix" {
		40  		// OpenBSD and AIX rely on argv[0]
		41  		cmd.Args[0] = fn
		42  	}
		43  	cmd.Env = append(os.Environ(), fmt.Sprintf("%s=1", executable_EnvVar))
		44  	out, err := cmd.CombinedOutput()
		45  	if err != nil {
		46  		t.Fatalf("exec(self) failed: %v", err)
		47  	}
		48  	outs := string(out)
		49  	if !filepath.IsAbs(outs) {
		50  		t.Fatalf("Child returned %q, want an absolute path", out)
		51  	}
		52  	if !sameFile(outs, ep) {
		53  		t.Fatalf("Child returned %q, not the same file as %q", out, ep)
		54  	}
		55  }
		56  
		57  func sameFile(fn1, fn2 string) bool {
		58  	fi1, err := os.Stat(fn1)
		59  	if err != nil {
		60  		return false
		61  	}
		62  	fi2, err := os.Stat(fn2)
		63  	if err != nil {
		64  		return false
		65  	}
		66  	return os.SameFile(fi1, fi2)
		67  }
		68  
		69  func init() {
		70  	if e := os.Getenv(executable_EnvVar); e != "" {
		71  		// first chdir to another path
		72  		dir := "/"
		73  		if runtime.GOOS == "windows" {
		74  			cwd, err := os.Getwd()
		75  			if err != nil {
		76  				panic(err)
		77  			}
		78  			dir = filepath.VolumeName(cwd)
		79  		}
		80  		os.Chdir(dir)
		81  		if ep, err := os.Executable(); err != nil {
		82  			fmt.Fprint(os.Stderr, "ERROR: ", err)
		83  		} else {
		84  			fmt.Fprint(os.Stderr, ep)
		85  		}
		86  		os.Exit(0)
		87  	}
		88  }
		89  
		90  func TestExecutableDeleted(t *testing.T) {
		91  	testenv.MustHaveExec(t)
		92  	switch runtime.GOOS {
		93  	case "windows", "plan9":
		94  		t.Skipf("%v does not support deleting running binary", runtime.GOOS)
		95  	case "openbsd", "freebsd", "aix":
		96  		t.Skipf("%v does not support reading deleted binary name", runtime.GOOS)
		97  	}
		98  
		99  	dir := t.TempDir()
	 100  
	 101  	src := filepath.Join(dir, "testdel.go")
	 102  	exe := filepath.Join(dir, "testdel.exe")
	 103  
	 104  	err := os.WriteFile(src, []byte(testExecutableDeletion), 0666)
	 105  	if err != nil {
	 106  		t.Fatal(err)
	 107  	}
	 108  
	 109  	out, err := osexec.Command(testenv.GoToolPath(t), "build", "-o", exe, src).CombinedOutput()
	 110  	t.Logf("build output:\n%s", out)
	 111  	if err != nil {
	 112  		t.Fatal(err)
	 113  	}
	 114  
	 115  	out, err = osexec.Command(exe).CombinedOutput()
	 116  	t.Logf("exec output:\n%s", out)
	 117  	if err != nil {
	 118  		t.Fatal(err)
	 119  	}
	 120  }
	 121  
	 122  const testExecutableDeletion = `package main
	 123  
	 124  import (
	 125  	"fmt"
	 126  	"os"
	 127  )
	 128  
	 129  func main() {
	 130  	before, err := os.Executable()
	 131  	if err != nil {
	 132  		fmt.Fprintf(os.Stderr, "failed to read executable name before deletion: %v\n", err)
	 133  		os.Exit(1)
	 134  	}
	 135  
	 136  	err = os.Remove(before)
	 137  	if err != nil {
	 138  		fmt.Fprintf(os.Stderr, "failed to remove executable: %v\n", err)
	 139  		os.Exit(1)
	 140  	}
	 141  
	 142  	after, err := os.Executable()
	 143  	if err != nil {
	 144  		fmt.Fprintf(os.Stderr, "failed to read executable name after deletion: %v\n", err)
	 145  		os.Exit(1)
	 146  	}
	 147  
	 148  	if before != after {
	 149  		fmt.Fprintf(os.Stderr, "before and after do not match: %v != %v\n", before, after)
	 150  		os.Exit(1)
	 151  	}
	 152  }
	 153  `
	 154
View as plain text