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
|
" Test signal handling.
source check.vim
source term_util.vim
CheckUnix
source shared.vim
" Check whether a signal is available on this system.
func HasSignal(signal)
let signals = system('kill -l')
return signals =~# '\<' .. a:signal .. '\>'
endfunc
" Test signal WINCH (window resize signal)
func Test_signal_WINCH()
CheckNotGui
if !HasSignal('WINCH')
throw 'Skipped: WINCH signal not supported'
endif
" We do not actually want to change the size of the terminal.
let old_WS = ''
if exists('&t_WS')
let old_WS = &t_WS
let &t_WS = ''
endif
let old_lines = &lines
let old_columns = &columns
let new_lines = &lines - 2
let new_columns = &columns - 2
exe 'set lines=' .. new_lines
exe 'set columns=' .. new_columns
call assert_equal(new_lines, &lines)
call assert_equal(new_columns, &columns)
" Send signal and wait for signal to be processed.
" 'lines' and 'columns' should have been restored
" after handing signal WINCH.
exe 'silent !kill -s WINCH ' .. getpid()
call WaitForAssert({-> assert_equal(old_lines, &lines)})
call assert_equal(old_columns, &columns)
if old_WS != ''
let &t_WS = old_WS
endif
endfunc
" Test signal PWR, which should update the swap file.
func Test_signal_PWR()
if !HasSignal('PWR')
throw 'Skipped: PWR signal not supported'
endif
" Set a very large 'updatetime' and 'updatecount', so that we can be sure
" that swap file is updated as a result of sending PWR signal, and not
" because of exceeding 'updatetime' or 'updatecount' when changing buffer.
set updatetime=100000 updatecount=100000
new Xtest_signal_PWR
let swap_name = swapname('%')
call setline(1, '123')
preserve
let swap_content = readfile(swap_name, 'b')
" Update the buffer and check that the swap file is not yet updated,
" since we set 'updatetime' and 'updatecount' to large values.
call setline(1, 'abc')
call assert_equal(swap_content, readfile(swap_name, 'b'))
" Sending PWR signal should update the swap file.
exe 'silent !kill -s PWR ' .. getpid()
call WaitForAssert({-> assert_notequal(swap_content, readfile(swap_name, 'b'))})
bwipe!
set updatetime& updatecount&
endfunc
" Test signal INT. Handler sets got_int. It should be like typing CTRL-C.
func Test_signal_INT()
CheckRunVimInTerminal
if !HasSignal('INT')
throw 'Skipped: INT signal not supported'
endif
let buf = RunVimInTerminal('', {'rows': 6})
let pid_vim = term_getjob(buf)->job_info().process
" Check that an endless loop in Vim is interrupted by signal INT.
call term_sendkeys(buf, ":call setline(1, 'running')\n")
call term_sendkeys(buf, ":while 1 | endwhile\n")
call WaitForAssert({-> assert_equal(':while 1 | endwhile', term_getline(buf, 6))})
exe 'silent !kill -s INT ' .. pid_vim
sleep 50m
call term_sendkeys(buf, ":call setline(1, 'INTERRUPTED')\n")
call WaitForAssert({-> assert_equal('INTERRUPTED', term_getline(buf, 1))})
call StopVimInTerminal(buf)
endfunc
" Test signal TSTP. Handler sets got_tstp.
func Test_signal_TSTP()
CheckRunVimInTerminal
if !HasSignal('TSTP')
throw 'Skipped: TSTP signal not supported'
endif
" If test fails once, it can leave temporary files and trying to rerun
" the test would then fail again if they are not deleted first.
call delete('.Xsig_TERM.swp')
call delete('XsetupAucmd')
call delete('XautoOut1')
call delete('XautoOut2')
let lines =<< trim END
au VimSuspend * call writefile(["VimSuspend triggered"], "XautoOut1", "as")
au VimResume * call writefile(["VimResume triggered"], "XautoOut2", "as")
END
call writefile(lines, 'XsetupAucmd', 'D')
let buf = RunVimInTerminal('-S XsetupAucmd Xsig_TERM', {'rows': 6})
let pid_vim = term_getjob(buf)->job_info().process
call term_sendkeys(buf, ":call setline(1, 'foo')\n")
call WaitForAssert({-> assert_equal('foo', term_getline(buf, 1))})
call assert_false(filereadable('Xsig_TERM'))
" After TSTP the file is not saved (same function as ^Z)
exe 'silent !kill -s TSTP ' .. pid_vim
call WaitForAssert({-> assert_true(filereadable('.Xsig_TERM.swp'))})
sleep 100m
" We resume after the suspend. Sleep a bit for the signal to take effect,
" also when running under valgrind.
exe 'silent !kill -s CONT ' .. pid_vim
call WaitForAssert({-> assert_true(filereadable('XautoOut2'))})
sleep 10m
call StopVimInTerminal(buf)
let result = readfile('XautoOut1')
call assert_equal(["VimSuspend triggered"], result)
let result = readfile('XautoOut2')
call assert_equal(["VimResume triggered"], result)
%bwipe!
call delete('.Xsig_TERM.swp')
call delete('XautoOut1')
call delete('XautoOut2')
endfunc
" Test a deadly signal.
"
" There are several deadly signals: SISEGV, SIBUS, SIGTERM...
" Test uses signal SIGTERM as it does not create a core
" dump file unlike SIGSEGV, SIGBUS, etc. See "man 7 signals.
"
" Vim should exit with a deadly signal and unsaved changes
" should be recoverable from the swap file preserved as a
" result of the deadly signal handler.
func Test_deadly_signal_TERM()
if !HasSignal('TERM')
throw 'Skipped: TERM signal not supported'
endif
CheckRunVimInTerminal
" If test fails once, it can leave temporary files and trying to rerun
" the test would then fail again if they are not deleted first.
call delete('.Xsig_TERM.swp')
call delete('XsetupAucmd')
call delete('XautoOut')
let lines =<< trim END
au VimLeave * call writefile(["VimLeave triggered"], "XautoOut", "as")
au VimLeavePre * call writefile(["VimLeavePre triggered"], "XautoOut", "as")
END
call writefile(lines, 'XsetupAucmd', 'D')
let buf = RunVimInTerminal('-S XsetupAucmd Xsig_TERM', {'rows': 6})
let pid_vim = term_getjob(buf)->job_info().process
call term_sendkeys(buf, ":call setline(1, 'foo')\n")
call WaitForAssert({-> assert_equal('foo', term_getline(buf, 1))})
call assert_false(filereadable('Xsig_TERM'))
exe 'silent !kill -s TERM ' .. pid_vim
call WaitForAssert({-> assert_true(filereadable('.Xsig_TERM.swp'))})
" Don't call StopVimInTerminal() as it expects job to be still running.
call WaitForAssert({-> assert_equal("finished", term_getstatus(buf))})
new
silent recover .Xsig_TERM.swp
call assert_equal(['foo'], getline(1, '$'))
let result = readfile('XautoOut')
call assert_equal(["VimLeavePre triggered", "VimLeave triggered"], result)
%bwipe!
call delete('.Xsig_TERM.swp')
call delete('XautoOut')
endfunc
" vim: ts=8 sw=2 sts=2 tw=80 fdm=marker
|
