diff options
Diffstat (limited to '')
-rw-r--r-- | dependencies/pkg/mod/golang.org/x/sys@v0.1.0/unix/syscall_darwin_test.go | 294 |
1 files changed, 294 insertions, 0 deletions
diff --git a/dependencies/pkg/mod/golang.org/x/sys@v0.1.0/unix/syscall_darwin_test.go b/dependencies/pkg/mod/golang.org/x/sys@v0.1.0/unix/syscall_darwin_test.go new file mode 100644 index 0000000..eac98fe --- /dev/null +++ b/dependencies/pkg/mod/golang.org/x/sys@v0.1.0/unix/syscall_darwin_test.go @@ -0,0 +1,294 @@ +// Copyright 2018 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package unix_test + +import ( + "bytes" + "io/ioutil" + "net" + "os" + "path" + "testing" + + "golang.org/x/sys/unix" +) + +var testData = []byte("This is a test\n") + +// stringsFromByteSlice converts a sequence of attributes to a []string. +// On Darwin, each entry is a NULL-terminated string. +func stringsFromByteSlice(buf []byte) []string { + var result []string + off := 0 + for i, b := range buf { + if b == 0 { + result = append(result, string(buf[off:i])) + off = i + 1 + } + } + return result +} + +func createTestFile(t *testing.T, dir string) (f *os.File, cleanup func() error) { + file, err := ioutil.TempFile(dir, t.Name()) + if err != nil { + t.Fatal(err) + } + + _, err = file.Write(testData) + if err != nil { + t.Fatal(err) + } + + err = file.Close() + if err != nil { + t.Fatal(err) + } + + return file, func() error { + return os.Remove(file.Name()) + } +} + +func TestClonefile(t *testing.T) { + file, cleanup := createTestFile(t, "") + defer cleanup() + + clonedName := file.Name() + "-cloned" + err := unix.Clonefile(file.Name(), clonedName, 0) + if err == unix.ENOSYS || err == unix.ENOTSUP { + t.Skip("clonefile is not available or supported, skipping test") + } else if err != nil { + t.Fatal(err) + } + defer os.Remove(clonedName) + + clonedData, err := ioutil.ReadFile(clonedName) + if err != nil { + t.Fatal(err) + } + + if !bytes.Equal(testData, clonedData) { + t.Errorf("Clonefile: got %q, expected %q", clonedData, testData) + } +} + +func TestClonefileatWithCwd(t *testing.T) { + file, cleanup := createTestFile(t, "") + defer cleanup() + + clonedName := file.Name() + "-cloned" + err := unix.Clonefileat(unix.AT_FDCWD, file.Name(), unix.AT_FDCWD, clonedName, 0) + if err == unix.ENOSYS || err == unix.ENOTSUP { + t.Skip("clonefileat is not available or supported, skipping test") + } else if err != nil { + t.Fatal(err) + } + defer os.Remove(clonedName) + + clonedData, err := ioutil.ReadFile(clonedName) + if err != nil { + t.Fatal(err) + } + + if !bytes.Equal(testData, clonedData) { + t.Errorf("Clonefileat: got %q, expected %q", clonedData, testData) + } +} + +func TestClonefileatWithRelativePaths(t *testing.T) { + srcDir, err := ioutil.TempDir("", "src") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(srcDir) + + dstDir, err := ioutil.TempDir("", "dest") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(dstDir) + + srcFd, err := unix.Open(srcDir, unix.O_RDONLY|unix.O_DIRECTORY, 0) + if err != nil { + t.Fatal(err) + } + defer unix.Close(srcFd) + + dstFd, err := unix.Open(dstDir, unix.O_RDONLY|unix.O_DIRECTORY, 0) + if err != nil { + t.Fatal(err) + } + defer unix.Close(dstFd) + + srcFile, cleanup := createTestFile(t, srcDir) + defer cleanup() + + dstFile, err := ioutil.TempFile(dstDir, "TestClonefileat") + if err != nil { + t.Fatal(err) + } + err = os.Remove(dstFile.Name()) + if err != nil { + t.Fatal(err) + } + + src := path.Base(srcFile.Name()) + dst := path.Base(dstFile.Name()) + err = unix.Clonefileat(srcFd, src, dstFd, dst, 0) + if err == unix.ENOSYS || err == unix.ENOTSUP { + t.Skip("clonefileat is not available or supported, skipping test") + } else if err != nil { + t.Fatal(err) + } + + clonedData, err := ioutil.ReadFile(dstFile.Name()) + if err != nil { + t.Fatal(err) + } + + if !bytes.Equal(testData, clonedData) { + t.Errorf("Clonefileat: got %q, expected %q", clonedData, testData) + } +} + +func TestFclonefileat(t *testing.T) { + file, cleanup := createTestFile(t, "") + defer cleanup() + + fd, err := unix.Open(file.Name(), unix.O_RDONLY, 0) + if err != nil { + t.Fatal(err) + } + defer unix.Close(fd) + + dstFile, err := ioutil.TempFile("", "TestFclonefileat") + if err != nil { + t.Fatal(err) + } + os.Remove(dstFile.Name()) + + err = unix.Fclonefileat(fd, unix.AT_FDCWD, dstFile.Name(), 0) + if err == unix.ENOSYS || err == unix.ENOTSUP { + t.Skip("clonefileat is not available or supported, skipping test") + } else if err != nil { + t.Fatal(err) + } + + clonedData, err := ioutil.ReadFile(dstFile.Name()) + if err != nil { + t.Fatal(err) + } + + if !bytes.Equal(testData, clonedData) { + t.Errorf("Fclonefileat: got %q, expected %q", clonedData, testData) + } +} + +func TestFcntlFstore(t *testing.T) { + f, err := ioutil.TempFile("", t.Name()) + if err != nil { + t.Fatal(err) + } + defer os.Remove(f.Name()) + defer f.Close() + + fstore := &unix.Fstore_t{ + Flags: unix.F_ALLOCATEALL, + Posmode: unix.F_PEOFPOSMODE, + Offset: 0, + Length: 1 << 10, + } + err = unix.FcntlFstore(f.Fd(), unix.F_PREALLOCATE, fstore) + if err == unix.EOPNOTSUPP { + t.Skipf("fcntl with F_PREALLOCATE not supported, skipping test") + } else if err != nil { + t.Fatalf("FcntlFstore: %v", err) + } + + st, err := f.Stat() + if err != nil { + t.Fatal(err) + } + + if st.Size() != 0 { + t.Errorf("FcntlFstore: got size = %d, want %d", st.Size(), 0) + } + +} + +func TestGetsockoptXucred(t *testing.T) { + fds, err := unix.Socketpair(unix.AF_LOCAL, unix.SOCK_STREAM, 0) + if err != nil { + t.Fatalf("Socketpair: %v", err) + } + + srvFile := os.NewFile(uintptr(fds[0]), "server") + cliFile := os.NewFile(uintptr(fds[1]), "client") + defer srvFile.Close() + defer cliFile.Close() + + srv, err := net.FileConn(srvFile) + if err != nil { + t.Fatalf("FileConn: %v", err) + } + defer srv.Close() + + cli, err := net.FileConn(cliFile) + if err != nil { + t.Fatalf("FileConn: %v", err) + } + defer cli.Close() + + cred, err := unix.GetsockoptXucred(fds[1], unix.SOL_LOCAL, unix.LOCAL_PEERCRED) + if err != nil { + t.Fatal(err) + } + t.Logf("got: %+v", cred) + if got, want := cred.Uid, os.Getuid(); int(got) != int(want) { + t.Errorf("uid = %v; want %v", got, want) + } + if cred.Ngroups > 0 { + if got, want := cred.Groups[0], os.Getgid(); int(got) != int(want) { + t.Errorf("gid = %v; want %v", got, want) + } + } +} + +func TestSysctlKinfoProc(t *testing.T) { + pid := unix.Getpid() + kp, err := unix.SysctlKinfoProc("kern.proc.pid", pid) + if err != nil { + t.Fatalf("SysctlKinfoProc: %v", err) + } + if got, want := int(kp.Proc.P_pid), pid; got != want { + t.Errorf("got pid %d, want %d", got, want) + } +} + +func TestSysctlKinfoProcSlice(t *testing.T) { + kps, err := unix.SysctlKinfoProcSlice("kern.proc.all") + if err != nil { + t.Fatalf("SysctlKinfoProc: %v", err) + } + if len(kps) == 0 { + t.Errorf("SysctlKinfoProcSlice: expected at least one process") + } + + uid := unix.Getuid() + kps, err = unix.SysctlKinfoProcSlice("kern.proc.uid", uid) + if err != nil { + t.Fatalf("SysctlKinfoProc: %v", err) + } + if len(kps) == 0 { + t.Errorf("SysctlKinfoProcSlice: expected at least one process") + } + + for _, kp := range kps { + if got, want := int(kp.Eproc.Ucred.Uid), uid; got != want { + t.Errorf("process %d: got uid %d, want %d", kp.Proc.P_pid, got, want) + } + } +} |