summary refs log tree commit diff
path: root/Test/C03traps.ztst
blob: 1c4006cc47838a3fa11fd880afc323d872dc51c7 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
# Tests for both trap builtin and TRAP* functions.

%prep

  setopt localtraps
  mkdir traps.tmp && cd traps.tmp

%test

  fn1() {
    trap 'print EXIT1' EXIT
    fn2() { trap 'print EXIT2' EXIT; }
    fn2
  }
  fn1
0:Nested `trap ... EXIT'
>EXIT2
>EXIT1

  fn1() {
    TRAPEXIT() { print EXIT1; }
    fn2() { TRAPEXIT() { print EXIT2; }; }
    fn2
  }
  fn1
0: Nested TRAPEXIT
>EXIT2
>EXIT1

  fn1() {
    trap 'print EXIT1' EXIT
    fn2() { trap - EXIT; }
    fn2
  }
  fn1
0:Nested `trap - EXIT' on `trap ... EXIT'
>EXIT1

  fn1() {
    TRAPEXIT() { print EXIT1; }
    fn2() { trap - EXIT; }
    fn2
  }
  fn1
0:Nested `trap - EXIT' on `TRAPEXIT'
>EXIT1

# We can't test an EXIT trap for the shell as a whole, because
# we're inside a function scope which we don't leave when the
# subshell exits.  Not sure if that's the correct behaviour, but
# it's sort of consistent.
  ( fn1() { trap 'print Function 1 going' EXIT; exit; print Not reached; }
    fn2() { trap 'print Function 2 going' EXIT; fn1; print Not reached; }
    fn2
  )
0:EXIT traps on functions when exiting from function
>Function 1 going
>Function 2 going

# $ZTST_exe is relative to the parent directory.
# We ought to fix this in ztst.zsh...
  (cd ..
  $ZTST_exe -fc 'TRAPEXIT() { print Exited.; }')
0:EXIT traps on a script
>Exited.

  fn1() {
    trap -
    trap
    trap 'print INT1' INT
    fn2() { trap 'print INT2' INT; trap; }
    trap
    fn2
    trap
  }
  fn1
0: Nested `trap ... INT', not triggered
>trap -- 'print INT1' INT
>trap -- 'print INT2' INT
>trap -- 'print INT1' INT

   fn1() {
    trap -
    trap
    TRAPINT() { print INT1; }
    fn2() { TRAPINT() { print INT2; }; trap; }
    trap
    fn2
    trap
  }
  fn1
0: Nested TRAPINT, not triggered
>TRAPINT () {
>	print INT1
>}
>TRAPINT () {
>	print INT2
>}
>TRAPINT () {
>	print INT1
>}

  fn1() {
    trap -
    trap 'print INT1' INT
    fn2() { trap - INT; trap; }
    trap
    fn2
    trap
  }
  fn1
0: Nested `trap - INT' on untriggered `trap ... INT'
>trap -- 'print INT1' INT
>trap -- 'print INT1' INT

# Testing the triggering of traps here is very unpleasant.
# The delays are attempts to avoid race conditions, though there is
# no guarantee that they will work.  Note the subtlety that the
# `sleep' in the function which receives the trap does *not* get the
# signal, only the parent shell, which is waiting for a SIGCHILD.
# (At least, that's what I think is happening.) Thus we have to wait at
# least the full two seconds to make sure we have got the output from the
# execution of the trap.

  print -u $ZTST_fd 'This test takes at least three seconds...'
  fn1() {
    trap 'print TERM1' TERM
    fn2() { trap 'print TERM2; return 1' TERM; sleep 2; }
    fn2 &
    sleep 1
    kill -TERM $!
    sleep 2
  }
  fn1
0: Nested `trap ... TERM', triggered on inner loop
>TERM2

  print -u $ZTST_fd 'This test, too, takes at least three seconds...'
  fn1() {
    trap 'print TERM1; return 1' TERM
    fn2() { trap 'print TERM2; return 1' TERM; }
    fn2
    sleep 2
  }
  fn1 &
  sleep 1
  kill -TERM $!
  sleep 2
0: Nested `trap ... TERM', triggered on outer loop
>TERM1

  TRAPZERR() { print error activated; }
  fn() { print start of fn; false; print end of fn; }
  fn
  fn() {
    setopt localoptions localtraps
    unfunction TRAPZERR
    print start of fn
    false
    print end of fn
  }
  fn
  unfunction TRAPZERR
  print finish
0: basic localtraps handling
>start of fn
>error activated
>end of fn
>start of fn
>end of fn
>finish

  TRAPZERR() { print 'ERR-or!'; }
  f() { print f; false; }
  t() { print t; }
  f
  f && t
  t && f && true
  t && f
  testunset() {
    setopt localtraps
    unset -f TRAPZERR
    print testunset
    false
    true
  }
  testunset
  f
  print status $?
  unfunction TRAPZERR
