.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/sys@v0.0.0-20210124154548-22da62e12c0c/unix/syscall_darwin_test.go

   1 // Copyright 2018 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 unix_test
   6
   7 import (
   8         "bytes"
   9         "io/ioutil"
  10         "os"
  11         "path"
  12         "testing"
  13
  14         "golang.org/x/sys/unix"
  15 )
  16
  17 var testData = []byte("This is a test\n")
  18
  19 // stringsFromByteSlice converts a sequence of attributes to a []string.
  20 // On Darwin, each entry is a NULL-terminated string.
  21 func stringsFromByteSlice(buf []byte) []string {
  22         var result []string
  23         off := 0
  24         for i, b := range buf {
  25                 if b == 0 {
  26                         result = append(result, string(buf[off:i]))
  27                         off = i + 1
  28                 }
  29         }
  30         return result
  31 }
  32
  33 func createTestFile(t *testing.T, dir string) (f *os.File, cleanup func() error) {
  34         file, err := ioutil.TempFile(dir, t.Name())
  35         if err != nil {
  36                 t.Fatal(err)
  37         }
  38
  39         _, err = file.Write(testData)
  40         if err != nil {
  41                 t.Fatal(err)
  42         }
  43
  44         err = file.Close()
  45         if err != nil {
  46                 t.Fatal(err)
  47         }
  48
  49         return file, func() error {
  50                 return os.Remove(file.Name())
  51         }
  52 }
  53
  54 func TestClonefile(t *testing.T) {
  55         file, cleanup := createTestFile(t, "")
  56         defer cleanup()
  57
  58         clonedName := file.Name() + "-cloned"
  59         err := unix.Clonefile(file.Name(), clonedName, 0)
  60         if err == unix.ENOSYS || err == unix.ENOTSUP {
  61                 t.Skip("clonefile is not available or supported, skipping test")
  62         } else if err != nil {
  63                 t.Fatal(err)
  64         }
  65         defer os.Remove(clonedName)
  66
  67         clonedData, err := ioutil.ReadFile(clonedName)
  68         if err != nil {
  69                 t.Fatal(err)
  70         }
  71
  72         if !bytes.Equal(testData, clonedData) {
  73                 t.Errorf("Clonefile: got %q, expected %q", clonedData, testData)
  74         }
  75 }
  76
  77 func TestClonefileatWithCwd(t *testing.T) {
  78         file, cleanup := createTestFile(t, "")
  79         defer cleanup()
  80
  81         clonedName := file.Name() + "-cloned"
  82         err := unix.Clonefileat(unix.AT_FDCWD, file.Name(), unix.AT_FDCWD, clonedName, 0)
  83         if err == unix.ENOSYS || err == unix.ENOTSUP {
  84                 t.Skip("clonefileat is not available or supported, skipping test")
  85         } else if err != nil {
  86                 t.Fatal(err)
  87         }
  88         defer os.Remove(clonedName)
  89
  90         clonedData, err := ioutil.ReadFile(clonedName)
  91         if err != nil {
  92                 t.Fatal(err)
  93         }
  94
  95         if !bytes.Equal(testData, clonedData) {
  96                 t.Errorf("Clonefileat: got %q, expected %q", clonedData, testData)
  97         }
  98 }
  99
 100 func TestClonefileatWithRelativePaths(t *testing.T) {
 101         srcDir, err := ioutil.TempDir("", "src")
 102         if err != nil {
 103                 t.Fatal(err)
 104         }
 105         defer os.RemoveAll(srcDir)
 106
 107         dstDir, err := ioutil.TempDir("", "dest")
 108         if err != nil {
 109                 t.Fatal(err)
 110         }
 111         defer os.RemoveAll(dstDir)
 112
 113         srcFd, err := unix.Open(srcDir, unix.O_RDONLY|unix.O_DIRECTORY, 0)
 114         if err != nil {
 115                 t.Fatal(err)
 116         }
 117         defer unix.Close(srcFd)
 118
 119         dstFd, err := unix.Open(dstDir, unix.O_RDONLY|unix.O_DIRECTORY, 0)
 120         if err != nil {
 121                 t.Fatal(err)
 122         }
 123         defer unix.Close(dstFd)
 124
 125         srcFile, cleanup := createTestFile(t, srcDir)
 126         defer cleanup()
 127
 128         dstFile, err := ioutil.TempFile(dstDir, "TestClonefileat")
 129         if err != nil {
 130                 t.Fatal(err)
 131         }
 132         err = os.Remove(dstFile.Name())
 133         if err != nil {
 134                 t.Fatal(err)
 135         }
 136
 137         src := path.Base(srcFile.Name())
 138         dst := path.Base(dstFile.Name())
 139         err = unix.Clonefileat(srcFd, src, dstFd, dst, 0)
 140         if err == unix.ENOSYS || err == unix.ENOTSUP {
 141                 t.Skip("clonefileat is not available or supported, skipping test")
 142         } else if err != nil {
 143                 t.Fatal(err)
 144         }
 145
 146         clonedData, err := ioutil.ReadFile(dstFile.Name())
 147         if err != nil {
 148                 t.Fatal(err)
 149         }
 150
 151         if !bytes.Equal(testData, clonedData) {
 152                 t.Errorf("Clonefileat: got %q, expected %q", clonedData, testData)
 153         }
 154 }
 155
 156 func TestFclonefileat(t *testing.T) {
 157         file, cleanup := createTestFile(t, "")
 158         defer cleanup()
 159
 160         fd, err := unix.Open(file.Name(), unix.O_RDONLY, 0)
 161         if err != nil {
 162                 t.Fatal(err)
 163         }
 164         defer unix.Close(fd)
 165
 166         dstFile, err := ioutil.TempFile("", "TestFclonefileat")
 167         if err != nil {
 168                 t.Fatal(err)
 169         }
 170         os.Remove(dstFile.Name())
 171
 172         err = unix.Fclonefileat(fd, unix.AT_FDCWD, dstFile.Name(), 0)
 173         if err == unix.ENOSYS || err == unix.ENOTSUP {
 174                 t.Skip("clonefileat is not available or supported, skipping test")
 175         } else if err != nil {
 176                 t.Fatal(err)
 177         }
 178
 179         clonedData, err := ioutil.ReadFile(dstFile.Name())
 180         if err != nil {
 181                 t.Fatal(err)
 182         }
 183
 184         if !bytes.Equal(testData, clonedData) {
 185                 t.Errorf("Fclonefileat: got %q, expected %q", clonedData, testData)
 186         }
 187 }
 188
 189 func TestFcntlFstore(t *testing.T) {
 190         f, err := ioutil.TempFile("", t.Name())
 191         if err != nil {
 192                 t.Fatal(err)
 193         }
 194         defer os.Remove(f.Name())
 195         defer f.Close()
 196
 197         fstore := &unix.Fstore_t{
 198                 Flags:   unix.F_ALLOCATEALL,
 199                 Posmode: unix.F_PEOFPOSMODE,
 200                 Offset:  0,
 201                 Length:  1 << 10,
 202         }
 203         err = unix.FcntlFstore(f.Fd(), unix.F_PREALLOCATE, fstore)
 204         if err == unix.EOPNOTSUPP {
 205                 t.Skipf("fcntl with F_PREALLOCATE not supported, skipping test")
 206         } else if err != nil {
 207                 t.Fatalf("FcntlFstore: %v", err)
 208         }
 209
 210         st, err := f.Stat()
 211         if err != nil {
 212                 t.Fatal(err)
 213         }
 214
 215         if st.Size() != 0 {
 216                 t.Errorf("FcntlFstore: got size = %d, want %d", st.Size(), 0)
 217         }
 218
 219 }