1 |
## oils_failures_allowed: 2
|
2 |
## compare_shells: bash mksh zsh ash
|
3 |
|
4 |
|
5 |
|
6 |
# NOTE: there are TABS below
|
7 |
read x <<EOF
|
8 |
A B C D E
|
9 |
FG
|
10 |
EOF
|
11 |
echo "[$x]"
|
12 |
## stdout: [A B C D E]
|
13 |
## status: 0
|
14 |
|
15 |
|
16 |
echo -n '' > $TMP/empty.txt
|
17 |
read x < $TMP/empty.txt
|
18 |
argv.py "status=$?" "$x"
|
19 |
|
20 |
# No variable name, behaves the same
|
21 |
read < $TMP/empty.txt
|
22 |
argv.py "status=$?" "$REPLY"
|
23 |
|
24 |
## STDOUT:
|
25 |
['status=1', '']
|
26 |
['status=1', '']
|
27 |
## END
|
28 |
## OK dash STDOUT:
|
29 |
['status=1', '']
|
30 |
['status=2', '']
|
31 |
## END
|
32 |
## status: 0
|
33 |
|
34 |
|
35 |
read -n 1 </dev/null
|
36 |
echo $?
|
37 |
## STDOUT:
|
38 |
1
|
39 |
## END
|
40 |
## OK dash stdout: 2
|
41 |
|
42 |
|
43 |
echo | read
|
44 |
echo status=$?
|
45 |
## STDOUT:
|
46 |
status=0
|
47 |
## END
|
48 |
## BUG dash STDOUT:
|
49 |
status=2
|
50 |
## END
|
51 |
|
52 |
|
53 |
|
54 |
# This is odd because the variable is populated successfully. OSH/YSH might
|
55 |
# need a separate put reading feature that doesn't use IFS.
|
56 |
|
57 |
echo -n ZZZ | { read x; echo status=$?; echo $x; }
|
58 |
|
59 |
## STDOUT:
|
60 |
status=1
|
61 |
ZZZ
|
62 |
## END
|
63 |
## status: 0
|
64 |
|
65 |
|
66 |
# NOTE: there are TABS below
|
67 |
read x y z <<EOF
|
68 |
A B C D E
|
69 |
FG
|
70 |
EOF
|
71 |
echo "[$x/$y/$z]"
|
72 |
## stdout: [A/B/C D E]
|
73 |
## status: 0
|
74 |
|
75 |
|
76 |
set -o errexit
|
77 |
set -o nounset # hm this doesn't change it
|
78 |
read x y z <<EOF
|
79 |
A B
|
80 |
EOF
|
81 |
echo /$x/$y/$z/
|
82 |
## stdout: /A/B//
|
83 |
## status: 0
|
84 |
|
85 |
|
86 |
echo 12345 > $TMP/readn.txt
|
87 |
read -n 4 x < $TMP/readn.txt
|
88 |
read -n 2 < $TMP/readn.txt # Do it again with no variable
|
89 |
argv.py $x $REPLY
|
90 |
## stdout: ['1234', '12']
|
91 |
## N-I dash/zsh stdout: []
|
92 |
|
93 |
|
94 |
echo XYZ > "$TMP/readn.txt"
|
95 |
IFS= TMOUT= read -n 1 char < "$TMP/readn.txt"
|
96 |
argv.py "$char"
|
97 |
## stdout: ['X']
|
98 |
## N-I dash/zsh stdout: ['']
|
99 |
|
100 |
|
101 |
case $SH in dash|zsh) exit ;; esac
|
102 |
|
103 |
echo ' a b ' | (read -n 4; echo "[$REPLY]")
|
104 |
echo ' a b ' | (read -n 5; echo "[$REPLY]")
|
105 |
echo ' a b ' | (read -n 6; echo "[$REPLY]")
|
106 |
echo
|
107 |
|
108 |
echo 'one var strips whitespace'
|
109 |
echo ' a b ' | (read -n 4 myvar; echo "[$myvar]")
|
110 |
echo ' a b ' | (read -n 5 myvar; echo "[$myvar]")
|
111 |
echo ' a b ' | (read -n 6 myvar; echo "[$myvar]")
|
112 |
echo
|
113 |
|
114 |
echo 'three vars'
|
115 |
echo ' a b ' | (read -n 4 x y z; echo "[$x] [$y] [$z]")
|
116 |
echo ' a b ' | (read -n 5 x y z; echo "[$x] [$y] [$z]")
|
117 |
echo ' a b ' | (read -n 6 x y z; echo "[$x] [$y] [$z]")
|
118 |
|
119 |
## STDOUT:
|
120 |
[ a ]
|
121 |
[ a b]
|
122 |
[ a b ]
|
123 |
|
124 |
one var strips whitespace
|
125 |
[a]
|
126 |
[a b]
|
127 |
[a b]
|
128 |
|
129 |
three vars
|
130 |
[a] [] []
|
131 |
[a] [b] []
|
132 |
[a] [b] []
|
133 |
## END
|
134 |
|
135 |
## N-I dash/zsh STDOUT:
|
136 |
## END
|
137 |
|
138 |
## BUG mksh STDOUT:
|
139 |
[a]
|
140 |
[a b]
|
141 |
[a b]
|
142 |
|
143 |
one var strips whitespace
|
144 |
[a]
|
145 |
[a b]
|
146 |
[a b]
|
147 |
|
148 |
three vars
|
149 |
[a] [] []
|
150 |
[a] [b] []
|
151 |
[a] [b] []
|
152 |
## END
|
153 |
|
154 |
|
155 |
|
156 |
case $SH in dash|zsh|ash) exit ;; esac
|
157 |
|
158 |
echo 'delim c'
|
159 |
echo ' a b c ' | (read -d 'c' -n 3; echo "[$REPLY]")
|
160 |
echo ' a b c ' | (read -d 'c' -n 4; echo "[$REPLY]")
|
161 |
echo ' a b c ' | (read -d 'c' -n 5; echo "[$REPLY]")
|
162 |
echo
|
163 |
|
164 |
echo 'one var'
|
165 |
echo ' a b c ' | (read -d 'c' -n 3 myvar; echo "[$myvar]")
|
166 |
echo ' a b c ' | (read -d 'c' -n 4 myvar; echo "[$myvar]")
|
167 |
echo ' a b c ' | (read -d 'c' -n 5 myvar; echo "[$myvar]")
|
168 |
echo
|
169 |
|
170 |
echo 'three vars'
|
171 |
echo ' a b c ' | (read -d 'c' -n 3 x y z; echo "[$x] [$y] [$z]")
|
172 |
echo ' a b c ' | (read -d 'c' -n 4 x y z; echo "[$x] [$y] [$z]")
|
173 |
echo ' a b c ' | (read -d 'c' -n 5 x y z; echo "[$x] [$y] [$z]")
|
174 |
|
175 |
## STDOUT:
|
176 |
delim c
|
177 |
[ a]
|
178 |
[ a ]
|
179 |
[ a b]
|
180 |
|
181 |
one var
|
182 |
[a]
|
183 |
[a]
|
184 |
[a b]
|
185 |
|
186 |
three vars
|
187 |
[a] [] []
|
188 |
[a] [] []
|
189 |
[a] [b] []
|
190 |
## END
|
191 |
|
192 |
## N-I dash/zsh/ash STDOUT:
|
193 |
## END
|
194 |
|
195 |
## BUG mksh STDOUT:
|
196 |
delim c
|
197 |
[a]
|
198 |
[a]
|
199 |
[a b]
|
200 |
|
201 |
one var
|
202 |
[a]
|
203 |
[a]
|
204 |
[a b]
|
205 |
|
206 |
three vars
|
207 |
[a] [] []
|
208 |
[a] [] []
|
209 |
[a] [b] []
|
210 |
## END
|
211 |
|
212 |
|
213 |
|
214 |
read -n not_a_number
|
215 |
echo status=$?
|
216 |
## stdout: status=2
|
217 |
## OK bash stdout: status=1
|
218 |
## N-I zsh stdout-json: ""
|
219 |
|
220 |
|
221 |
case $SH in (dash|ash|zsh) exit ;; esac
|
222 |
|
223 |
echo abcxyz | { read -n 3; echo reply=$REPLY; }
|
224 |
## status: 0
|
225 |
## stdout: reply=abc
|
226 |
## N-I dash/ash/zsh stdout-json: ""
|
227 |
|
228 |
# zsh appears to hang with -k
|
229 |
## N-I zsh stdout-json: ""
|
230 |
|
231 |
|
232 |
|
233 |
# mksh and zsh implement splitting with $REPLY, bash/ash don't
|
234 |
|
235 |
echo ' a b ' | (read; echo "[$REPLY]")
|
236 |
echo ' a b ' | (read myvar; echo "[$myvar]")
|
237 |
|
238 |
echo ' a b \
|
239 |
line2' | (read; echo "[$REPLY]")
|
240 |
echo ' a b \
|
241 |
line2' | (read myvar; echo "[$myvar]")
|
242 |
|
243 |
# Now test with -r
|
244 |
echo ' a b \
|
245 |
line2' | (read -r; echo "[$REPLY]")
|
246 |
echo ' a b \
|
247 |
line2' | (read -r myvar; echo "[$myvar]")
|
248 |
|
249 |
## STDOUT:
|
250 |
[ a b ]
|
251 |
[a b]
|
252 |
[ a b line2]
|
253 |
[a b line2]
|
254 |
[ a b \]
|
255 |
[a b \]
|
256 |
## END
|
257 |
## N-I dash stdout:
|
258 |
## BUG mksh/zsh STDOUT:
|
259 |
[a b]
|
260 |
[a b]
|
261 |
[a b line2]
|
262 |
[a b line2]
|
263 |
[a b \]
|
264 |
[a b \]
|
265 |
## END
|
266 |
## BUG dash STDOUT:
|
267 |
[]
|
268 |
[a b ]
|
269 |
[]
|
270 |
[a b line2]
|
271 |
[]
|
272 |
[a b \]
|
273 |
## END
|
274 |
|
275 |
|
276 |
# dash, ash and zsh do not implement read -N
|
277 |
# mksh treats -N exactly the same as -n
|
278 |
case $SH in (dash|ash|zsh) exit ;; esac
|
279 |
|
280 |
# bash docs: https://www.gnu.org/software/bash/manual/html_node/Bash-Builtins.html
|
281 |
|
282 |
echo 'a b c' > $TMP/readn.txt
|
283 |
|
284 |
echo 'read -n'
|
285 |
read -n 5 A B C < $TMP/readn.txt; echo "'$A' '$B' '$C'"
|
286 |
read -n 4 A B C < $TMP/readn.txt; echo "'$A' '$B' '$C'"
|
287 |
echo
|
288 |
|
289 |
echo 'read -N'
|
290 |
read -N 5 A B C < $TMP/readn.txt; echo "'$A' '$B' '$C'"
|
291 |
read -N 4 A B C < $TMP/readn.txt; echo "'$A' '$B' '$C'"
|
292 |
## STDOUT:
|
293 |
read -n
|
294 |
'a' 'b' 'c'
|
295 |
'a' 'b' ''
|
296 |
|
297 |
read -N
|
298 |
'a b c' '' ''
|
299 |
'a b ' '' ''
|
300 |
## END
|
301 |
## N-I dash/ash/zsh stdout-json: ""
|
302 |
## BUG mksh STDOUT:
|
303 |
read -n
|
304 |
'a' 'b' 'c'
|
305 |
'a' 'b' ''
|
306 |
|
307 |
read -N
|
308 |
'a' 'b' 'c'
|
309 |
'a' 'b' ''
|
310 |
## END
|
311 |
|
312 |
|
313 |
case $SH in (dash|ash|zsh) exit ;; esac
|
314 |
|
315 |
echo $'a\nb\nc' > $TMP/read-lines.txt
|
316 |
|
317 |
read -N 3 out < $TMP/read-lines.txt
|
318 |
echo "$out"
|
319 |
## STDOUT:
|
320 |
a
|
321 |
b
|
322 |
## END
|
323 |
## N-I dash/ash/zsh stdout-json: ""
|
324 |
|
325 |
|
326 |
|
327 |
echo 'a b' > $TMP/read-few.txt
|
328 |
|
329 |
c='some value'
|
330 |
read a b c < $TMP/read-few.txt
|
331 |
echo "'$a' '$b' '$c'"
|
332 |
|
333 |
case $SH in (dash) exit ;; esac # dash does not implement -n
|
334 |
|
335 |
c='some value'
|
336 |
read -n 3 a b c < $TMP/read-few.txt
|
337 |
echo "'$a' '$b' '$c'"
|
338 |
## STDOUT:
|
339 |
'a' 'b' ''
|
340 |
'a' 'b' ''
|
341 |
## END
|
342 |
## N-I dash STDOUT:
|
343 |
'a' 'b' ''
|
344 |
## END
|
345 |
## BUG zsh STDOUT:
|
346 |
'a' 'b' ''
|
347 |
'b' '' ''
|
348 |
## END
|
349 |
|
350 |
|
351 |
echo 'one\ two' > $TMP/readr.txt
|
352 |
read escaped < $TMP/readr.txt
|
353 |
read -r raw < $TMP/readr.txt
|
354 |
argv.py "$escaped" "$raw"
|
355 |
## stdout: ['one two', 'one\\ two']
|
356 |
|
357 |
|
358 |
echo 'one\ two\x65three' > $TMP/readr.txt
|
359 |
read escaped < $TMP/readr.txt
|
360 |
read -r raw < $TMP/readr.txt
|
361 |
argv.py "$escaped" "$raw"
|
362 |
# mksh respects the hex escapes here, but other shells don't!
|
363 |
## stdout: ['one twox65three', 'one\\ two\\x65three']
|
364 |
## BUG mksh/zsh stdout: ['one twoethree', 'one\\ twoethree']
|
365 |
|
366 |
|
367 |
# NOTE: osh failing because of file descriptor issue. stdin has to be closed!
|
368 |
tmp=$TMP/$(basename $SH)-readr.txt
|
369 |
echo -e 'one\\\ntwo\n' > $tmp
|
370 |
read escaped < $tmp
|
371 |
read -r raw < $tmp
|
372 |
argv.py "$escaped" "$raw"
|
373 |
## stdout: ['onetwo', 'one\\']
|
374 |
## N-I dash stdout: ['-e onetwo', '-e one\\']
|
375 |
|
376 |
|
377 |
read x y << 'EOF'
|
378 |
one-\
|
379 |
two three-\
|
380 |
four five-\
|
381 |
six
|
382 |
EOF
|
383 |
argv.py "$x" "$y" "$z"
|
384 |
## stdout: ['one-two', 'three-four five-six', '']
|
385 |
|
386 |
|
387 |
echo '\nline' > $TMP/readr.txt
|
388 |
read escaped < $TMP/readr.txt
|
389 |
read -r raw < $TMP/readr.txt
|
390 |
argv.py "$escaped" "$raw"
|
391 |
# dash/mksh/zsh are bugs because at least the raw mode should let you read a
|
392 |
# literal \n.
|
393 |
## stdout: ['nline', '\\nline']
|
394 |
## BUG dash/mksh/zsh stdout: ['', '']
|
395 |
|
396 |
|
397 |
case $SH in (dash|zsh) exit ;; esac
|
398 |
|
399 |
# It's hard to really test this because it requires a terminal. We hit a
|
400 |
# different code path when reading through a pipe. There can be bugs there
|
401 |
# too!
|
402 |
|
403 |
echo foo | { read -s; echo $REPLY; }
|
404 |
echo bar | { read -n 2 -s; echo $REPLY; }
|
405 |
|
406 |
# Hm no exit 1 here? Weird
|
407 |
echo b | { read -n 2 -s; echo $?; echo $REPLY; }
|
408 |
## STDOUT:
|
409 |
foo
|
410 |
ba
|
411 |
0
|
412 |
b
|
413 |
## END
|
414 |
## N-I dash/zsh stdout-json: ""
|
415 |
|
416 |
|
417 |
# The leading spaces are stripped if they appear in IFS.
|
418 |
IFS=$(echo -e '\n')
|
419 |
read var <<EOF
|
420 |
a b c
|
421 |
d e f
|
422 |
EOF
|
423 |
echo "[$var]"
|
424 |
## stdout: [ a b c]
|
425 |
## N-I dash stdout: [a b c]
|
426 |
|
427 |
|
428 |
# The leading spaces are stripped if they appear in IFS.
|
429 |
# IFS chars are escaped with :.
|
430 |
tmp=$TMP/$(basename $SH)-read-ifs.txt
|
431 |
IFS=:
|
432 |
cat >$tmp <<'EOF'
|
433 |
\\a :b\: c:d\
|
434 |
e
|
435 |
EOF
|
436 |
read a b c d < $tmp
|
437 |
# Use printf because echo in dash/mksh interprets escapes, while it doesn't in
|
438 |
# bash.
|
439 |
printf "%s\n" "[$a|$b|$c|$d]"
|
440 |
## stdout: [ \a |b: c|d e|]
|
441 |
|
442 |
|
443 |
IFS=''
|
444 |
read x y <<EOF
|
445 |
a b c d
|
446 |
EOF
|
447 |
echo "[$x|$y]"
|
448 |
## stdout: [ a b c d|]
|
449 |
|
450 |
|
451 |
|
452 |
# bash doesn't respect these, but other shells do. Gah! I think bash
|
453 |
# behavior makes more sense. It only escapes IFS.
|
454 |
echo '\a \b \c \d \e \f \g \h \x65 \145 \i' > $TMP/read-c.txt
|
455 |
read line < $TMP/read-c.txt
|
456 |
echo $line
|
457 |
## stdout-json: "a b c d e f g h x65 145 i\n"
|
458 |
## BUG ash stdout-json: "abcdefghx65 145 i\n"
|
459 |
## BUG dash/zsh stdout-json: "\u0007 \u0008\n"
|
460 |
## BUG mksh stdout-json: "\u0007 \u0008 d \u001b \u000c g h e 145 i\n"
|
461 |
|
462 |
|
463 |
f() {
|
464 |
read head << EOF
|
465 |
ref: refs/heads/dev/andy
|
466 |
EOF
|
467 |
}
|
468 |
f
|
469 |
echo $head
|
470 |
## STDOUT:
|
471 |
ref: refs/heads/dev/andy
|
472 |
## END
|
473 |
|
474 |
|
475 |
|
476 |
# read -a is used in bash-completion
|
477 |
# none of these shells implement it
|
478 |
case $SH in
|
479 |
*mksh|*dash|*zsh|*/ash)
|
480 |
exit 2;
|
481 |
;;
|
482 |
esac
|
483 |
|
484 |
read -a myarray <<'EOF'
|
485 |
a b c\ d
|
486 |
EOF
|
487 |
argv.py "${myarray[@]}"
|
488 |
|
489 |
# arguments are ignored here
|
490 |
read -r -a array2 extra arguments <<'EOF'
|
491 |
a b c\ d
|
492 |
EOF
|
493 |
argv.py "${array2[@]}"
|
494 |
argv.py "${extra[@]}"
|
495 |
argv.py "${arguments[@]}"
|
496 |
## status: 0
|
497 |
## STDOUT:
|
498 |
['a', 'b', 'c d']
|
499 |
['a', 'b', 'c\\', 'd']
|
500 |
[]
|
501 |
[]
|
502 |
## END
|
503 |
## N-I dash/mksh/zsh/ash status: 2
|
504 |
## N-I dash/mksh/zsh/ash stdout-json: ""
|
505 |
|
506 |
|
507 |
printf a,b,c:d,e,f:g,h,i | {
|
508 |
IFS=,
|
509 |
read -d : v1
|
510 |
echo "v1=$v1"
|
511 |
read -d : v1 v2
|
512 |
echo "v1=$v1 v2=$v2"
|
513 |
read -d : v1 v2 v3
|
514 |
echo "v1=$v1 v2=$v2 v3=$v3"
|
515 |
}
|
516 |
## STDOUT:
|
517 |
v1=a,b,c
|
518 |
v1=d v2=e,f
|
519 |
v1=g v2=h v3=i
|
520 |
## END
|
521 |
## N-I dash STDOUT:
|
522 |
v1=
|
523 |
v1= v2=
|
524 |
v1= v2= v3=
|
525 |
## END
|
526 |
|
527 |
|
528 |
printf 'a,b,c\0d,e,f\0g,h,i' | {
|
529 |
IFS=,
|
530 |
read -d '' v1
|
531 |
echo "v1=$v1"
|
532 |
read -d '' v1 v2
|
533 |
echo "v1=$v1 v2=$v2"
|
534 |
read -d '' v1 v2 v3
|
535 |
echo "v1=$v1 v2=$v2 v3=$v3"
|
536 |
}
|
537 |
## STDOUT:
|
538 |
v1=a,b,c
|
539 |
v1=d v2=e,f
|
540 |
v1=g v2=h v3=i
|
541 |
## END
|
542 |
## N-I dash STDOUT:
|
543 |
v1=
|
544 |
v1= v2=
|
545 |
v1= v2= v3=
|
546 |
## END
|
547 |
|
548 |
|
549 |
read -rd '' var <<EOF
|
550 |
foo
|
551 |
bar
|
552 |
EOF
|
553 |
echo "$var"
|
554 |
## STDOUT:
|
555 |
foo
|
556 |
bar
|
557 |
## END
|
558 |
## N-I dash stdout-json: "\n"
|
559 |
|
560 |
|
561 |
{ read -d : part
|
562 |
echo $part $?
|
563 |
read -d : part
|
564 |
echo $part $?
|
565 |
} <<EOF
|
566 |
foo:bar
|
567 |
EOF
|
568 |
## STDOUT:
|
569 |
foo 0
|
570 |
bar 1
|
571 |
## END
|
572 |
## N-I dash STDOUT:
|
573 |
2
|
574 |
2
|
575 |
## END
|
576 |
|
577 |
|
578 |
case $SH in (dash|zsh|mksh) exit ;; esac
|
579 |
|
580 |
# is there input available?
|
581 |
read -t 0 < /dev/null
|
582 |
echo $?
|
583 |
|
584 |
# floating point
|
585 |
read -t 0.0 < /dev/null
|
586 |
echo $?
|
587 |
|
588 |
# floating point
|
589 |
echo foo | { read -t 0; echo reply=$REPLY; }
|
590 |
echo $?
|
591 |
|
592 |
## STDOUT:
|
593 |
0
|
594 |
0
|
595 |
reply=
|
596 |
0
|
597 |
## END
|
598 |
## N-I dash/zsh/mksh stdout-json: ""
|
599 |
|
600 |
|
601 |
case $SH in (dash) exit ;; esac
|
602 |
|
603 |
read -t 0.5 < /dev/null
|
604 |
echo $?
|
605 |
|
606 |
## STDOUT:
|
607 |
1
|
608 |
## END
|
609 |
## BUG zsh/mksh STDOUT:
|
610 |
1
|
611 |
## END
|
612 |
## N-I dash stdout-json: ""
|
613 |
|
614 |
|
615 |
# bash appears to just take the absolute value?
|
616 |
|
617 |
read -t -0.5 < /dev/null
|
618 |
echo $?
|
619 |
|
620 |
## STDOUT:
|
621 |
2
|
622 |
## END
|
623 |
## BUG bash STDOUT:
|
624 |
1
|
625 |
## END
|
626 |
## BUG zsh stdout-json: ""
|
627 |
## BUG zsh status: 1
|
628 |
|
629 |
|
630 |
case $SH in (dash|mksh) exit ;; esac
|
631 |
|
632 |
# file descriptor
|
633 |
read -u 3 3<<EOF
|
634 |
hi
|
635 |
EOF
|
636 |
echo reply=$REPLY
|
637 |
## STDOUT:
|
638 |
reply=hi
|
639 |
## END
|
640 |
## N-I dash/mksh stdout-json: ""
|
641 |
|
642 |
|
643 |
read -u -3
|
644 |
echo status=$?
|
645 |
## STDOUT:
|
646 |
status=2
|
647 |
## END
|
648 |
## OK bash/zsh STDOUT:
|
649 |
status=1
|
650 |
## END
|
651 |
|
652 |
|
653 |
case $SH in (dash|zsh|ash) exit ;; esac
|
654 |
|
655 |
echo foobar | { read -n 5 -d b; echo $REPLY; }
|
656 |
echo foobar | { read -N 5 -d b; echo $REPLY; }
|
657 |
## STDOUT:
|
658 |
foo
|
659 |
fooba
|
660 |
## END
|
661 |
## OK mksh STDOUT:
|
662 |
fooba
|
663 |
fooba
|
664 |
## END
|
665 |
## N-I dash/zsh/ash stdout-json: ""
|
666 |
|
667 |
|
668 |
|
669 |
# hm DISABLED if we're not going to the terminal
|
670 |
# so we're only testing that it accepts the flag here
|
671 |
|
672 |
case $SH in (dash|mksh|zsh) exit ;; esac
|
673 |
|
674 |
echo hi | { read -p 'P'; echo $REPLY; }
|
675 |
echo hi | { read -p 'P' -n 1; echo $REPLY; }
|
676 |
## STDOUT:
|
677 |
hi
|
678 |
h
|
679 |
## END
|
680 |
## stderr-json: ""
|
681 |
## N-I dash/mksh/zsh stdout-json: ""
|
682 |
|
683 |
|
684 |
read -n -1
|
685 |
echo status=$?
|
686 |
## STDOUT:
|
687 |
status=2
|
688 |
## END
|
689 |
## OK bash stdout: status=1
|
690 |
## BUG mksh stdout-json: ""
|
691 |
# zsh gives a fatal error? seems inconsistent
|
692 |
## BUG zsh stdout-json: ""
|
693 |
## BUG zsh status: 1
|
694 |
|
695 |
|
696 |
echo hi | { read -rn1 var; echo var=$var; }
|
697 |
## STDOUT:
|
698 |
var=h
|
699 |
## END
|
700 |
## N-I dash/zsh STDOUT:
|
701 |
var=
|
702 |
## END
|
703 |
|
704 |
|
705 |
|
706 |
|
707 |
case $SH in (dash|zsh|mksh) exit ;; esac # NOT IMPLEMENTED
|
708 |
|
709 |
mkdir -p read0
|
710 |
cd read0
|
711 |
rm -f *
|
712 |
|
713 |
touch a\\b\\c\\d # -r is necessary!
|
714 |
|
715 |
find . -type f -a -print0 | { read -r -d ''; echo "[$REPLY]"; }
|
716 |
|
717 |
## STDOUT:
|
718 |
[./a\b\c\d]
|
719 |
## END
|
720 |
## N-I dash/zsh/mksh STDOUT:
|
721 |
## END
|
722 |
|
723 |
|
724 |
|
725 |
|
726 |
# This tickles an infinite loop bug in our version of mksh! TODO: upgrade the
|
727 |
# version and enable this
|
728 |
case $SH in (mksh) return ;; esac
|
729 |
|
730 |
cd $TMP
|
731 |
mkdir -p dir
|
732 |
read x < ./dir
|
733 |
echo status=$?
|
734 |
|
735 |
## STDOUT:
|
736 |
status=1
|
737 |
## END
|
738 |
# OK mksh stdout: status=2
|
739 |
## OK mksh stdout-json: ""
|
740 |
|
741 |
|
742 |
|
743 |
case $SH in (dash|ash) return ;; esac # not implemented
|
744 |
|
745 |
# same hanging bug
|
746 |
case $SH in (mksh) return ;; esac
|
747 |
|
748 |
mkdir -p dir
|
749 |
read -n 3 x < ./dir
|
750 |
echo status=$?
|
751 |
## STDOUT:
|
752 |
status=1
|
753 |
## END
|
754 |
## OK mksh stdout-json: ""
|
755 |
## N-I dash/ash stdout-json: ""
|
756 |
|
757 |
|
758 |
case $SH in (dash|ash|mksh|zsh) return ;; esac # not implemented
|
759 |
|
760 |
mkdir -p dir
|
761 |
mapfile $x < ./dir
|
762 |
echo status=$?
|
763 |
|
764 |
## STDOUT:
|
765 |
status=1
|
766 |
## END
|
767 |
## BUG bash STDOUT:
|
768 |
status=0
|
769 |
## END
|
770 |
## N-I dash/ash/mksh/zsh stdout-json: ""
|