0: more sophisticated error trapping
>f
>ERR-or!
>f
>t
>f
>t
>f
>ERR-or!
>testunset
>f
>ERR-or!
>status 1

  f() {
    setopt localtraps
    TRAPWINCH() { print "Window changed.  That wrecked the test."; }
  }
  f
  f
  functions TRAPWINCH
1:Unsetting ordinary traps with localtraps.

#
# Returns from within traps are a perennial problem.
# The following two apply to returns in and around standard
# ksh-style traps.  The intention is that a return value from
# within the function is preserved (i.e. statuses set by the trap
# are ignored) unless the trap explicitly executes `return', which makes
# it return from the enclosing function.
#
  fn() { trap 'true' EXIT; return 1; }
  fn
1: ksh-style EXIT traps preserve return value

  inner() { trap 'return 3' EXIT; return 2; }
  outer() { inner; return 1; }
  outer
3: ksh-style EXIT traps can force return status of enclosing function

# Autoloaded traps are horrid, but unfortunately people expect
# them to work if we support them.
  echo "print Running exit trap" >TRAPEXIT
  ${${ZTST_exe##[^/]*}:-$ZTST_testdir/$ZTST_exe} -fc '
    fpath=(. $fpath)
    autoload TRAPEXIT
    print "Exiting, attempt 1"
    exit
    print "What?"
  '
  ${${ZTST_exe##[^/]*}:-$ZTST_testdir/$ZTST_exe} -fc '
    fpath=(. $fpath)
    autoload TRAPEXIT;
    fn() { print Some function }
    fn
    print "Exiting, attempt 2"
    exit
  '
0: autoloaded TRAPEXIT (exit status > 128 indicates an old bug is back)
>Exiting, attempt 1
>Running exit trap
>Some function
>Exiting, attempt 2
>Running exit trap

  print -u $ZTST_fd Another test that takes three seconds
  gotsig=0
  signal_handler() {
   echo "parent received signal"
   gotsig=1
  }
  child() {
   sleep 1
   echo "child sending signal"
   kill -15 $parentpid
   sleep 2
   echo "child exiting" 
   exit 33
  } 
  parentpid=$$
  child &
  childpid=$!
  trap signal_handler 15
  echo "parent waiting"
  wait $childpid
  cstatus=$?
  echo "wait #1 finished, gotsig=$gotsig, status=$cstatus"
  gotsig=0
  wait $childpid
  cstatus=$?
  echo "wait #2 finished, gotsig=$gotsig, status=$cstatus"
0:waiting for trapped signal
>parent waiting
>child sending signal
>parent received signal
>wait #1 finished, gotsig=1, status=143
>child exiting
>wait #2 finished, gotsig=0, status=33

  fn1() {
    setopt errexit
    trap 'echo error1' ZERR
    false
    print Shouldn\'t get here 1a
  }
  fn2() {
    setopt errexit
    trap 'echo error2' ZERR
    return 1
    print Shouldn\'t get here 2a
  }
  fn3() {
    setopt errexit
    TRAPZERR() { echo error3; }
    false
    print Shouldn\'t get here 3a
  }
  fn4() {
    setopt errexit
    TRAPZERR() { echo error4; }
    return 1
    print Shouldn\'t get here 4a
  }
  (fn1; print Shouldn\'t get here 1b)
  (fn2; print Shouldn\'t get here 2b)
  (fn3; print Shouldn\'t get here 3b)
  (fn4; print Shouldn\'t get here 4b)
1: Combination of ERR_EXIT and ZERR trap
>error1
>error2
>error3
>error4

   fn1() { TRAPZERR() { print trap; return 42; }; false; print Broken; }
   (fn1)
   print Working $?
0: Force return of containing function from TRAPZERR.
>trap
>Working 42

   fn2() { trap 'print trap; return 42' ZERR; false; print Broken }
   (fn2)
   print Working $?
0: Return with non-zero status triggered from within trap '...' ZERR.
>trap
>Working 42

   fn3() { TRAPZERR() { print trap; return 0; }; false; print OK this time; }
   (fn3)
   print Working $?
0: Normal return from TRAPZERR.
>trap
>OK this time
>Working 0

   fn4() { trap 'print trap; return 0' ZERR; false; print Broken; }
   (fn4)
   print Working $?
0: Return with zero status triggered from within trap '...' ZERR.
>trap
>Working 0

   { trap 'echo This subshell is exiting' EXIT; } | cat
0: EXIT trap set in current shell at left of pipeline
>This subshell is exiting

   ( trap 'echo This subshell is also exiting' EXIT; ) | cat
0: EXIT trap set in subshell at left of pipeline
>This subshell is also exiting

   ( trap 'echo Should only appear once at the end' EXIT
     ( : trap reset here ) | cat
     : trap not reset but not part of shell command list | cat
     echo nothing after this should appear $( : trap reset here too)
   )
0: EXIT trap set in subshell reset in subsubshell
>nothing after this should appear
>Should only appear once at the end

   echo $( trap 'echo command substitution exited' EXIT )
0: EXIT trap set in command substitution
>command substitution exited

%clean

  rm -f TRAPEXIT