func TestFixedGOROOT(t *testing.T) { if runtime.GOOS == "plan9" { t.Skipf("skipping plan9, it is inconsistent by allowing GOROOT to be updated by Setenv") } // Restore both the real GOROOT environment variable, and runtime's copies: if orig, ok := syscall.Getenv("GOROOT"); ok { defer syscall.Setenv("GOROOT", orig) } else { defer syscall.Unsetenv("GOROOT") } envs := runtime.Envs() oldenvs := append([]string{}, envs...) defer runtime.SetEnvs(oldenvs) // attempt to reuse existing envs backing array. want := runtime.GOROOT() runtime.SetEnvs(append(envs[:0], "GOROOT="+want)) if got := runtime.GOROOT(); got != want { t.Errorf(`initial runtime.GOROOT()=%q, want %q`, got, want) } if err := syscall.Setenv("GOROOT", "/os"); err != nil { t.Fatal(err) } if got := runtime.GOROOT(); got != want { t.Errorf(`after setenv runtime.GOROOT()=%q, want %q`, got, want) } if err := syscall.Unsetenv("GOROOT"); err != nil { t.Fatal(err) } if got := runtime.GOROOT(); got != want { t.Errorf(`after unsetenv runtime.GOROOT()=%q, want %q`, got, want) } }
// Test parsing a environment variables func TestParseEnv(t *testing.T) { syscall.Setenv("BOOL", "") syscall.Setenv("BOOL2", "true") syscall.Setenv("INT", "22") syscall.Setenv("INT64", "0x23") syscall.Setenv("UINT", "24") syscall.Setenv("UINT64", "25") syscall.Setenv("STRING", "hello") syscall.Setenv("FLOAT64", "2718e28") syscall.Setenv("DURATION", "2m") f := NewFlagSet(os.Args[0], ContinueOnError) boolFlag := f.Bool("bool", false, "bool value") bool2Flag := f.Bool("bool2", false, "bool2 value") intFlag := f.Int("int", 0, "int value") int64Flag := f.Int64("int64", 0, "int64 value") uintFlag := f.Uint("uint", 0, "uint value") uint64Flag := f.Uint64("uint64", 0, "uint64 value") stringFlag := f.String("string", "0", "string value") float64Flag := f.Float64("float64", 0, "float64 value") durationFlag := f.Duration("duration", 5*time.Second, "time.Duration value") err := f.ParseEnv(os.Environ()) if err != nil { t.Fatal("expected no error; got ", err) } if *boolFlag != true { t.Error("bool flag should be true, is ", *boolFlag) } if *bool2Flag != true { t.Error("bool2 flag should be true, is ", *bool2Flag) } if *intFlag != 22 { t.Error("int flag should be 22, is ", *intFlag) } if *int64Flag != 0x23 { t.Error("int64 flag should be 0x23, is ", *int64Flag) } if *uintFlag != 24 { t.Error("uint flag should be 24, is ", *uintFlag) } if *uint64Flag != 25 { t.Error("uint64 flag should be 25, is ", *uint64Flag) } if *stringFlag != "hello" { t.Error("string flag should be `hello`, is ", *stringFlag) } if *float64Flag != 2718e28 { t.Error("float64 flag should be 2718e28, is ", *float64Flag) } if *durationFlag != 2*time.Minute { t.Error("duration flag should be 2m, is ", *durationFlag) } }
// Setenv sets the value of the environment variable named by the key. // It returns an error, if any. func Setenv(key, value string) error { err := syscall.Setenv(key, value) if err != nil { return NewSyscallError("setenv", err) } return nil }
func init() { switch path, _ := syscall.Getenv("GOCOVOUT"); path { case "": // No tracing case "-": Default.Tracer = fdwriter(syscall.Stdout) default: // Add the process ID to the filename. // TODO handle PID reuse by checking if file exists. path += "." + itoa(syscall.Getpid()) mode := syscall.O_WRONLY | syscall.O_CREAT | syscall.O_TRUNC fd, err := syscall.Open(path, mode, 0666) if err != nil { msg := "gocov: failed to create log file: " msg += err.Error() + "\n" write(fdwriter(syscall.Stderr), []byte(msg)) syscall.Exit(1) } Default.Tracer = fdwriter(int(fd)) } // Remove GOCOVOUT from environ, to prevent noise from child processes. // TODO Don't do this; append .pid to output filename. syscall.Setenv("GOCOVOUT", "") }
func mount_osxfusefs(fd int, mnt string) error { var err error if err = syscall.Setenv("MOUNT_FUSEFS_CALL_BY_LIB", ""); err != nil { return err } if err = syscall.Setenv("MOUNT_FUSEFS_DAEMON_PATH", "/Library/Filesystems/osxfusefs.fs/Support/mount_osxfusefs"); err != nil { return err } cmd := exec.Command("/Library/Filesystems/osxfusefs.fs/Support/mount_osxfusefs", "-o", "iosize=4096", strconv.Itoa(fd), mnt) /*cmd.SysProcAttr = &syscall.SysProcAttr{ //Setsid: true, Setpgid: true, }*/ out, err := cmd.CombinedOutput() if len(out) > 0 || err != nil { fmt.Errorf("mount_osxfusefs: %q, %v", out, err) } return nil }
func testSetGetenv(t *testing.T, key, value string) { err := syscall.Setenv(key, value) if err != nil { t.Fatalf("Setenv failed to set %q: %v", value, err) } newvalue, found := syscall.Getenv(key) if !found { t.Fatalf("Getenv failed to find %v variable (want value %q)", key, value) } if newvalue != value { t.Fatalf("Getenv(%v) = %q; want %q", key, newvalue, value) } }
func init() { switch path, _ := syscall.Getenv("GOCOVOUT"); path { case "": // No tracing case "-": Default.Tracer = fdwriter(syscall.Stdout) default: mode := syscall.O_WRONLY | syscall.O_CREAT | syscall.O_APPEND fd, err := syscall.Open(path, mode, 0666) if err != nil { msg := "gocov: failed to create log file: " msg += err.Error() + "\n" write(fdwriter(syscall.Stderr), []byte(msg)) syscall.Exit(1) } Default.Tracer = fdwriter(int(fd)) } // Remove GOCOVOUT from environ, to prevent noise from child processes. // TODO Don't do this; append .pid to output filename. syscall.Setenv("GOCOVOUT", "") }
func initTestingZone() { syscall.Setenv("TZ", "America/Los_Angeles") initLocal() }
func Setenv(key, value string) error { return syscall.Setenv(key, value) }
func (genv *GoatEnv) PrependToGoPath() error { gopath, _ := syscall.Getenv("GOPATH") return syscall.Setenv("GOPATH", genv.AbsDepDir()+":"+gopath) }