diff options
Diffstat (limited to 'vendor/golang.org/x/sys/unix/syscall_unix_test.go')
-rw-r--r-- | vendor/golang.org/x/sys/unix/syscall_unix_test.go | 213 |
1 files changed, 212 insertions, 1 deletions
diff --git a/vendor/golang.org/x/sys/unix/syscall_unix_test.go b/vendor/golang.org/x/sys/unix/syscall_unix_test.go index 496e471..d694990 100644 --- a/vendor/golang.org/x/sys/unix/syscall_unix_test.go +++ b/vendor/golang.org/x/sys/unix/syscall_unix_test.go @@ -15,6 +15,7 @@ import ( "os/exec" "path/filepath" "runtime" + "syscall" "testing" "time" @@ -59,6 +60,62 @@ func _() { ) } +func TestErrnoSignalName(t *testing.T) { + testErrors := []struct { + num syscall.Errno + name string + }{ + {syscall.EPERM, "EPERM"}, + {syscall.EINVAL, "EINVAL"}, + {syscall.ENOENT, "ENOENT"}, + } + + for _, te := range testErrors { + t.Run(fmt.Sprintf("%d/%s", te.num, te.name), func(t *testing.T) { + e := unix.ErrnoName(te.num) + if e != te.name { + t.Errorf("ErrnoName(%d) returned %s, want %s", te.num, e, te.name) + } + }) + } + + testSignals := []struct { + num syscall.Signal + name string + }{ + {syscall.SIGHUP, "SIGHUP"}, + {syscall.SIGPIPE, "SIGPIPE"}, + {syscall.SIGSEGV, "SIGSEGV"}, + } + + for _, ts := range testSignals { + t.Run(fmt.Sprintf("%d/%s", ts.num, ts.name), func(t *testing.T) { + s := unix.SignalName(ts.num) + if s != ts.name { + t.Errorf("SignalName(%d) returned %s, want %s", ts.num, s, ts.name) + } + }) + } +} + +func TestFcntlInt(t *testing.T) { + t.Parallel() + file, err := ioutil.TempFile("", "TestFnctlInt") + if err != nil { + t.Fatal(err) + } + defer os.Remove(file.Name()) + defer file.Close() + f := file.Fd() + flags, err := unix.FcntlInt(f, unix.F_GETFD, 0) + if err != nil { + t.Fatal(err) + } + if flags&unix.FD_CLOEXEC == 0 { + t.Errorf("flags %#x do not include FD_CLOEXEC", flags) + } +} + // TestFcntlFlock tests whether the file locking structure matches // the calling convention of each kernel. func TestFcntlFlock(t *testing.T) { @@ -86,6 +143,10 @@ func TestFcntlFlock(t *testing.T) { // "-test.run=^TestPassFD$" and an environment variable used to signal // that the test should become the child process instead. func TestPassFD(t *testing.T) { + if runtime.GOOS == "darwin" && (runtime.GOARCH == "arm" || runtime.GOARCH == "arm64") { + t.Skip("cannot exec subprocess on iOS, skipping test") + } + if os.Getenv("GO_WANT_HELPER_PROCESS") == "1" { passFDChild() return @@ -351,6 +412,11 @@ func TestDup(t *testing.T) { } func TestPoll(t *testing.T) { + if runtime.GOOS == "android" || + (runtime.GOOS == "darwin" && (runtime.GOARCH == "arm" || runtime.GOARCH == "arm64")) { + t.Skip("mkfifo syscall is not available on android and iOS, skipping test") + } + f, cleanup := mktmpfifo(t) defer cleanup() @@ -387,7 +453,10 @@ func TestGetwd(t *testing.T) { // These are chosen carefully not to be symlinks on a Mac // (unlike, say, /var, /etc) dirs := []string{"/", "/usr/bin"} - if runtime.GOOS == "darwin" { + switch runtime.GOOS { + case "android": + dirs = []string{"/", "/system/bin"} + case "darwin": switch runtime.GOARCH { case "arm", "arm64": d1, err := ioutil.TempDir("", "d1") @@ -426,6 +495,114 @@ func TestGetwd(t *testing.T) { } } +func TestFstatat(t *testing.T) { + defer chtmpdir(t)() + + touch(t, "file1") + + var st1 unix.Stat_t + err := unix.Stat("file1", &st1) + if err != nil { + t.Fatalf("Stat: %v", err) + } + + var st2 unix.Stat_t + err = unix.Fstatat(unix.AT_FDCWD, "file1", &st2, 0) + if err != nil { + t.Fatalf("Fstatat: %v", err) + } + + if st1 != st2 { + t.Errorf("Fstatat: returned stat does not match Stat") + } + + err = os.Symlink("file1", "symlink1") + if err != nil { + t.Fatal(err) + } + + err = unix.Lstat("symlink1", &st1) + if err != nil { + t.Fatalf("Lstat: %v", err) + } + + err = unix.Fstatat(unix.AT_FDCWD, "symlink1", &st2, unix.AT_SYMLINK_NOFOLLOW) + if err != nil { + t.Fatalf("Fstatat: %v", err) + } + + if st1 != st2 { + t.Errorf("Fstatat: returned stat does not match Lstat") + } +} + +func TestFchmodat(t *testing.T) { + defer chtmpdir(t)() + + touch(t, "file1") + err := os.Symlink("file1", "symlink1") + if err != nil { + t.Fatal(err) + } + + mode := os.FileMode(0444) + err = unix.Fchmodat(unix.AT_FDCWD, "symlink1", uint32(mode), 0) + if err != nil { + t.Fatalf("Fchmodat: unexpected error: %v", err) + } + + fi, err := os.Stat("file1") + if err != nil { + t.Fatal(err) + } + + if fi.Mode() != mode { + t.Errorf("Fchmodat: failed to change file mode: expected %v, got %v", mode, fi.Mode()) + } + + mode = os.FileMode(0644) + didChmodSymlink := true + err = unix.Fchmodat(unix.AT_FDCWD, "symlink1", uint32(mode), unix.AT_SYMLINK_NOFOLLOW) + if err != nil { + if (runtime.GOOS == "android" || runtime.GOOS == "linux" || runtime.GOOS == "solaris") && err == unix.EOPNOTSUPP { + // Linux and Illumos don't support flags != 0 + didChmodSymlink = false + } else { + t.Fatalf("Fchmodat: unexpected error: %v", err) + } + } + + if !didChmodSymlink { + // Didn't change mode of the symlink. On Linux, the permissions + // of a symbolic link are always 0777 according to symlink(7) + mode = os.FileMode(0777) + } + + var st unix.Stat_t + err = unix.Lstat("symlink1", &st) + if err != nil { + t.Fatal(err) + } + + got := os.FileMode(st.Mode & 0777) + if got != mode { + t.Errorf("Fchmodat: failed to change symlink mode: expected %v, got %v", mode, got) + } +} + +func TestMkdev(t *testing.T) { + major := uint32(42) + minor := uint32(7) + dev := unix.Mkdev(major, minor) + + if unix.Major(dev) != major { + t.Errorf("Major(%#x) == %d, want %d", dev, unix.Major(dev), major) + } + if unix.Minor(dev) != minor { + t.Errorf("Minor(%#x) == %d, want %d", dev, unix.Minor(dev), minor) + } +} + // mktmpfifo creates a temporary FIFO and provides a cleanup function. func mktmpfifo(t *testing.T) (*os.File, func()) { err := unix.Mkfifo("fifo", 0666) @@ -444,3 +621,37 @@ func mktmpfifo(t *testing.T) (*os.File, func()) { os.Remove("fifo") } } + +// utilities taken from os/os_test.go + +func touch(t *testing.T, name string) { + f, err := os.Create(name) + if err != nil { + t.Fatal(err) + } + if err := f.Close(); err != nil { + t.Fatal(err) + } +} + +// chtmpdir changes the working directory to a new temporary directory and +// provides a cleanup function. Used when PWD is read-only. +func chtmpdir(t *testing.T) func() { + oldwd, err := os.Getwd() + if err != nil { + t.Fatalf("chtmpdir: %v", err) + } + d, err := ioutil.TempDir("", "test") + if err != nil { + t.Fatalf("chtmpdir: %v", err) + } + if err := os.Chdir(d); err != nil { + t.Fatalf("chtmpdir: %v", err) + } + return func() { + if err := os.Chdir(oldwd); err != nil { + t.Fatalf("chtmpdir: %v", err) + } + os.RemoveAll(d) + } +} |