Codebase list golang-github-creack-pty / 2497551e-ab1b-4ec4-a0fb-c9b9f8d39055/upstream/1.1.18+git20220421.1.0d412c9
Import upstream version 1.1.18+git20220421.1.0d412c9 Debian Janitor 1 year, 4 months ago
5 changed file(s) with 387 addition(s) and 69 deletion(s). Raw diff Collapse all Expand all
+0
-17
.github/workflows/crosscompile.yml less more
0 name: Crosscompile
1
2 on:
3 push:
4 branches:
5 - master
6
7 jobs:
8 test:
9 name: Run ./test_crosscompile.sh
10 runs-on: ubuntu-latest
11
12 steps:
13 - name: Checkout repo
14 uses: actions/checkout@v2
15 - name: Run ./test_crosscompile.sh
16 run: ./test_crosscompile.sh⏎
+0
-46
.github/workflows/test.yml less more
0 name: Test
1
2 on:
3 push:
4 branches:
5 - master
6 pull_request:
7 branches:
8 - master
9
10 jobs:
11 test:
12 name: "Test go ${{ matrix.go_version }} on ${{ matrix.platform }}"
13 runs-on: ${{ matrix.platform }}
14
15 strategy:
16 matrix:
17 platform:
18 - ubuntu-latest
19 - macos-latest
20 go_version:
21 # Test the two currently supported releases (https://go.dev/doc/devel/release#policy)
22 - 1.17.x
23 - 1.18.x
24 include:
25 # Also sanity test a very old release on linux
26 - platform: ubuntu-latest
27 go_version: 1.6.x
28
29 steps:
30 # 1.6 doesn't seem to default GOPATH to anything, so we set it explicitly here
31 - name: Set GOPATH
32 run: echo "GOPATH=$HOME/go" >> $GITHUB_ENV
33
34 - name: Set up Go ${{ matrix.go_version }}
35 uses: actions/setup-go@v3
36 with:
37 go-version: ${{ matrix.go_version }}
38 check-latest: true
39 - name: Checkout repo
40 uses: actions/checkout@v2
41
42 - name: Build
43 run: go build -v
44 - name: Test
45 run: go test -v⏎
+0
-4
.gitignore less more
0 [568].out
1 _go*
2 _test*
3 _obj
+374
-0
doc_test.go less more
0 package pty
1
2 import (
3 "bytes"
4 "io"
5 "os"
6 "testing"
7 )
8
9 // Will fill p from reader r
10 func readBytes(r io.Reader, p []byte) error {
11 bytesRead := 0
12 for bytesRead < len(p) {
13 n, err := r.Read(p[bytesRead:])
14 if err != nil {
15 return err
16 }
17 bytesRead = bytesRead + n
18 }
19 return nil
20 }
21
22 func TestOpen(t *testing.T) {
23 t.Parallel()
24
25 pty, tty, err := Open()
26 if err != nil {
27 t.Errorf("Unexpected error from Open: %s", err)
28 }
29
30 err = tty.Close()
31 if err != nil {
32 t.Errorf("Unexpected error from tty Close: %s", err)
33 }
34
35 err = pty.Close()
36 if err != nil {
37 t.Errorf("Unexpected error from pty Close: %s", err)
38 }
39 }
40
41 func TestName(t *testing.T) {
42 t.Parallel()
43
44 pty, tty, err := Open()
45 if err != nil {
46 t.Errorf("Unexpected error from Open: %s", err)
47 }
48
49 // Check name isn't empty. There's variation on what exactly the OS calls these files.
50 if pty.Name() == "" {
51 t.Error("pty name was empty")
52 }
53 if tty.Name() == "" {
54 t.Error("tty name was empty")
55 }
56
57 err = tty.Close()
58 if err != nil {
59 t.Errorf("Unexpected error from tty Close: %s", err)
60 }
61
62 err = pty.Close()
63 if err != nil {
64 t.Errorf("Unexpected error from pty Close: %s", err)
65 }
66 }
67
68 // TestOpenByName ensures that the name associated with the tty is valid
69 // and can be opened and used if passed by file name (rather than passing
70 // the existing open file descriptor).
71 func TestOpenByName(t *testing.T) {
72 t.Parallel()
73
74 pty, tty, err := Open()
75 if err != nil {
76 t.Fatal(err)
77 }
78 defer pty.Close()
79 defer tty.Close()
80
81 ttyFile, err := os.OpenFile(tty.Name(), os.O_RDWR, 0600)
82 if err != nil {
83 t.Fatalf("Failed to open tty file: %v", err)
84 }
85 defer ttyFile.Close()
86
87 // Ensure we can write to the newly opened tty file and read on the pty.
88 text := []byte("ping")
89 n, err := ttyFile.Write(text)
90 if err != nil {
91 t.Errorf("Unexpected error from Write: %s", err)
92 }
93 if n != len(text) {
94 t.Errorf("Unexpected count returned from Write, got %d expected %d", n, len(text))
95 }
96
97 buffer := make([]byte, len(text))
98 if err := readBytes(pty, buffer); err != nil {
99 t.Errorf("Unexpected error from readBytes: %s", err)
100 }
101 if !bytes.Equal(text, buffer) {
102 t.Errorf("Unexpected result returned from Read, got %v expected %v", buffer, text)
103 }
104 }
105
106 func TestGetsize(t *testing.T) {
107 t.Parallel()
108
109 pty, tty, err := Open()
110 if err != nil {
111 t.Errorf("Unexpected error from Open: %s", err)
112 }
113
114 prows, pcols, err := Getsize(pty)
115 if err != nil {
116 t.Errorf("Unexpected error from Getsize: %s", err)
117 }
118
119 trows, tcols, err := Getsize(tty)
120 if err != nil {
121 t.Errorf("Unexpected error from Getsize: %s", err)
122 }
123
124 if prows != trows {
125 t.Errorf("pty rows != tty rows: %d != %d", prows, trows)
126 }
127 if prows != trows {
128 t.Errorf("pty cols != tty cols: %d != %d", pcols, tcols)
129 }
130
131 err = tty.Close()
132 if err != nil {
133 t.Errorf("Unexpected error from tty Close: %s", err)
134 }
135
136 err = pty.Close()
137 if err != nil {
138 t.Errorf("Unexpected error from pty Close: %s", err)
139 }
140 }
141
142 func TestGetsizefull(t *testing.T) {
143 t.Parallel()
144
145 pty, tty, err := Open()
146 if err != nil {
147 t.Errorf("Unexpected error from Open: %s", err)
148 }
149
150 psize, err := GetsizeFull(pty)
151 if err != nil {
152 t.Errorf("Unexpected error from GetsizeFull: %s", err)
153 }
154
155 tsize, err := GetsizeFull(tty)
156 if err != nil {
157 t.Errorf("Unexpected error from GetsizeFull: %s", err)
158 }
159
160 if psize.X != tsize.X {
161 t.Errorf("pty x != tty x: %d != %d", psize.X, tsize.X)
162 }
163 if psize.Y != tsize.Y {
164 t.Errorf("pty y != tty y: %d != %d", psize.Y, tsize.Y)
165 }
166 if psize.Rows != tsize.Rows {
167 t.Errorf("pty rows != tty rows: %d != %d", psize.Rows, tsize.Rows)
168 }
169 if psize.Cols != tsize.Cols {
170 t.Errorf("pty cols != tty cols: %d != %d", psize.Cols, tsize.Cols)
171 }
172
173 err = tty.Close()
174 if err != nil {
175 t.Errorf("Unexpected error from tty Close: %s", err)
176 }
177
178 err = pty.Close()
179 if err != nil {
180 t.Errorf("Unexpected error from pty Close: %s", err)
181 }
182 }
183
184 func TestSetsize(t *testing.T) {
185 t.Parallel()
186
187 pty, tty, err := Open()
188 if err != nil {
189 t.Errorf("Unexpected error from Open: %s", err)
190 }
191
192 psize, err := GetsizeFull(pty)
193 if err != nil {
194 t.Errorf("Unexpected error from GetsizeFull: %s", err)
195 }
196
197 psize.X = psize.X + 1
198 psize.Y = psize.Y + 1
199 psize.Rows = psize.Rows + 1
200 psize.Cols = psize.Cols + 1
201
202 err = Setsize(tty, psize)
203 if err != nil {
204 t.Errorf("Unexpected error from Setsize: %s", err)
205 }
206
207 tsize, err := GetsizeFull(tty)
208 if err != nil {
209 t.Errorf("Unexpected error from GetsizeFull: %s", err)
210 }
211
212 if psize.X != tsize.X {
213 t.Errorf("pty x != tty x: %d != %d", psize.X, tsize.X)
214 }
215 if psize.Y != tsize.Y {
216 t.Errorf("pty y != tty y: %d != %d", psize.Y, tsize.Y)
217 }
218 if psize.Rows != tsize.Rows {
219 t.Errorf("pty rows != tty rows: %d != %d", psize.Rows, tsize.Rows)
220 }
221 if psize.Cols != tsize.Cols {
222 t.Errorf("pty cols != tty cols: %d != %d", psize.Cols, tsize.Cols)
223 }
224
225 err = tty.Close()
226 if err != nil {
227 t.Errorf("Unexpected error from tty Close: %s", err)
228 }
229
230 err = pty.Close()
231 if err != nil {
232 t.Errorf("Unexpected error from pty Close: %s", err)
233 }
234 }
235
236 func TestReadWriteText(t *testing.T) {
237 t.Parallel()
238
239 pty, tty, err := Open()
240 if err != nil {
241 t.Errorf("Unexpected error from Open: %s", err)
242 }
243
244 // Write to tty, read from pty
245 text := []byte("ping")
246 n, err := tty.Write(text)
247 if err != nil {
248 t.Errorf("Unexpected error from Write: %s", err)
249 }
250 if n != len(text) {
251 t.Errorf("Unexpected count returned from Write, got %d expected %d", n, len(text))
252 }
253
254 buffer := make([]byte, 4)
255 err = readBytes(pty, buffer)
256 if err != nil {
257 t.Errorf("Unexpected error from readBytes: %s", err)
258 }
259 if !bytes.Equal(text, buffer) {
260 t.Errorf("Unexpected result returned from Read, got %v expected %v", buffer, text)
261 }
262
263 // Write to pty, read from tty.
264 // We need to send a \n otherwise this will block in the terminal driver.
265 text = []byte("pong\n")
266 n, err = pty.Write(text)
267 if err != nil {
268 t.Errorf("Unexpected error from Write: %s", err)
269 }
270 if n != len(text) {
271 t.Errorf("Unexpected count returned from Write, got %d expected %d", n, len(text))
272 }
273
274 buffer = make([]byte, 5)
275 err = readBytes(tty, buffer)
276 if err != nil {
277 t.Errorf("Unexpected error from readBytes: %s", err)
278 }
279 expect := []byte("pong\n")
280 if !bytes.Equal(expect, buffer) {
281 t.Errorf("Unexpected result returned from Read, got %v expected %v", buffer, expect)
282 }
283
284 // Read the echo back from pty
285 buffer = make([]byte, 5)
286 err = readBytes(pty, buffer)
287 if err != nil {
288 t.Errorf("Unexpected error from readBytes: %s", err)
289 }
290 expect = []byte("pong\r")
291 if !bytes.Equal(expect, buffer) {
292 t.Errorf("Unexpected result returned from Read, got %v expected %v", buffer, expect)
293 }
294
295 err = tty.Close()
296 if err != nil {
297 t.Errorf("Unexpected error from tty Close: %s", err)
298 }
299
300 err = pty.Close()
301 if err != nil {
302 t.Errorf("Unexpected error from pty Close: %s", err)
303 }
304 }
305
306 func TestReadWriteControls(t *testing.T) {
307 t.Parallel()
308
309 pty, tty, err := Open()
310 if err != nil {
311 t.Errorf("Unexpected error from Open: %s", err)
312 }
313
314 // Write the start of a line to pty
315 text := []byte("pind")
316 n, err := pty.Write(text)
317 if err != nil {
318 t.Errorf("Unexpected error from Write: %s", err)
319 }
320 if n != len(text) {
321 t.Errorf("Unexpected count returned from Write, got %d expected %d", n, len(text))
322 }
323
324 // Backspace that last char
325 n, err = pty.Write([]byte("\b"))
326 if err != nil {
327 t.Errorf("Unexpected error from Write: %s", err)
328 }
329 if n != 1 {
330 t.Errorf("Unexpected count returned from Write, got %d expected %d", n, 1)
331 }
332
333 // Write the correct char and a CR
334 n, err = pty.Write([]byte("g\n"))
335 if err != nil {
336 t.Errorf("Unexpected error from Write: %s", err)
337 }
338 if n != 2 {
339 t.Errorf("Unexpected count returned from Write, got %d expected %d", n, 2)
340 }
341
342 // Read the line
343 buffer := make([]byte, 7)
344 err = readBytes(tty, buffer)
345 if err != nil {
346 t.Errorf("Unexpected error from readBytes: %s", err)
347 }
348 expect := []byte("pind\bg\n")
349 if !bytes.Equal(expect, buffer) {
350 t.Errorf("Unexpected result returned from Read, got %v expected %v", buffer, expect)
351 }
352
353 // Read the echo back from pty
354 buffer = make([]byte, 7)
355 err = readBytes(pty, buffer)
356 if err != nil {
357 t.Errorf("Unexpected error from readBytes: %s", err)
358 }
359 expect = []byte("pind^Hg")
360 if !bytes.Equal(expect, buffer) {
361 t.Errorf("Unexpected result returned from Read, got %v expected %v", buffer, expect)
362 }
363
364 err = tty.Close()
365 if err != nil {
366 t.Errorf("Unexpected error from tty Close: %s", err)
367 }
368
369 err = pty.Close()
370 if err != nil {
371 t.Errorf("Unexpected error from pty Close: %s", err)
372 }
373 }
+13
-2
pty_openbsd.go less more
77 "syscall"
88 "unsafe"
99 )
10
11 func cInt8ToString(in []int8) string {
12 var s []byte
13 for _, v := range in {
14 if v == 0 {
15 break
16 }
17 s = append(s, byte(v))
18 }
19 return string(s)
20 }
1021
1122 func open() (pty, tty *os.File, err error) {
1223 /*
2839 return nil, nil, err
2940 }
3041
31 pty = os.NewFile(uintptr(ptm.Cfd), "/dev/ptm")
32 tty = os.NewFile(uintptr(ptm.Sfd), "/dev/ptm")
42 pty = os.NewFile(uintptr(ptm.Cfd), cInt8ToString(ptm.Cn[:]))
43 tty = os.NewFile(uintptr(ptm.Sfd), cInt8ToString(ptm.Sn[:]))
3344
3445 return pty, tty, nil
3546 }