github.com/dolotech/hongbao@v0.0.0-20191130105438-fd59d7a5dda5/src/golang.org/x/sys/unix/syscall_linux_test.go (about) 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 // +build linux 6 7 package unix_test 8 9 import ( 10 "io/ioutil" 11 "os" 12 "testing" 13 "time" 14 15 "golang.org/x/sys/unix" 16 ) 17 18 func TestFchmodat(t *testing.T) { 19 defer chtmpdir(t)() 20 21 touch(t, "file1") 22 os.Symlink("file1", "symlink1") 23 24 err := unix.Fchmodat(unix.AT_FDCWD, "symlink1", 0444, 0) 25 if err != nil { 26 t.Fatalf("Fchmodat: unexpected error: %v", err) 27 } 28 29 fi, err := os.Stat("file1") 30 if err != nil { 31 t.Fatal(err) 32 } 33 34 if fi.Mode() != 0444 { 35 t.Errorf("Fchmodat: failed to change mode: expected %v, got %v", 0444, fi.Mode()) 36 } 37 38 err = unix.Fchmodat(unix.AT_FDCWD, "symlink1", 0444, unix.AT_SYMLINK_NOFOLLOW) 39 if err != unix.EOPNOTSUPP { 40 t.Fatalf("Fchmodat: unexpected error: %v, expected EOPNOTSUPP", err) 41 } 42 } 43 44 func TestIoctlGetInt(t *testing.T) { 45 f, err := os.Open("/dev/random") 46 if err != nil { 47 t.Fatalf("failed to open device: %v", err) 48 } 49 defer f.Close() 50 51 v, err := unix.IoctlGetInt(int(f.Fd()), unix.RNDGETENTCNT) 52 if err != nil { 53 t.Fatalf("failed to perform ioctl: %v", err) 54 } 55 56 t.Logf("%d bits of entropy available", v) 57 } 58 59 func TestPoll(t *testing.T) { 60 f, cleanup := mktmpfifo(t) 61 defer cleanup() 62 63 const timeout = 100 64 65 ok := make(chan bool, 1) 66 go func() { 67 select { 68 case <-time.After(10 * timeout * time.Millisecond): 69 t.Errorf("Poll: failed to timeout after %d milliseconds", 10*timeout) 70 case <-ok: 71 } 72 }() 73 74 fds := []unix.PollFd{{Fd: int32(f.Fd()), Events: unix.POLLIN}} 75 n, err := unix.Poll(fds, timeout) 76 ok <- true 77 if err != nil { 78 t.Errorf("Poll: unexpected error: %v", err) 79 return 80 } 81 if n != 0 { 82 t.Errorf("Poll: wrong number of events: got %v, expected %v", n, 0) 83 return 84 } 85 } 86 87 func TestPpoll(t *testing.T) { 88 f, cleanup := mktmpfifo(t) 89 defer cleanup() 90 91 const timeout = 100 * time.Millisecond 92 93 ok := make(chan bool, 1) 94 go func() { 95 select { 96 case <-time.After(10 * timeout): 97 t.Errorf("Ppoll: failed to timeout after %d", 10*timeout) 98 case <-ok: 99 } 100 }() 101 102 fds := []unix.PollFd{{Fd: int32(f.Fd()), Events: unix.POLLIN}} 103 timeoutTs := unix.NsecToTimespec(int64(timeout)) 104 n, err := unix.Ppoll(fds, &timeoutTs, nil) 105 ok <- true 106 if err != nil { 107 t.Errorf("Ppoll: unexpected error: %v", err) 108 return 109 } 110 if n != 0 { 111 t.Errorf("Ppoll: wrong number of events: got %v, expected %v", n, 0) 112 return 113 } 114 } 115 116 // mktmpfifo creates a temporary FIFO and provides a cleanup function. 117 func mktmpfifo(t *testing.T) (*os.File, func()) { 118 err := unix.Mkfifo("fifo", 0666) 119 if err != nil { 120 t.Fatalf("mktmpfifo: failed to create FIFO: %v", err) 121 } 122 123 f, err := os.OpenFile("fifo", os.O_RDWR, 0666) 124 if err != nil { 125 os.Remove("fifo") 126 t.Fatalf("mktmpfifo: failed to open FIFO: %v", err) 127 } 128 129 return f, func() { 130 f.Close() 131 os.Remove("fifo") 132 } 133 } 134 135 func TestTime(t *testing.T) { 136 var ut unix.Time_t 137 ut2, err := unix.Time(&ut) 138 if err != nil { 139 t.Fatalf("Time: %v", err) 140 } 141 if ut != ut2 { 142 t.Errorf("Time: return value %v should be equal to argument %v", ut2, ut) 143 } 144 145 var now time.Time 146 147 for i := 0; i < 10; i++ { 148 ut, err = unix.Time(nil) 149 if err != nil { 150 t.Fatalf("Time: %v", err) 151 } 152 153 now = time.Now() 154 155 if int64(ut) == now.Unix() { 156 return 157 } 158 } 159 160 t.Errorf("Time: return value %v should be nearly equal to time.Now().Unix() %v", ut, now.Unix()) 161 } 162 163 func TestUtime(t *testing.T) { 164 defer chtmpdir(t)() 165 166 touch(t, "file1") 167 168 buf := &unix.Utimbuf{ 169 Modtime: 12345, 170 } 171 172 err := unix.Utime("file1", buf) 173 if err != nil { 174 t.Fatalf("Utime: %v", err) 175 } 176 177 fi, err := os.Stat("file1") 178 if err != nil { 179 t.Fatal(err) 180 } 181 182 if fi.ModTime().Unix() != 12345 { 183 t.Errorf("Utime: failed to change modtime: expected %v, got %v", 12345, fi.ModTime().Unix()) 184 } 185 } 186 187 func TestGetrlimit(t *testing.T) { 188 var rlim unix.Rlimit 189 err := unix.Getrlimit(unix.RLIMIT_AS, &rlim) 190 if err != nil { 191 t.Fatalf("Getrlimit: %v", err) 192 } 193 } 194 195 func TestSelect(t *testing.T) { 196 _, err := unix.Select(0, nil, nil, nil, &unix.Timeval{0, 0}) 197 if err != nil { 198 t.Fatalf("Select: %v", err) 199 } 200 } 201 202 // utilities taken from os/os_test.go 203 204 func touch(t *testing.T, name string) { 205 f, err := os.Create(name) 206 if err != nil { 207 t.Fatal(err) 208 } 209 if err := f.Close(); err != nil { 210 t.Fatal(err) 211 } 212 } 213 214 // chtmpdir changes the working directory to a new temporary directory and 215 // provides a cleanup function. Used when PWD is read-only. 216 func chtmpdir(t *testing.T) func() { 217 oldwd, err := os.Getwd() 218 if err != nil { 219 t.Fatalf("chtmpdir: %v", err) 220 } 221 d, err := ioutil.TempDir("", "test") 222 if err != nil { 223 t.Fatalf("chtmpdir: %v", err) 224 } 225 if err := os.Chdir(d); err != nil { 226 t.Fatalf("chtmpdir: %v", err) 227 } 228 return func() { 229 if err := os.Chdir(oldwd); err != nil { 230 t.Fatalf("chtmpdir: %v", err) 231 } 232 os.RemoveAll(d) 233 } 234 }