Bram Moolenaar | f386f08 | 2019-07-29 23:03:03 +0200 | [diff] [blame] | 1 | " Test for channel and job functions. |
Bram Moolenaar | d7ece10 | 2016-02-02 23:23:02 +0100 | [diff] [blame] | 2 | |
Bram Moolenaar | f386f08 | 2019-07-29 23:03:03 +0200 | [diff] [blame] | 3 | " When +channel is supported then +job is too, so we don't check for that. |
Bram Moolenaar | 4641a12 | 2019-07-29 22:10:23 +0200 | [diff] [blame] | 4 | source check.vim |
| 5 | CheckFeature channel |
Bram Moolenaar | e246925 | 2016-02-04 10:54:34 +0100 | [diff] [blame] | 6 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 7 | source shared.vim |
Bram Moolenaar | 4641a12 | 2019-07-29 22:10:23 +0200 | [diff] [blame] | 8 | source screendump.vim |
Bram Moolenaar | dfc33a6 | 2020-04-29 22:30:13 +0200 | [diff] [blame] | 9 | source view_util.vim |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 10 | |
| 11 | let s:python = PythonProg() |
| 12 | if s:python == '' |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 13 | " Can't run this test without Python. |
Bram Moolenaar | 5d30ff1 | 2019-06-06 16:12:12 +0200 | [diff] [blame] | 14 | throw 'Skipped: Python command missing' |
Bram Moolenaar | d7ece10 | 2016-02-02 23:23:02 +0100 | [diff] [blame] | 15 | endif |
| 16 | |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 17 | " Uncomment the next line to see what happens. Output is in |
| 18 | " src/testdir/channellog. |
Bram Moolenaar | f386f08 | 2019-07-29 23:03:03 +0200 | [diff] [blame] | 19 | " Add ch_log() calls where you want to see what happens. |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 20 | " call ch_logfile('channellog', 'w') |
| 21 | |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 22 | func SetUp() |
| 23 | if g:testfunc =~ '_ipv6()$' |
| 24 | let s:localhost = '[::1]:' |
| 25 | let s:testscript = 'test_channel_6.py' |
| 26 | else |
| 27 | let s:localhost = 'localhost:' |
| 28 | let s:testscript = 'test_channel.py' |
| 29 | endif |
| 30 | let s:chopt = {} |
| 31 | call ch_log(g:testfunc) |
Bram Moolenaar | ec9b017 | 2020-06-19 19:10:59 +0200 | [diff] [blame] | 32 | |
| 33 | " Most tests use job_start(), which can be flaky |
| 34 | let g:test_is_flaky = 1 |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 35 | endfunc |
Bram Moolenaar | 3b05b13 | 2016-02-03 23:25:07 +0100 | [diff] [blame] | 36 | |
Bram Moolenaar | 4b96df5 | 2020-01-26 22:00:26 +0100 | [diff] [blame] | 37 | " Run "testfunc" after starting the server and stop the server afterwards. |
Bram Moolenaar | 81661fb | 2016-02-18 22:23:34 +0100 | [diff] [blame] | 38 | func s:run_server(testfunc, ...) |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 39 | call RunServer(s:testscript, a:testfunc, a:000) |
Bram Moolenaar | fcb1e3d | 2016-02-03 21:32:46 +0100 | [diff] [blame] | 40 | endfunc |
| 41 | |
Bram Moolenaar | 81952470 | 2018-02-27 19:10:00 +0100 | [diff] [blame] | 42 | " Return a list of open files. |
| 43 | " Can be used to make sure no resources leaked. |
| 44 | " Returns an empty list on systems where this is not supported. |
| 45 | func s:get_resources() |
| 46 | let pid = getpid() |
| 47 | |
Bram Moolenaar | 39536dd | 2019-01-29 22:58:21 +0100 | [diff] [blame] | 48 | if executable('lsof') |
Bram Moolenaar | 81952470 | 2018-02-27 19:10:00 +0100 | [diff] [blame] | 49 | return systemlist('lsof -p ' . pid . ' | awk ''$4~/^[0-9]*[rwu]$/&&$5=="REG"{print$NF}''') |
| 50 | elseif isdirectory('/proc/' . pid . '/fd/') |
| 51 | return systemlist('readlink /proc/' . pid . '/fd/* | grep -v ''^/dev/''') |
| 52 | else |
| 53 | return [] |
| 54 | endif |
| 55 | endfunc |
| 56 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 57 | let g:Ch_responseMsg = '' |
| 58 | func Ch_requestHandler(handle, msg) |
| 59 | let g:Ch_responseHandle = a:handle |
| 60 | let g:Ch_responseMsg = a:msg |
Bram Moolenaar | fcb1e3d | 2016-02-03 21:32:46 +0100 | [diff] [blame] | 61 | endfunc |
| 62 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 63 | func Ch_communicate(port) |
Bram Moolenaar | 5643db8 | 2016-12-03 14:29:10 +0100 | [diff] [blame] | 64 | " Avoid dropping messages, since we don't use a callback here. |
| 65 | let s:chopt.drop = 'never' |
Bram Moolenaar | 0b14688 | 2018-09-06 16:27:24 +0200 | [diff] [blame] | 66 | " Also add the noblock flag to try it out. |
| 67 | let s:chopt.noblock = 1 |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 68 | let handle = ch_open(s:localhost . a:port, s:chopt) |
Bram Moolenaar | 7707344 | 2016-02-13 23:23:53 +0100 | [diff] [blame] | 69 | if ch_status(handle) == "fail" |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 70 | call assert_report("Can't open channel") |
Bram Moolenaar | fcb1e3d | 2016-02-03 21:32:46 +0100 | [diff] [blame] | 71 | return |
| 72 | endif |
Bram Moolenaar | f386f08 | 2019-07-29 23:03:03 +0200 | [diff] [blame] | 73 | |
| 74 | " check that getjob without a job is handled correctly |
| 75 | call assert_equal('no process', string(ch_getjob(handle))) |
| 76 | |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 77 | let dict = handle->ch_info() |
Bram Moolenaar | 03602ec | 2016-03-20 20:57:45 +0100 | [diff] [blame] | 78 | call assert_true(dict.id != 0) |
| 79 | call assert_equal('open', dict.status) |
| 80 | call assert_equal(a:port, string(dict.port)) |
| 81 | call assert_equal('open', dict.sock_status) |
| 82 | call assert_equal('socket', dict.sock_io) |
| 83 | |
Bram Moolenaar | d7ece10 | 2016-02-02 23:23:02 +0100 | [diff] [blame] | 84 | " Simple string request and reply. |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 85 | call assert_equal('got it', ch_evalexpr(handle, 'hello!')) |
Bram Moolenaar | d7ece10 | 2016-02-02 23:23:02 +0100 | [diff] [blame] | 86 | |
Bram Moolenaar | ac74d5e | 2016-03-20 14:31:00 +0100 | [diff] [blame] | 87 | " Malformed command should be ignored. |
Bram Moolenaar | ba61ac0 | 2016-03-20 16:40:37 +0100 | [diff] [blame] | 88 | call assert_equal('ok', ch_evalexpr(handle, 'malformed1')) |
| 89 | call assert_equal('ok', ch_evalexpr(handle, 'malformed2')) |
| 90 | call assert_equal('ok', ch_evalexpr(handle, 'malformed3')) |
| 91 | |
| 92 | " split command should work |
| 93 | call assert_equal('ok', ch_evalexpr(handle, 'split')) |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 94 | call WaitFor('exists("g:split")') |
Bram Moolenaar | ba61ac0 | 2016-03-20 16:40:37 +0100 | [diff] [blame] | 95 | call assert_equal(123, g:split) |
Bram Moolenaar | ac74d5e | 2016-03-20 14:31:00 +0100 | [diff] [blame] | 96 | |
Bram Moolenaar | f1f0792 | 2016-08-26 17:58:53 +0200 | [diff] [blame] | 97 | " string with ][ should work |
| 98 | call assert_equal('this][that', ch_evalexpr(handle, 'echo this][that')) |
| 99 | |
Bram Moolenaar | 4b785f6 | 2016-11-29 21:54:44 +0100 | [diff] [blame] | 100 | " nothing to read now |
| 101 | call assert_equal(0, ch_canread(handle)) |
| 102 | |
Bram Moolenaar | f1f0792 | 2016-08-26 17:58:53 +0200 | [diff] [blame] | 103 | " sending three messages quickly then reading should work |
| 104 | for i in range(3) |
| 105 | call ch_sendexpr(handle, 'echo hello ' . i) |
| 106 | endfor |
| 107 | call assert_equal('hello 0', ch_read(handle)[1]) |
| 108 | call assert_equal('hello 1', ch_read(handle)[1]) |
| 109 | call assert_equal('hello 2', ch_read(handle)[1]) |
| 110 | |
Bram Moolenaar | d7ece10 | 2016-02-02 23:23:02 +0100 | [diff] [blame] | 111 | " Request that triggers sending two ex commands. These will usually be |
| 112 | " handled before getting the response, but it's not guaranteed, thus wait a |
| 113 | " tiny bit for the commands to get executed. |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 114 | call assert_equal('ok', ch_evalexpr(handle, 'make change')) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 115 | call WaitForAssert({-> assert_equal("added2", getline("$"))}) |
Bram Moolenaar | d7ece10 | 2016-02-02 23:23:02 +0100 | [diff] [blame] | 116 | call assert_equal('added1', getline(line('$') - 1)) |
Bram Moolenaar | d7ece10 | 2016-02-02 23:23:02 +0100 | [diff] [blame] | 117 | |
Bram Moolenaar | b836f63 | 2021-07-01 22:11:28 +0200 | [diff] [blame] | 118 | " Request command "echoerr 'this is an error'". |
| 119 | " This will throw an exception, catch it here. |
| 120 | let caught = 'no' |
| 121 | try |
| 122 | call assert_equal('ok', ch_evalexpr(handle, 'echoerr')) |
| 123 | catch /this is an error/ |
| 124 | let caught = 'yes' |
| 125 | endtry |
| 126 | if caught != 'yes' |
| 127 | call assert_report("Expected exception from error message") |
| 128 | endif |
| 129 | |
Bram Moolenaar | c4dcd60 | 2016-03-26 22:56:46 +0100 | [diff] [blame] | 130 | " Request command "foo bar", which fails silently. |
| 131 | call assert_equal('ok', ch_evalexpr(handle, 'bad command')) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 132 | call WaitForAssert({-> assert_match("E492:.*foo bar", v:errmsg)}) |
Bram Moolenaar | c4dcd60 | 2016-03-26 22:56:46 +0100 | [diff] [blame] | 133 | |
Bram Moolenaar | da94fdf | 2016-03-03 18:09:10 +0100 | [diff] [blame] | 134 | call assert_equal('ok', ch_evalexpr(handle, 'do normal', {'timeout': 100})) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 135 | call WaitForAssert({-> assert_equal('added more', getline('$'))}) |
Bram Moolenaar | f416086 | 2016-02-05 23:09:12 +0100 | [diff] [blame] | 136 | |
Bram Moolenaar | a07fec9 | 2016-02-05 21:04:08 +0100 | [diff] [blame] | 137 | " Send a request with a specific handler. |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 138 | call ch_sendexpr(handle, 'hello!', {'callback': 'Ch_requestHandler'}) |
| 139 | call WaitFor('exists("g:Ch_responseHandle")') |
| 140 | if !exists('g:Ch_responseHandle') |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 141 | call assert_report('g:Ch_responseHandle was not set') |
Bram Moolenaar | 7707344 | 2016-02-13 23:23:53 +0100 | [diff] [blame] | 142 | else |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 143 | call assert_equal(handle, g:Ch_responseHandle) |
| 144 | unlet g:Ch_responseHandle |
Bram Moolenaar | 7707344 | 2016-02-13 23:23:53 +0100 | [diff] [blame] | 145 | endif |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 146 | call assert_equal('got it', g:Ch_responseMsg) |
Bram Moolenaar | a07fec9 | 2016-02-05 21:04:08 +0100 | [diff] [blame] | 147 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 148 | let g:Ch_responseMsg = '' |
| 149 | call ch_sendexpr(handle, 'hello!', {'callback': function('Ch_requestHandler')}) |
| 150 | call WaitFor('exists("g:Ch_responseHandle")') |
| 151 | if !exists('g:Ch_responseHandle') |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 152 | call assert_report('g:Ch_responseHandle was not set') |
Bram Moolenaar | 7707344 | 2016-02-13 23:23:53 +0100 | [diff] [blame] | 153 | else |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 154 | call assert_equal(handle, g:Ch_responseHandle) |
| 155 | unlet g:Ch_responseHandle |
Bram Moolenaar | 7707344 | 2016-02-13 23:23:53 +0100 | [diff] [blame] | 156 | endif |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 157 | call assert_equal('got it', g:Ch_responseMsg) |
Bram Moolenaar | b6a4fee | 2016-02-11 20:48:34 +0100 | [diff] [blame] | 158 | |
Bram Moolenaar | 069c1e7 | 2016-07-15 21:25:08 +0200 | [diff] [blame] | 159 | " Using lambda. |
| 160 | let g:Ch_responseMsg = '' |
| 161 | call ch_sendexpr(handle, 'hello!', {'callback': {a, b -> Ch_requestHandler(a, b)}}) |
| 162 | call WaitFor('exists("g:Ch_responseHandle")') |
| 163 | if !exists('g:Ch_responseHandle') |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 164 | call assert_report('g:Ch_responseHandle was not set') |
Bram Moolenaar | 069c1e7 | 2016-07-15 21:25:08 +0200 | [diff] [blame] | 165 | else |
| 166 | call assert_equal(handle, g:Ch_responseHandle) |
| 167 | unlet g:Ch_responseHandle |
| 168 | endif |
| 169 | call assert_equal('got it', g:Ch_responseMsg) |
| 170 | |
Bram Moolenaar | 38fd4bb | 2016-03-06 16:38:28 +0100 | [diff] [blame] | 171 | " Collect garbage, tests that our handle isn't collected. |
Bram Moolenaar | 574860b | 2016-05-24 17:33:34 +0200 | [diff] [blame] | 172 | call test_garbagecollect_now() |
Bram Moolenaar | 38fd4bb | 2016-03-06 16:38:28 +0100 | [diff] [blame] | 173 | |
Bram Moolenaar | 40ea1da | 2016-02-19 22:33:35 +0100 | [diff] [blame] | 174 | " check setting options (without testing the effect) |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 175 | eval handle->ch_setoptions({'callback': 's:NotUsed'}) |
Bram Moolenaar | 1f6ef66 | 2016-02-19 22:59:44 +0100 | [diff] [blame] | 176 | call ch_setoptions(handle, {'timeout': 1111}) |
Bram Moolenaar | b6b5252 | 2016-02-20 23:30:07 +0100 | [diff] [blame] | 177 | call ch_setoptions(handle, {'mode': 'json'}) |
Bram Moolenaar | e2e4075 | 2020-09-04 21:18:46 +0200 | [diff] [blame] | 178 | call assert_fails("call ch_setoptions(handle, {'waittime': 111})", 'E475:') |
Bram Moolenaar | 0ba75a9 | 2016-02-19 23:21:26 +0100 | [diff] [blame] | 179 | call ch_setoptions(handle, {'callback': ''}) |
Bram Moolenaar | 65e08ee | 2016-12-01 16:41:50 +0100 | [diff] [blame] | 180 | call ch_setoptions(handle, {'drop': 'never'}) |
| 181 | call ch_setoptions(handle, {'drop': 'auto'}) |
Bram Moolenaar | e2e4075 | 2020-09-04 21:18:46 +0200 | [diff] [blame] | 182 | call assert_fails("call ch_setoptions(handle, {'drop': 'bad'})", 'E475:') |
Bram Moolenaar | ad48e6c | 2020-04-21 22:19:45 +0200 | [diff] [blame] | 183 | call assert_equal(0, ch_setoptions(handle, test_null_dict())) |
| 184 | call assert_equal(0, ch_setoptions(test_null_channel(), {'drop' : 'never'})) |
Bram Moolenaar | 40ea1da | 2016-02-19 22:33:35 +0100 | [diff] [blame] | 185 | |
Bram Moolenaar | fcb1e3d | 2016-02-03 21:32:46 +0100 | [diff] [blame] | 186 | " Send an eval request that works. |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 187 | call assert_equal('ok', ch_evalexpr(handle, 'eval-works')) |
Bram Moolenaar | a02b321 | 2016-02-04 21:03:33 +0100 | [diff] [blame] | 188 | sleep 10m |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 189 | call assert_equal([-1, 'foo123'], ch_evalexpr(handle, 'eval-result')) |
Bram Moolenaar | fcb1e3d | 2016-02-03 21:32:46 +0100 | [diff] [blame] | 190 | |
Bram Moolenaar | fa8b2e1 | 2016-03-26 22:19:27 +0100 | [diff] [blame] | 191 | " Send an eval request with special characters. |
| 192 | call assert_equal('ok', ch_evalexpr(handle, 'eval-special')) |
| 193 | sleep 10m |
| 194 | call assert_equal([-2, "foo\x7f\x10\x01bar"], ch_evalexpr(handle, 'eval-result')) |
| 195 | |
| 196 | " Send an eval request to get a line with special characters. |
| 197 | call setline(3, "a\nb\<CR>c\x01d\x7fe") |
| 198 | call assert_equal('ok', ch_evalexpr(handle, 'eval-getline')) |
| 199 | sleep 10m |
| 200 | call assert_equal([-3, "a\nb\<CR>c\x01d\x7fe"], ch_evalexpr(handle, 'eval-result')) |
| 201 | |
Bram Moolenaar | fcb1e3d | 2016-02-03 21:32:46 +0100 | [diff] [blame] | 202 | " Send an eval request that fails. |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 203 | call assert_equal('ok', ch_evalexpr(handle, 'eval-fails')) |
Bram Moolenaar | a02b321 | 2016-02-04 21:03:33 +0100 | [diff] [blame] | 204 | sleep 10m |
Bram Moolenaar | fa8b2e1 | 2016-03-26 22:19:27 +0100 | [diff] [blame] | 205 | call assert_equal([-4, 'ERROR'], ch_evalexpr(handle, 'eval-result')) |
Bram Moolenaar | fcb1e3d | 2016-02-03 21:32:46 +0100 | [diff] [blame] | 206 | |
Bram Moolenaar | 55fab43 | 2016-02-07 16:53:13 +0100 | [diff] [blame] | 207 | " Send an eval request that works but can't be encoded. |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 208 | call assert_equal('ok', ch_evalexpr(handle, 'eval-error')) |
Bram Moolenaar | 55fab43 | 2016-02-07 16:53:13 +0100 | [diff] [blame] | 209 | sleep 10m |
Bram Moolenaar | fa8b2e1 | 2016-03-26 22:19:27 +0100 | [diff] [blame] | 210 | call assert_equal([-5, 'ERROR'], ch_evalexpr(handle, 'eval-result')) |
Bram Moolenaar | 55fab43 | 2016-02-07 16:53:13 +0100 | [diff] [blame] | 211 | |
Bram Moolenaar | 66624ff | 2016-02-03 23:59:43 +0100 | [diff] [blame] | 212 | " Send a bad eval request. There will be no response. |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 213 | call assert_equal('ok', ch_evalexpr(handle, 'eval-bad')) |
Bram Moolenaar | a02b321 | 2016-02-04 21:03:33 +0100 | [diff] [blame] | 214 | sleep 10m |
Bram Moolenaar | fa8b2e1 | 2016-03-26 22:19:27 +0100 | [diff] [blame] | 215 | call assert_equal([-5, 'ERROR'], ch_evalexpr(handle, 'eval-result')) |
Bram Moolenaar | 66624ff | 2016-02-03 23:59:43 +0100 | [diff] [blame] | 216 | |
Bram Moolenaar | f416086 | 2016-02-05 23:09:12 +0100 | [diff] [blame] | 217 | " Send an expr request |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 218 | call assert_equal('ok', ch_evalexpr(handle, 'an expr')) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 219 | call WaitForAssert({-> assert_equal('three', getline('$'))}) |
Bram Moolenaar | f416086 | 2016-02-05 23:09:12 +0100 | [diff] [blame] | 220 | call assert_equal('one', getline(line('$') - 2)) |
| 221 | call assert_equal('two', getline(line('$') - 1)) |
Bram Moolenaar | f416086 | 2016-02-05 23:09:12 +0100 | [diff] [blame] | 222 | |
| 223 | " Request a redraw, we don't check for the effect. |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 224 | call assert_equal('ok', ch_evalexpr(handle, 'redraw')) |
| 225 | call assert_equal('ok', ch_evalexpr(handle, 'redraw!')) |
Bram Moolenaar | f416086 | 2016-02-05 23:09:12 +0100 | [diff] [blame] | 226 | |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 227 | call assert_equal('ok', ch_evalexpr(handle, 'empty-request')) |
Bram Moolenaar | f416086 | 2016-02-05 23:09:12 +0100 | [diff] [blame] | 228 | |
Bram Moolenaar | 6f3a544 | 2016-02-20 19:56:13 +0100 | [diff] [blame] | 229 | " Reading while there is nothing available. |
Bram Moolenaar | 9186a27 | 2016-02-23 19:34:01 +0100 | [diff] [blame] | 230 | call assert_equal(v:none, ch_read(handle, {'timeout': 0})) |
Bram Moolenaar | 5feabe0 | 2020-01-30 18:24:53 +0100 | [diff] [blame] | 231 | if exists('*reltimefloat') |
| 232 | let start = reltime() |
| 233 | call assert_equal(v:none, ch_read(handle, {'timeout': 333})) |
| 234 | let elapsed = reltime(start) |
| 235 | call assert_inrange(0.3, 0.6, reltimefloat(reltime(start))) |
| 236 | endif |
Bram Moolenaar | 6f3a544 | 2016-02-20 19:56:13 +0100 | [diff] [blame] | 237 | |
| 238 | " Send without waiting for a response, then wait for a response. |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 239 | call ch_sendexpr(handle, 'wait a bit') |
Bram Moolenaar | 6f3a544 | 2016-02-20 19:56:13 +0100 | [diff] [blame] | 240 | let resp = ch_read(handle) |
| 241 | call assert_equal(type([]), type(resp)) |
| 242 | call assert_equal(type(11), type(resp[0])) |
| 243 | call assert_equal('waited', resp[1]) |
| 244 | |
Bram Moolenaar | d7ece10 | 2016-02-02 23:23:02 +0100 | [diff] [blame] | 245 | " make the server quit, can't check if this works, should not hang. |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 246 | call ch_sendexpr(handle, '!quit!') |
Bram Moolenaar | d6a8d48 | 2016-02-10 20:32:20 +0100 | [diff] [blame] | 247 | endfunc |
Bram Moolenaar | d7ece10 | 2016-02-02 23:23:02 +0100 | [diff] [blame] | 248 | |
Bram Moolenaar | d6a8d48 | 2016-02-10 20:32:20 +0100 | [diff] [blame] | 249 | func Test_communicate() |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 250 | call s:run_server('Ch_communicate') |
Bram Moolenaar | d7ece10 | 2016-02-02 23:23:02 +0100 | [diff] [blame] | 251 | endfunc |
Bram Moolenaar | fcb1e3d | 2016-02-03 21:32:46 +0100 | [diff] [blame] | 252 | |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 253 | func Test_communicate_ipv6() |
| 254 | CheckIPv6 |
| 255 | call Test_communicate() |
| 256 | endfunc |
| 257 | |
Bram Moolenaar | 3b05b13 | 2016-02-03 23:25:07 +0100 | [diff] [blame] | 258 | " Test that we can open two channels. |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 259 | func Ch_two_channels(port) |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 260 | let handle = ch_open(s:localhost . a:port, s:chopt) |
Bram Moolenaar | f562e72 | 2016-07-19 17:25:25 +0200 | [diff] [blame] | 261 | call assert_equal(v:t_channel, type(handle)) |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 262 | if handle->ch_status() == "fail" |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 263 | call assert_report("Can't open channel") |
Bram Moolenaar | 3b05b13 | 2016-02-03 23:25:07 +0100 | [diff] [blame] | 264 | return |
| 265 | endif |
Bram Moolenaar | d6a8d48 | 2016-02-10 20:32:20 +0100 | [diff] [blame] | 266 | |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 267 | call assert_equal('got it', ch_evalexpr(handle, 'hello!')) |
Bram Moolenaar | 3b05b13 | 2016-02-03 23:25:07 +0100 | [diff] [blame] | 268 | |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 269 | let newhandle = ch_open(s:localhost . a:port, s:chopt) |
Bram Moolenaar | 7707344 | 2016-02-13 23:23:53 +0100 | [diff] [blame] | 270 | if ch_status(newhandle) == "fail" |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 271 | call assert_report("Can't open second channel") |
Bram Moolenaar | d6a8d48 | 2016-02-10 20:32:20 +0100 | [diff] [blame] | 272 | return |
| 273 | endif |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 274 | call assert_equal('got it', ch_evalexpr(newhandle, 'hello!')) |
| 275 | call assert_equal('got it', ch_evalexpr(handle, 'hello!')) |
Bram Moolenaar | 3b05b13 | 2016-02-03 23:25:07 +0100 | [diff] [blame] | 276 | |
| 277 | call ch_close(handle) |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 278 | call assert_equal('got it', ch_evalexpr(newhandle, 'hello!')) |
Bram Moolenaar | 3b05b13 | 2016-02-03 23:25:07 +0100 | [diff] [blame] | 279 | |
Bram Moolenaar | d6a8d48 | 2016-02-10 20:32:20 +0100 | [diff] [blame] | 280 | call ch_close(newhandle) |
Bram Moolenaar | ca68ae1 | 2020-03-30 19:32:53 +0200 | [diff] [blame] | 281 | call assert_fails("call ch_close(newhandle)", 'E906:') |
Bram Moolenaar | d6a8d48 | 2016-02-10 20:32:20 +0100 | [diff] [blame] | 282 | endfunc |
| 283 | |
| 284 | func Test_two_channels() |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 285 | eval 'Test_two_channels()'->ch_log() |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 286 | call s:run_server('Ch_two_channels') |
Bram Moolenaar | 3b05b13 | 2016-02-03 23:25:07 +0100 | [diff] [blame] | 287 | endfunc |
| 288 | |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 289 | func Test_two_channels_ipv6() |
| 290 | CheckIPv6 |
| 291 | call Test_two_channels() |
| 292 | endfunc |
| 293 | |
Bram Moolenaar | fcb1e3d | 2016-02-03 21:32:46 +0100 | [diff] [blame] | 294 | " Test that a server crash is handled gracefully. |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 295 | func Ch_server_crash(port) |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 296 | let handle = ch_open(s:localhost . a:port, s:chopt) |
Bram Moolenaar | 7707344 | 2016-02-13 23:23:53 +0100 | [diff] [blame] | 297 | if ch_status(handle) == "fail" |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 298 | call assert_report("Can't open channel") |
Bram Moolenaar | fcb1e3d | 2016-02-03 21:32:46 +0100 | [diff] [blame] | 299 | return |
| 300 | endif |
Bram Moolenaar | d6a8d48 | 2016-02-10 20:32:20 +0100 | [diff] [blame] | 301 | |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 302 | call ch_evalexpr(handle, '!crash!') |
Bram Moolenaar | fcb1e3d | 2016-02-03 21:32:46 +0100 | [diff] [blame] | 303 | |
Bram Moolenaar | fcb1e3d | 2016-02-03 21:32:46 +0100 | [diff] [blame] | 304 | sleep 10m |
Bram Moolenaar | d6a8d48 | 2016-02-10 20:32:20 +0100 | [diff] [blame] | 305 | endfunc |
| 306 | |
| 307 | func Test_server_crash() |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 308 | call s:run_server('Ch_server_crash') |
Bram Moolenaar | fcb1e3d | 2016-02-03 21:32:46 +0100 | [diff] [blame] | 309 | endfunc |
Bram Moolenaar | 7a84dbe | 2016-02-07 21:29:00 +0100 | [diff] [blame] | 310 | |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 311 | func Test_server_crash_ipv6() |
| 312 | CheckIPv6 |
| 313 | call Test_server_crash() |
| 314 | endfunc |
| 315 | |
Bram Moolenaar | d6547fc | 2016-03-03 19:35:02 +0100 | [diff] [blame] | 316 | """"""""" |
| 317 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 318 | func Ch_handler(chan, msg) |
Bram Moolenaar | 65e08ee | 2016-12-01 16:41:50 +0100 | [diff] [blame] | 319 | call ch_log('Ch_handler()') |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 320 | unlet g:Ch_reply |
| 321 | let g:Ch_reply = a:msg |
Bram Moolenaar | f615728 | 2016-02-10 21:07:14 +0100 | [diff] [blame] | 322 | endfunc |
| 323 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 324 | func Ch_channel_handler(port) |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 325 | let handle = ch_open(s:localhost . a:port, s:chopt) |
Bram Moolenaar | 7707344 | 2016-02-13 23:23:53 +0100 | [diff] [blame] | 326 | if ch_status(handle) == "fail" |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 327 | call assert_report("Can't open channel") |
Bram Moolenaar | f615728 | 2016-02-10 21:07:14 +0100 | [diff] [blame] | 328 | return |
| 329 | endif |
| 330 | |
| 331 | " Test that it works while waiting on a numbered message. |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 332 | call assert_equal('ok', ch_evalexpr(handle, 'call me')) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 333 | call WaitForAssert({-> assert_equal('we called you', g:Ch_reply)}) |
Bram Moolenaar | f615728 | 2016-02-10 21:07:14 +0100 | [diff] [blame] | 334 | |
| 335 | " Test that it works while not waiting on a numbered message. |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 336 | call ch_sendexpr(handle, 'call me again') |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 337 | call WaitForAssert({-> assert_equal('we did call you', g:Ch_reply)}) |
Bram Moolenaar | f615728 | 2016-02-10 21:07:14 +0100 | [diff] [blame] | 338 | endfunc |
| 339 | |
| 340 | func Test_channel_handler() |
Bram Moolenaar | 6fc8227 | 2016-08-28 19:26:43 +0200 | [diff] [blame] | 341 | let g:Ch_reply = "" |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 342 | let s:chopt.callback = 'Ch_handler' |
| 343 | call s:run_server('Ch_channel_handler') |
Bram Moolenaar | 6fc8227 | 2016-08-28 19:26:43 +0200 | [diff] [blame] | 344 | let g:Ch_reply = "" |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 345 | let s:chopt.callback = function('Ch_handler') |
| 346 | call s:run_server('Ch_channel_handler') |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 347 | endfunc |
| 348 | |
| 349 | func Test_channel_handler_ipv6() |
| 350 | CheckIPv6 |
| 351 | call Test_channel_handler() |
Bram Moolenaar | f615728 | 2016-02-10 21:07:14 +0100 | [diff] [blame] | 352 | endfunc |
| 353 | |
Bram Moolenaar | d6547fc | 2016-03-03 19:35:02 +0100 | [diff] [blame] | 354 | """"""""" |
| 355 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 356 | let g:Ch_reply = '' |
| 357 | func Ch_zeroHandler(chan, msg) |
| 358 | unlet g:Ch_reply |
| 359 | let g:Ch_reply = a:msg |
Bram Moolenaar | 5983ad0 | 2016-03-05 20:54:36 +0100 | [diff] [blame] | 360 | endfunc |
| 361 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 362 | let g:Ch_zero_reply = '' |
| 363 | func Ch_oneHandler(chan, msg) |
| 364 | unlet g:Ch_zero_reply |
| 365 | let g:Ch_zero_reply = a:msg |
Bram Moolenaar | 5983ad0 | 2016-03-05 20:54:36 +0100 | [diff] [blame] | 366 | endfunc |
| 367 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 368 | func Ch_channel_zero(port) |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 369 | let handle = (s:localhost .. a:port)->ch_open(s:chopt) |
Bram Moolenaar | 5983ad0 | 2016-03-05 20:54:36 +0100 | [diff] [blame] | 370 | if ch_status(handle) == "fail" |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 371 | call assert_report("Can't open channel") |
Bram Moolenaar | 5983ad0 | 2016-03-05 20:54:36 +0100 | [diff] [blame] | 372 | return |
| 373 | endif |
| 374 | |
| 375 | " Check that eval works. |
| 376 | call assert_equal('got it', ch_evalexpr(handle, 'hello!')) |
| 377 | |
| 378 | " Check that eval works if a zero id message is sent back. |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 379 | let g:Ch_reply = '' |
Bram Moolenaar | 5983ad0 | 2016-03-05 20:54:36 +0100 | [diff] [blame] | 380 | call assert_equal('sent zero', ch_evalexpr(handle, 'send zero')) |
Bram Moolenaar | 5983ad0 | 2016-03-05 20:54:36 +0100 | [diff] [blame] | 381 | if s:has_handler |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 382 | call WaitForAssert({-> assert_equal('zero index', g:Ch_reply)}) |
Bram Moolenaar | 5983ad0 | 2016-03-05 20:54:36 +0100 | [diff] [blame] | 383 | else |
Bram Moolenaar | 9fe885e | 2016-03-08 16:06:55 +0100 | [diff] [blame] | 384 | sleep 20m |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 385 | call assert_equal('', g:Ch_reply) |
Bram Moolenaar | 5983ad0 | 2016-03-05 20:54:36 +0100 | [diff] [blame] | 386 | endif |
| 387 | |
| 388 | " Check that handler works if a zero id message is sent back. |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 389 | let g:Ch_reply = '' |
| 390 | let g:Ch_zero_reply = '' |
| 391 | call ch_sendexpr(handle, 'send zero', {'callback': 'Ch_oneHandler'}) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 392 | call WaitForAssert({-> assert_equal('sent zero', g:Ch_zero_reply)}) |
Bram Moolenaar | 5983ad0 | 2016-03-05 20:54:36 +0100 | [diff] [blame] | 393 | if s:has_handler |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 394 | call assert_equal('zero index', g:Ch_reply) |
Bram Moolenaar | 5983ad0 | 2016-03-05 20:54:36 +0100 | [diff] [blame] | 395 | else |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 396 | call assert_equal('', g:Ch_reply) |
Bram Moolenaar | 5983ad0 | 2016-03-05 20:54:36 +0100 | [diff] [blame] | 397 | endif |
Bram Moolenaar | 5983ad0 | 2016-03-05 20:54:36 +0100 | [diff] [blame] | 398 | endfunc |
| 399 | |
| 400 | func Test_zero_reply() |
Bram Moolenaar | 5983ad0 | 2016-03-05 20:54:36 +0100 | [diff] [blame] | 401 | " Run with channel handler |
| 402 | let s:has_handler = 1 |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 403 | let s:chopt.callback = 'Ch_zeroHandler' |
| 404 | call s:run_server('Ch_channel_zero') |
Bram Moolenaar | 5983ad0 | 2016-03-05 20:54:36 +0100 | [diff] [blame] | 405 | unlet s:chopt.callback |
| 406 | |
| 407 | " Run without channel handler |
| 408 | let s:has_handler = 0 |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 409 | call s:run_server('Ch_channel_zero') |
Bram Moolenaar | 5983ad0 | 2016-03-05 20:54:36 +0100 | [diff] [blame] | 410 | endfunc |
| 411 | |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 412 | func Test_zero_reply_ipv6() |
| 413 | CheckIPv6 |
| 414 | call Test_zero_reply() |
| 415 | endfunc |
| 416 | |
Bram Moolenaar | 5983ad0 | 2016-03-05 20:54:36 +0100 | [diff] [blame] | 417 | """"""""" |
| 418 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 419 | let g:Ch_reply1 = "" |
| 420 | func Ch_handleRaw1(chan, msg) |
| 421 | unlet g:Ch_reply1 |
| 422 | let g:Ch_reply1 = a:msg |
Bram Moolenaar | d6547fc | 2016-03-03 19:35:02 +0100 | [diff] [blame] | 423 | endfunc |
| 424 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 425 | let g:Ch_reply2 = "" |
| 426 | func Ch_handleRaw2(chan, msg) |
| 427 | unlet g:Ch_reply2 |
| 428 | let g:Ch_reply2 = a:msg |
Bram Moolenaar | d6547fc | 2016-03-03 19:35:02 +0100 | [diff] [blame] | 429 | endfunc |
| 430 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 431 | let g:Ch_reply3 = "" |
| 432 | func Ch_handleRaw3(chan, msg) |
| 433 | unlet g:Ch_reply3 |
| 434 | let g:Ch_reply3 = a:msg |
Bram Moolenaar | d6547fc | 2016-03-03 19:35:02 +0100 | [diff] [blame] | 435 | endfunc |
| 436 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 437 | func Ch_raw_one_time_callback(port) |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 438 | let handle = ch_open(s:localhost . a:port, s:chopt) |
Bram Moolenaar | d6547fc | 2016-03-03 19:35:02 +0100 | [diff] [blame] | 439 | if ch_status(handle) == "fail" |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 440 | call assert_report("Can't open channel") |
Bram Moolenaar | d6547fc | 2016-03-03 19:35:02 +0100 | [diff] [blame] | 441 | return |
| 442 | endif |
| 443 | call ch_setoptions(handle, {'mode': 'raw'}) |
| 444 | |
Bram Moolenaar | 4b785f6 | 2016-11-29 21:54:44 +0100 | [diff] [blame] | 445 | " The messages are sent raw, we do our own JSON strings here. |
Bram Moolenaar | dd74ab9 | 2016-08-26 19:20:26 +0200 | [diff] [blame] | 446 | call ch_sendraw(handle, "[1, \"hello!\"]\n", {'callback': 'Ch_handleRaw1'}) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 447 | call WaitForAssert({-> assert_equal("[1, \"got it\"]", g:Ch_reply1)}) |
Bram Moolenaar | dd74ab9 | 2016-08-26 19:20:26 +0200 | [diff] [blame] | 448 | call ch_sendraw(handle, "[2, \"echo something\"]\n", {'callback': 'Ch_handleRaw2'}) |
| 449 | call ch_sendraw(handle, "[3, \"wait a bit\"]\n", {'callback': 'Ch_handleRaw3'}) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 450 | call WaitForAssert({-> assert_equal("[2, \"something\"]", g:Ch_reply2)}) |
Bram Moolenaar | 9fe885e | 2016-03-08 16:06:55 +0100 | [diff] [blame] | 451 | " wait for the 200 msec delayed reply |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 452 | call WaitForAssert({-> assert_equal("[3, \"waited\"]", g:Ch_reply3)}) |
Bram Moolenaar | d6547fc | 2016-03-03 19:35:02 +0100 | [diff] [blame] | 453 | endfunc |
| 454 | |
| 455 | func Test_raw_one_time_callback() |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 456 | call s:run_server('Ch_raw_one_time_callback') |
Bram Moolenaar | d6547fc | 2016-03-03 19:35:02 +0100 | [diff] [blame] | 457 | endfunc |
| 458 | |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 459 | func Test_raw_one_time_callback_ipv6() |
| 460 | CheckIPv6 |
| 461 | call Test_raw_one_time_callback() |
| 462 | endfunc |
| 463 | |
Bram Moolenaar | d6547fc | 2016-03-03 19:35:02 +0100 | [diff] [blame] | 464 | """"""""" |
| 465 | |
Bram Moolenaar | 7a84dbe | 2016-02-07 21:29:00 +0100 | [diff] [blame] | 466 | " Test that trying to connect to a non-existing port fails quickly. |
| 467 | func Test_connect_waittime() |
Bram Moolenaar | 5feabe0 | 2020-01-30 18:24:53 +0100 | [diff] [blame] | 468 | CheckFunction reltimefloat |
Bram Moolenaar | 373a876 | 2020-03-19 19:44:32 +0100 | [diff] [blame] | 469 | " this is timing sensitive |
Bram Moolenaar | 5feabe0 | 2020-01-30 18:24:53 +0100 | [diff] [blame] | 470 | |
Bram Moolenaar | 7a84dbe | 2016-02-07 21:29:00 +0100 | [diff] [blame] | 471 | let start = reltime() |
Bram Moolenaar | a483326 | 2016-02-09 23:33:25 +0100 | [diff] [blame] | 472 | let handle = ch_open('localhost:9876', s:chopt) |
Bram Moolenaar | 81661fb | 2016-02-18 22:23:34 +0100 | [diff] [blame] | 473 | if ch_status(handle) != "fail" |
Bram Moolenaar | 7a84dbe | 2016-02-07 21:29:00 +0100 | [diff] [blame] | 474 | " Oops, port does exists. |
| 475 | call ch_close(handle) |
| 476 | else |
| 477 | let elapsed = reltime(start) |
Bram Moolenaar | 74f5e65 | 2016-02-07 21:44:49 +0100 | [diff] [blame] | 478 | call assert_true(reltimefloat(elapsed) < 1.0) |
Bram Moolenaar | 7a84dbe | 2016-02-07 21:29:00 +0100 | [diff] [blame] | 479 | endif |
| 480 | |
Bram Moolenaar | 08298fa | 2016-02-21 13:01:53 +0100 | [diff] [blame] | 481 | " We intend to use a socket that doesn't exist and wait for half a second |
| 482 | " before giving up. If the socket does exist it can fail in various ways. |
Bram Moolenaar | 4b96df5 | 2020-01-26 22:00:26 +0100 | [diff] [blame] | 483 | " Check for "Connection reset by peer" to avoid flakiness. |
Bram Moolenaar | 7a84dbe | 2016-02-07 21:29:00 +0100 | [diff] [blame] | 484 | let start = reltime() |
Bram Moolenaar | 08298fa | 2016-02-21 13:01:53 +0100 | [diff] [blame] | 485 | try |
| 486 | let handle = ch_open('localhost:9867', {'waittime': 500}) |
| 487 | if ch_status(handle) != "fail" |
| 488 | " Oops, port does exists. |
| 489 | call ch_close(handle) |
| 490 | else |
Bram Moolenaar | ac42afd | 2016-03-12 13:48:49 +0100 | [diff] [blame] | 491 | " Failed connection should wait about 500 msec. Can be longer if the |
| 492 | " computer is busy with other things. |
Bram Moolenaar | 772153f | 2019-03-04 12:09:49 +0100 | [diff] [blame] | 493 | call assert_inrange(0.3, 1.5, reltimefloat(reltime(start))) |
Bram Moolenaar | 08298fa | 2016-02-21 13:01:53 +0100 | [diff] [blame] | 494 | endif |
| 495 | catch |
| 496 | if v:exception !~ 'Connection reset by peer' |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 497 | call assert_report("Caught exception: " . v:exception) |
Bram Moolenaar | 08298fa | 2016-02-21 13:01:53 +0100 | [diff] [blame] | 498 | endif |
| 499 | endtry |
Bram Moolenaar | 7a84dbe | 2016-02-07 21:29:00 +0100 | [diff] [blame] | 500 | endfunc |
Bram Moolenaar | 6463ca2 | 2016-02-13 17:04:46 +0100 | [diff] [blame] | 501 | |
Bram Moolenaar | d6547fc | 2016-03-03 19:35:02 +0100 | [diff] [blame] | 502 | """"""""" |
| 503 | |
Bram Moolenaar | 9a6e33a | 2016-02-16 19:25:12 +0100 | [diff] [blame] | 504 | func Test_raw_pipe() |
Bram Moolenaar | 4b785f6 | 2016-11-29 21:54:44 +0100 | [diff] [blame] | 505 | " Add a dummy close callback to avoid that messages are dropped when calling |
| 506 | " ch_canread(). |
Bram Moolenaar | 0b14688 | 2018-09-06 16:27:24 +0200 | [diff] [blame] | 507 | " Also test the non-blocking option. |
Bram Moolenaar | 4b785f6 | 2016-11-29 21:54:44 +0100 | [diff] [blame] | 508 | let job = job_start(s:python . " test_channel_pipe.py", |
Bram Moolenaar | 0b14688 | 2018-09-06 16:27:24 +0200 | [diff] [blame] | 509 | \ {'mode': 'raw', 'drop': 'never', 'noblock': 1}) |
Bram Moolenaar | f562e72 | 2016-07-19 17:25:25 +0200 | [diff] [blame] | 510 | call assert_equal(v:t_job, type(job)) |
Bram Moolenaar | 9a6e33a | 2016-02-16 19:25:12 +0100 | [diff] [blame] | 511 | call assert_equal("run", job_status(job)) |
Bram Moolenaar | 7ef3810 | 2016-09-26 22:36:58 +0200 | [diff] [blame] | 512 | |
| 513 | call assert_equal("open", ch_status(job)) |
| 514 | call assert_equal("open", ch_status(job), {"part": "out"}) |
| 515 | call assert_equal("open", ch_status(job), {"part": "err"}) |
| 516 | call assert_fails('call ch_status(job, {"in_mode": "raw"})', 'E475:') |
| 517 | call assert_fails('call ch_status(job, {"part": "in"})', 'E475:') |
| 518 | |
| 519 | let dict = ch_info(job) |
| 520 | call assert_true(dict.id != 0) |
| 521 | call assert_equal('open', dict.status) |
| 522 | call assert_equal('open', dict.out_status) |
| 523 | call assert_equal('RAW', dict.out_mode) |
| 524 | call assert_equal('pipe', dict.out_io) |
| 525 | call assert_equal('open', dict.err_status) |
| 526 | call assert_equal('RAW', dict.err_mode) |
| 527 | call assert_equal('pipe', dict.err_io) |
| 528 | |
Bram Moolenaar | 9a6e33a | 2016-02-16 19:25:12 +0100 | [diff] [blame] | 529 | try |
Bram Moolenaar | 151f656 | 2016-03-07 21:19:38 +0100 | [diff] [blame] | 530 | " For a change use the job where a channel is expected. |
| 531 | call ch_sendraw(job, "echo something\n") |
| 532 | let msg = ch_readraw(job) |
Bram Moolenaar | 9a6e33a | 2016-02-16 19:25:12 +0100 | [diff] [blame] | 533 | call assert_equal("something\n", substitute(msg, "\r", "", 'g')) |
| 534 | |
Bram Moolenaar | 151f656 | 2016-03-07 21:19:38 +0100 | [diff] [blame] | 535 | call ch_sendraw(job, "double this\n") |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 536 | let g:handle = job->job_getchannel() |
| 537 | call WaitFor('g:handle->ch_canread()') |
Bram Moolenaar | 4b785f6 | 2016-11-29 21:54:44 +0100 | [diff] [blame] | 538 | unlet g:handle |
Bram Moolenaar | 151f656 | 2016-03-07 21:19:38 +0100 | [diff] [blame] | 539 | let msg = ch_readraw(job) |
Bram Moolenaar | 9a6e33a | 2016-02-16 19:25:12 +0100 | [diff] [blame] | 540 | call assert_equal("this\nAND this\n", substitute(msg, "\r", "", 'g')) |
| 541 | |
Bram Moolenaar | 6fc8227 | 2016-08-28 19:26:43 +0200 | [diff] [blame] | 542 | let g:Ch_reply = "" |
| 543 | call ch_sendraw(job, "double this\n", {'callback': 'Ch_handler'}) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 544 | call WaitForAssert({-> assert_equal("this\nAND this\n", substitute(g:Ch_reply, "\r", "", 'g'))}) |
Bram Moolenaar | 6fc8227 | 2016-08-28 19:26:43 +0200 | [diff] [blame] | 545 | |
Bram Moolenaar | ca68ae1 | 2020-03-30 19:32:53 +0200 | [diff] [blame] | 546 | call assert_fails("let i = ch_evalraw(job, '2 + 2', {'callback' : 'abc'})", 'E917:') |
| 547 | call assert_fails("let i = ch_evalexpr(job, '2 + 2')", 'E912:') |
| 548 | call assert_fails("let i = ch_evalraw(job, '2 + 2', {'drop' : ''})", 'E475:') |
| 549 | call assert_fails("let i = ch_evalraw(test_null_job(), '2 + 2')", 'E906:') |
| 550 | |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 551 | let reply = job->ch_evalraw("quit\n", {'timeout': 100}) |
Bram Moolenaar | 9a6e33a | 2016-02-16 19:25:12 +0100 | [diff] [blame] | 552 | call assert_equal("Goodbye!\n", substitute(reply, "\r", "", 'g')) |
| 553 | finally |
| 554 | call job_stop(job) |
| 555 | endtry |
Bram Moolenaar | 8950a56 | 2016-03-12 15:22:55 +0100 | [diff] [blame] | 556 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 557 | let g:Ch_job = job |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 558 | call WaitForAssert({-> assert_equal("dead", job_status(g:Ch_job))}) |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 559 | let info = job->job_info() |
Bram Moolenaar | 8950a56 | 2016-03-12 15:22:55 +0100 | [diff] [blame] | 560 | call assert_equal("dead", info.status) |
| 561 | call assert_equal("term", info.stoponexit) |
Bram Moolenaar | e1fc515 | 2018-04-21 19:49:08 +0200 | [diff] [blame] | 562 | call assert_equal(2, len(info.cmd)) |
| 563 | call assert_equal("test_channel_pipe.py", info.cmd[1]) |
| 564 | |
| 565 | let found = 0 |
| 566 | for j in job_info() |
| 567 | if j == job |
| 568 | let found += 1 |
| 569 | endif |
| 570 | endfor |
| 571 | call assert_equal(1, found) |
Bram Moolenaar | 8b63313 | 2020-03-20 18:20:51 +0100 | [diff] [blame] | 572 | |
Bram Moolenaar | ca68ae1 | 2020-03-30 19:32:53 +0200 | [diff] [blame] | 573 | call assert_fails("call job_stop('abc')", 'E475:') |
Bram Moolenaar | 9b7bf9e | 2020-07-11 22:14:59 +0200 | [diff] [blame] | 574 | call assert_fails("call job_stop(job, [])", 'E730:') |
Bram Moolenaar | ca68ae1 | 2020-03-30 19:32:53 +0200 | [diff] [blame] | 575 | call assert_fails("call job_stop(test_null_job())", 'E916:') |
| 576 | |
Bram Moolenaar | 8b63313 | 2020-03-20 18:20:51 +0100 | [diff] [blame] | 577 | " Try to use the job and channel where a number is expected. This is not |
| 578 | " related to testing the raw pipe. This test is here just to reuse the |
| 579 | " already created job/channel. |
| 580 | let ch = job_getchannel(job) |
| 581 | call assert_fails('let i = job + 1', 'E910:') |
| 582 | call assert_fails('let j = ch + 1', 'E913:') |
| 583 | call assert_fails('echo 2.0 == job', 'E911:') |
| 584 | call assert_fails('echo 2.0 == ch', 'E914:') |
Bram Moolenaar | 9a6e33a | 2016-02-16 19:25:12 +0100 | [diff] [blame] | 585 | endfunc |
| 586 | |
Bram Moolenaar | 6e5ea8d | 2019-01-12 22:47:31 +0100 | [diff] [blame] | 587 | func Test_raw_pipe_blob() |
Bram Moolenaar | 6e5ea8d | 2019-01-12 22:47:31 +0100 | [diff] [blame] | 588 | " Add a dummy close callback to avoid that messages are dropped when calling |
| 589 | " ch_canread(). |
| 590 | " Also test the non-blocking option. |
| 591 | let job = job_start(s:python . " test_channel_pipe.py", |
| 592 | \ {'mode': 'raw', 'drop': 'never', 'noblock': 1}) |
| 593 | call assert_equal(v:t_job, type(job)) |
| 594 | call assert_equal("run", job_status(job)) |
| 595 | |
| 596 | call assert_equal("open", ch_status(job)) |
| 597 | call assert_equal("open", ch_status(job), {"part": "out"}) |
| 598 | |
| 599 | try |
| 600 | " Create a blob with the echo command and write it. |
| 601 | let blob = 0z00 |
| 602 | let cmd = "echo something\n" |
| 603 | for i in range(0, len(cmd) - 1) |
| 604 | let blob[i] = char2nr(cmd[i]) |
| 605 | endfor |
| 606 | call assert_equal(len(cmd), len(blob)) |
| 607 | call ch_sendraw(job, blob) |
| 608 | |
| 609 | " Read a blob with the reply. |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 610 | let msg = job->ch_readblob() |
Bram Moolenaar | 6e5ea8d | 2019-01-12 22:47:31 +0100 | [diff] [blame] | 611 | let expected = 'something' |
| 612 | for i in range(0, len(expected) - 1) |
| 613 | call assert_equal(char2nr(expected[i]), msg[i]) |
| 614 | endfor |
| 615 | |
| 616 | let reply = ch_evalraw(job, "quit\n", {'timeout': 100}) |
| 617 | call assert_equal("Goodbye!\n", substitute(reply, "\r", "", 'g')) |
| 618 | finally |
| 619 | call job_stop(job) |
| 620 | endtry |
| 621 | |
| 622 | let g:Ch_job = job |
| 623 | call WaitForAssert({-> assert_equal("dead", job_status(g:Ch_job))}) |
| 624 | let info = job_info(job) |
| 625 | call assert_equal("dead", info.status) |
| 626 | endfunc |
| 627 | |
Bram Moolenaar | 9a6e33a | 2016-02-16 19:25:12 +0100 | [diff] [blame] | 628 | func Test_nl_pipe() |
Bram Moolenaar | 1adda34 | 2016-03-12 15:39:40 +0100 | [diff] [blame] | 629 | let job = job_start([s:python, "test_channel_pipe.py"]) |
Bram Moolenaar | 6463ca2 | 2016-02-13 17:04:46 +0100 | [diff] [blame] | 630 | call assert_equal("run", job_status(job)) |
| 631 | try |
| 632 | let handle = job_getchannel(job) |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 633 | call ch_sendraw(handle, "echo something\n") |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 634 | call assert_equal("something", handle->ch_readraw()) |
Bram Moolenaar | 9a6e33a | 2016-02-16 19:25:12 +0100 | [diff] [blame] | 635 | |
Bram Moolenaar | c25558b | 2016-03-03 21:02:23 +0100 | [diff] [blame] | 636 | call ch_sendraw(handle, "echoerr wrong\n") |
| 637 | call assert_equal("wrong", ch_readraw(handle, {'part': 'err'})) |
| 638 | |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 639 | call ch_sendraw(handle, "double this\n") |
Bram Moolenaar | 9a6e33a | 2016-02-16 19:25:12 +0100 | [diff] [blame] | 640 | call assert_equal("this", ch_readraw(handle)) |
| 641 | call assert_equal("AND this", ch_readraw(handle)) |
| 642 | |
Bram Moolenaar | bbe8d91 | 2016-06-05 16:10:57 +0200 | [diff] [blame] | 643 | call ch_sendraw(handle, "split this line\n") |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 644 | call assert_equal("this linethis linethis line", handle->ch_read()) |
Bram Moolenaar | bbe8d91 | 2016-06-05 16:10:57 +0200 | [diff] [blame] | 645 | |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 646 | let reply = ch_evalraw(handle, "quit\n") |
Bram Moolenaar | 9a6e33a | 2016-02-16 19:25:12 +0100 | [diff] [blame] | 647 | call assert_equal("Goodbye!", reply) |
Bram Moolenaar | 6463ca2 | 2016-02-13 17:04:46 +0100 | [diff] [blame] | 648 | finally |
| 649 | call job_stop(job) |
| 650 | endtry |
| 651 | endfunc |
Bram Moolenaar | 3bece9f | 2016-02-15 20:39:46 +0100 | [diff] [blame] | 652 | |
Bram Moolenaar | 641ad6c | 2016-09-01 18:32:11 +0200 | [diff] [blame] | 653 | func Stop_g_job() |
| 654 | call job_stop(g:job) |
| 655 | if has('win32') |
| 656 | " On MS-Windows the server must close the file handle before we are able |
| 657 | " to delete the file. |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 658 | call WaitForAssert({-> assert_equal('dead', job_status(g:job))}) |
Bram Moolenaar | 641ad6c | 2016-09-01 18:32:11 +0200 | [diff] [blame] | 659 | sleep 10m |
| 660 | endif |
| 661 | endfunc |
| 662 | |
Bram Moolenaar | b69fccf | 2016-03-06 23:06:25 +0100 | [diff] [blame] | 663 | func Test_nl_read_file() |
Bram Moolenaar | b69fccf | 2016-03-06 23:06:25 +0100 | [diff] [blame] | 664 | call writefile(['echo something', 'echoerr wrong', 'double this'], 'Xinput') |
Bram Moolenaar | 641ad6c | 2016-09-01 18:32:11 +0200 | [diff] [blame] | 665 | let g:job = job_start(s:python . " test_channel_pipe.py", |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 666 | \ {'in_io': 'file', 'in_name': 'Xinput'}) |
Bram Moolenaar | 641ad6c | 2016-09-01 18:32:11 +0200 | [diff] [blame] | 667 | call assert_equal("run", job_status(g:job)) |
Bram Moolenaar | b69fccf | 2016-03-06 23:06:25 +0100 | [diff] [blame] | 668 | try |
Bram Moolenaar | 641ad6c | 2016-09-01 18:32:11 +0200 | [diff] [blame] | 669 | let handle = job_getchannel(g:job) |
Bram Moolenaar | b69fccf | 2016-03-06 23:06:25 +0100 | [diff] [blame] | 670 | call assert_equal("something", ch_readraw(handle)) |
| 671 | call assert_equal("wrong", ch_readraw(handle, {'part': 'err'})) |
| 672 | call assert_equal("this", ch_readraw(handle)) |
| 673 | call assert_equal("AND this", ch_readraw(handle)) |
| 674 | finally |
Bram Moolenaar | 641ad6c | 2016-09-01 18:32:11 +0200 | [diff] [blame] | 675 | call Stop_g_job() |
Bram Moolenaar | b69fccf | 2016-03-06 23:06:25 +0100 | [diff] [blame] | 676 | call delete('Xinput') |
| 677 | endtry |
Bram Moolenaar | ca68ae1 | 2020-03-30 19:32:53 +0200 | [diff] [blame] | 678 | call assert_fails("echo ch_read(test_null_channel(), {'callback' : 'abc'})", 'E475:') |
Bram Moolenaar | b69fccf | 2016-03-06 23:06:25 +0100 | [diff] [blame] | 679 | endfunc |
| 680 | |
Bram Moolenaar | e98d121 | 2016-03-08 15:37:41 +0100 | [diff] [blame] | 681 | func Test_nl_write_out_file() |
Bram Moolenaar | 641ad6c | 2016-09-01 18:32:11 +0200 | [diff] [blame] | 682 | let g:job = job_start(s:python . " test_channel_pipe.py", |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 683 | \ {'out_io': 'file', 'out_name': 'Xoutput'}) |
Bram Moolenaar | 641ad6c | 2016-09-01 18:32:11 +0200 | [diff] [blame] | 684 | call assert_equal("run", job_status(g:job)) |
Bram Moolenaar | e98d121 | 2016-03-08 15:37:41 +0100 | [diff] [blame] | 685 | try |
Bram Moolenaar | 641ad6c | 2016-09-01 18:32:11 +0200 | [diff] [blame] | 686 | let handle = job_getchannel(g:job) |
Bram Moolenaar | e98d121 | 2016-03-08 15:37:41 +0100 | [diff] [blame] | 687 | call ch_sendraw(handle, "echo line one\n") |
| 688 | call ch_sendraw(handle, "echo line two\n") |
| 689 | call ch_sendraw(handle, "double this\n") |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 690 | call WaitForAssert({-> assert_equal(['line one', 'line two', 'this', 'AND this'], readfile('Xoutput'))}) |
Bram Moolenaar | e98d121 | 2016-03-08 15:37:41 +0100 | [diff] [blame] | 691 | finally |
Bram Moolenaar | 641ad6c | 2016-09-01 18:32:11 +0200 | [diff] [blame] | 692 | call Stop_g_job() |
Bram Moolenaar | 81952470 | 2018-02-27 19:10:00 +0100 | [diff] [blame] | 693 | call assert_equal(-1, match(s:get_resources(), '\(^\|/\)Xoutput$')) |
Bram Moolenaar | e98d121 | 2016-03-08 15:37:41 +0100 | [diff] [blame] | 694 | call delete('Xoutput') |
| 695 | endtry |
| 696 | endfunc |
| 697 | |
| 698 | func Test_nl_write_err_file() |
Bram Moolenaar | 641ad6c | 2016-09-01 18:32:11 +0200 | [diff] [blame] | 699 | let g:job = job_start(s:python . " test_channel_pipe.py", |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 700 | \ {'err_io': 'file', 'err_name': 'Xoutput'}) |
Bram Moolenaar | 641ad6c | 2016-09-01 18:32:11 +0200 | [diff] [blame] | 701 | call assert_equal("run", job_status(g:job)) |
Bram Moolenaar | e98d121 | 2016-03-08 15:37:41 +0100 | [diff] [blame] | 702 | try |
Bram Moolenaar | 641ad6c | 2016-09-01 18:32:11 +0200 | [diff] [blame] | 703 | let handle = job_getchannel(g:job) |
Bram Moolenaar | e98d121 | 2016-03-08 15:37:41 +0100 | [diff] [blame] | 704 | call ch_sendraw(handle, "echoerr line one\n") |
| 705 | call ch_sendraw(handle, "echoerr line two\n") |
| 706 | call ch_sendraw(handle, "doubleerr this\n") |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 707 | call WaitForAssert({-> assert_equal(['line one', 'line two', 'this', 'AND this'], readfile('Xoutput'))}) |
Bram Moolenaar | e98d121 | 2016-03-08 15:37:41 +0100 | [diff] [blame] | 708 | finally |
Bram Moolenaar | 641ad6c | 2016-09-01 18:32:11 +0200 | [diff] [blame] | 709 | call Stop_g_job() |
Bram Moolenaar | e98d121 | 2016-03-08 15:37:41 +0100 | [diff] [blame] | 710 | call delete('Xoutput') |
| 711 | endtry |
| 712 | endfunc |
| 713 | |
| 714 | func Test_nl_write_both_file() |
Bram Moolenaar | 641ad6c | 2016-09-01 18:32:11 +0200 | [diff] [blame] | 715 | let g:job = job_start(s:python . " test_channel_pipe.py", |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 716 | \ {'out_io': 'file', 'out_name': 'Xoutput', 'err_io': 'out'}) |
Bram Moolenaar | 641ad6c | 2016-09-01 18:32:11 +0200 | [diff] [blame] | 717 | call assert_equal("run", job_status(g:job)) |
Bram Moolenaar | e98d121 | 2016-03-08 15:37:41 +0100 | [diff] [blame] | 718 | try |
Bram Moolenaar | 641ad6c | 2016-09-01 18:32:11 +0200 | [diff] [blame] | 719 | let handle = job_getchannel(g:job) |
Bram Moolenaar | e98d121 | 2016-03-08 15:37:41 +0100 | [diff] [blame] | 720 | call ch_sendraw(handle, "echoerr line one\n") |
| 721 | call ch_sendraw(handle, "echo line two\n") |
| 722 | call ch_sendraw(handle, "double this\n") |
| 723 | call ch_sendraw(handle, "doubleerr that\n") |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 724 | call WaitForAssert({-> assert_equal(['line one', 'line two', 'this', 'AND this', 'that', 'AND that'], readfile('Xoutput'))}) |
Bram Moolenaar | e98d121 | 2016-03-08 15:37:41 +0100 | [diff] [blame] | 725 | finally |
Bram Moolenaar | 641ad6c | 2016-09-01 18:32:11 +0200 | [diff] [blame] | 726 | call Stop_g_job() |
Bram Moolenaar | 81952470 | 2018-02-27 19:10:00 +0100 | [diff] [blame] | 727 | call assert_equal(-1, match(s:get_resources(), '\(^\|/\)Xoutput$')) |
Bram Moolenaar | e98d121 | 2016-03-08 15:37:41 +0100 | [diff] [blame] | 728 | call delete('Xoutput') |
| 729 | endtry |
| 730 | endfunc |
| 731 | |
Bram Moolenaar | 01d46e4 | 2016-06-02 19:06:25 +0200 | [diff] [blame] | 732 | func BufCloseCb(ch) |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 733 | let g:Ch_bufClosed = 'yes' |
Bram Moolenaar | 01d46e4 | 2016-06-02 19:06:25 +0200 | [diff] [blame] | 734 | endfunc |
| 735 | |
Bram Moolenaar | 169ebb0 | 2016-09-07 23:32:23 +0200 | [diff] [blame] | 736 | func Run_test_pipe_to_buffer(use_name, nomod, do_msg) |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 737 | let g:Ch_bufClosed = 'no' |
Bram Moolenaar | 01d46e4 | 2016-06-02 19:06:25 +0200 | [diff] [blame] | 738 | let options = {'out_io': 'buffer', 'close_cb': 'BufCloseCb'} |
Bram Moolenaar | 169ebb0 | 2016-09-07 23:32:23 +0200 | [diff] [blame] | 739 | let expected = ['', 'line one', 'line two', 'this', 'AND this', 'Goodbye!'] |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 740 | if a:use_name |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 741 | let options['out_name'] = 'pipe-output' |
Bram Moolenaar | 169ebb0 | 2016-09-07 23:32:23 +0200 | [diff] [blame] | 742 | if a:do_msg |
| 743 | let expected[0] = 'Reading from channel output...' |
| 744 | else |
| 745 | let options['out_msg'] = 0 |
| 746 | call remove(expected, 0) |
| 747 | endif |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 748 | else |
| 749 | sp pipe-output |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 750 | let options['out_buf'] = bufnr('%') |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 751 | quit |
Bram Moolenaar | 169ebb0 | 2016-09-07 23:32:23 +0200 | [diff] [blame] | 752 | call remove(expected, 0) |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 753 | endif |
Bram Moolenaar | 9f5842e | 2016-05-29 16:17:08 +0200 | [diff] [blame] | 754 | if a:nomod |
| 755 | let options['out_modifiable'] = 0 |
| 756 | endif |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 757 | let job = job_start(s:python . " test_channel_pipe.py", options) |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 758 | call assert_equal("run", job_status(job)) |
| 759 | try |
| 760 | let handle = job_getchannel(job) |
| 761 | call ch_sendraw(handle, "echo line one\n") |
| 762 | call ch_sendraw(handle, "echo line two\n") |
| 763 | call ch_sendraw(handle, "double this\n") |
| 764 | call ch_sendraw(handle, "quit\n") |
| 765 | sp pipe-output |
Bram Moolenaar | 3e1c617 | 2017-11-02 16:58:00 +0100 | [diff] [blame] | 766 | call WaitFor('line("$") == ' . len(expected) . ' && g:Ch_bufClosed == "yes"') |
Bram Moolenaar | 169ebb0 | 2016-09-07 23:32:23 +0200 | [diff] [blame] | 767 | call assert_equal(expected, getline(1, '$')) |
Bram Moolenaar | 9f5842e | 2016-05-29 16:17:08 +0200 | [diff] [blame] | 768 | if a:nomod |
| 769 | call assert_equal(0, &modifiable) |
| 770 | else |
| 771 | call assert_equal(1, &modifiable) |
| 772 | endif |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 773 | call assert_equal('yes', g:Ch_bufClosed) |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 774 | bwipe! |
| 775 | finally |
| 776 | call job_stop(job) |
| 777 | endtry |
| 778 | endfunc |
| 779 | |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 780 | func Test_pipe_to_buffer_name() |
Bram Moolenaar | 169ebb0 | 2016-09-07 23:32:23 +0200 | [diff] [blame] | 781 | call Run_test_pipe_to_buffer(1, 0, 1) |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 782 | endfunc |
| 783 | |
| 784 | func Test_pipe_to_buffer_nr() |
Bram Moolenaar | 169ebb0 | 2016-09-07 23:32:23 +0200 | [diff] [blame] | 785 | call Run_test_pipe_to_buffer(0, 0, 1) |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 786 | endfunc |
| 787 | |
Bram Moolenaar | 9f5842e | 2016-05-29 16:17:08 +0200 | [diff] [blame] | 788 | func Test_pipe_to_buffer_name_nomod() |
Bram Moolenaar | 169ebb0 | 2016-09-07 23:32:23 +0200 | [diff] [blame] | 789 | call Run_test_pipe_to_buffer(1, 1, 1) |
Bram Moolenaar | 9f5842e | 2016-05-29 16:17:08 +0200 | [diff] [blame] | 790 | endfunc |
| 791 | |
Bram Moolenaar | 169ebb0 | 2016-09-07 23:32:23 +0200 | [diff] [blame] | 792 | func Test_pipe_to_buffer_name_nomsg() |
| 793 | call Run_test_pipe_to_buffer(1, 0, 1) |
| 794 | endfunc |
| 795 | |
Bram Moolenaar | c4da113 | 2017-07-15 19:39:43 +0200 | [diff] [blame] | 796 | func Test_close_output_buffer() |
Bram Moolenaar | c4da113 | 2017-07-15 19:39:43 +0200 | [diff] [blame] | 797 | enew! |
| 798 | let test_lines = ['one', 'two'] |
| 799 | call setline(1, test_lines) |
Bram Moolenaar | c4da113 | 2017-07-15 19:39:43 +0200 | [diff] [blame] | 800 | let options = {'out_io': 'buffer'} |
| 801 | let options['out_name'] = 'buffer-output' |
| 802 | let options['out_msg'] = 0 |
| 803 | split buffer-output |
| 804 | let job = job_start(s:python . " test_channel_write.py", options) |
| 805 | call assert_equal("run", job_status(job)) |
| 806 | try |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 807 | call WaitForAssert({-> assert_equal(3, line('$'))}) |
Bram Moolenaar | c4da113 | 2017-07-15 19:39:43 +0200 | [diff] [blame] | 808 | quit! |
| 809 | sleep 100m |
| 810 | " Make sure the write didn't happen to the wrong buffer. |
| 811 | call assert_equal(test_lines, getline(1, line('$'))) |
| 812 | call assert_equal(-1, bufwinnr('buffer-output')) |
| 813 | sbuf buffer-output |
| 814 | call assert_notequal(-1, bufwinnr('buffer-output')) |
| 815 | sleep 100m |
| 816 | close " no more writes |
| 817 | bwipe! |
| 818 | finally |
| 819 | call job_stop(job) |
| 820 | endtry |
| 821 | endfunc |
| 822 | |
Bram Moolenaar | 169ebb0 | 2016-09-07 23:32:23 +0200 | [diff] [blame] | 823 | func Run_test_pipe_err_to_buffer(use_name, nomod, do_msg) |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 824 | let options = {'err_io': 'buffer'} |
Bram Moolenaar | 169ebb0 | 2016-09-07 23:32:23 +0200 | [diff] [blame] | 825 | let expected = ['', 'line one', 'line two', 'this', 'AND this'] |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 826 | if a:use_name |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 827 | let options['err_name'] = 'pipe-err' |
Bram Moolenaar | 169ebb0 | 2016-09-07 23:32:23 +0200 | [diff] [blame] | 828 | if a:do_msg |
| 829 | let expected[0] = 'Reading from channel error...' |
| 830 | else |
| 831 | let options['err_msg'] = 0 |
| 832 | call remove(expected, 0) |
| 833 | endif |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 834 | else |
| 835 | sp pipe-err |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 836 | let options['err_buf'] = bufnr('%') |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 837 | quit |
Bram Moolenaar | 169ebb0 | 2016-09-07 23:32:23 +0200 | [diff] [blame] | 838 | call remove(expected, 0) |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 839 | endif |
Bram Moolenaar | 9f5842e | 2016-05-29 16:17:08 +0200 | [diff] [blame] | 840 | if a:nomod |
| 841 | let options['err_modifiable'] = 0 |
| 842 | endif |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 843 | let job = job_start(s:python . " test_channel_pipe.py", options) |
Bram Moolenaar | 6ff02c9 | 2016-03-08 20:12:44 +0100 | [diff] [blame] | 844 | call assert_equal("run", job_status(job)) |
| 845 | try |
| 846 | let handle = job_getchannel(job) |
| 847 | call ch_sendraw(handle, "echoerr line one\n") |
| 848 | call ch_sendraw(handle, "echoerr line two\n") |
| 849 | call ch_sendraw(handle, "doubleerr this\n") |
| 850 | call ch_sendraw(handle, "quit\n") |
| 851 | sp pipe-err |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 852 | call WaitForAssert({-> assert_equal(expected, getline(1, '$'))}) |
Bram Moolenaar | 9f5842e | 2016-05-29 16:17:08 +0200 | [diff] [blame] | 853 | if a:nomod |
| 854 | call assert_equal(0, &modifiable) |
| 855 | else |
| 856 | call assert_equal(1, &modifiable) |
| 857 | endif |
Bram Moolenaar | 6ff02c9 | 2016-03-08 20:12:44 +0100 | [diff] [blame] | 858 | bwipe! |
| 859 | finally |
| 860 | call job_stop(job) |
| 861 | endtry |
| 862 | endfunc |
| 863 | |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 864 | func Test_pipe_err_to_buffer_name() |
Bram Moolenaar | 169ebb0 | 2016-09-07 23:32:23 +0200 | [diff] [blame] | 865 | call Run_test_pipe_err_to_buffer(1, 0, 1) |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 866 | endfunc |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 867 | |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 868 | func Test_pipe_err_to_buffer_nr() |
Bram Moolenaar | 169ebb0 | 2016-09-07 23:32:23 +0200 | [diff] [blame] | 869 | call Run_test_pipe_err_to_buffer(0, 0, 1) |
Bram Moolenaar | 9f5842e | 2016-05-29 16:17:08 +0200 | [diff] [blame] | 870 | endfunc |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 871 | |
Bram Moolenaar | 9f5842e | 2016-05-29 16:17:08 +0200 | [diff] [blame] | 872 | func Test_pipe_err_to_buffer_name_nomod() |
Bram Moolenaar | 169ebb0 | 2016-09-07 23:32:23 +0200 | [diff] [blame] | 873 | call Run_test_pipe_err_to_buffer(1, 1, 1) |
| 874 | endfunc |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 875 | |
Bram Moolenaar | 169ebb0 | 2016-09-07 23:32:23 +0200 | [diff] [blame] | 876 | func Test_pipe_err_to_buffer_name_nomsg() |
| 877 | call Run_test_pipe_err_to_buffer(1, 0, 0) |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 878 | endfunc |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 879 | |
Bram Moolenaar | 6ff02c9 | 2016-03-08 20:12:44 +0100 | [diff] [blame] | 880 | func Test_pipe_both_to_buffer() |
Bram Moolenaar | 6ff02c9 | 2016-03-08 20:12:44 +0100 | [diff] [blame] | 881 | let job = job_start(s:python . " test_channel_pipe.py", |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 882 | \ {'out_io': 'buffer', 'out_name': 'pipe-err', 'err_io': 'out'}) |
Bram Moolenaar | 6ff02c9 | 2016-03-08 20:12:44 +0100 | [diff] [blame] | 883 | call assert_equal("run", job_status(job)) |
Bram Moolenaar | 99fa721 | 2020-04-26 15:59:55 +0200 | [diff] [blame] | 884 | let handle = job_getchannel(job) |
| 885 | call assert_equal(bufnr('pipe-err'), ch_getbufnr(handle, 'out')) |
| 886 | call assert_equal(bufnr('pipe-err'), ch_getbufnr(handle, 'err')) |
Bram Moolenaar | 6ff02c9 | 2016-03-08 20:12:44 +0100 | [diff] [blame] | 887 | try |
Bram Moolenaar | 6ff02c9 | 2016-03-08 20:12:44 +0100 | [diff] [blame] | 888 | call ch_sendraw(handle, "echo line one\n") |
| 889 | call ch_sendraw(handle, "echoerr line two\n") |
| 890 | call ch_sendraw(handle, "double this\n") |
| 891 | call ch_sendraw(handle, "doubleerr that\n") |
| 892 | call ch_sendraw(handle, "quit\n") |
| 893 | sp pipe-err |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 894 | call WaitForAssert({-> assert_equal(['Reading from channel output...', 'line one', 'line two', 'this', 'AND this', 'that', 'AND that', 'Goodbye!'], getline(1, '$'))}) |
Bram Moolenaar | 6ff02c9 | 2016-03-08 20:12:44 +0100 | [diff] [blame] | 895 | bwipe! |
| 896 | finally |
| 897 | call job_stop(job) |
| 898 | endtry |
| 899 | endfunc |
| 900 | |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 901 | func Run_test_pipe_from_buffer(use_name) |
Bram Moolenaar | 014069a | 2016-03-03 22:51:40 +0100 | [diff] [blame] | 902 | sp pipe-input |
| 903 | call setline(1, ['echo one', 'echo two', 'echo three']) |
Bram Moolenaar | 8b877ac | 2016-03-28 19:16:20 +0200 | [diff] [blame] | 904 | let options = {'in_io': 'buffer', 'block_write': 1} |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 905 | if a:use_name |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 906 | let options['in_name'] = 'pipe-input' |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 907 | else |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 908 | let options['in_buf'] = bufnr('%') |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 909 | endif |
Bram Moolenaar | 014069a | 2016-03-03 22:51:40 +0100 | [diff] [blame] | 910 | |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 911 | let job = job_start(s:python . " test_channel_pipe.py", options) |
Bram Moolenaar | 014069a | 2016-03-03 22:51:40 +0100 | [diff] [blame] | 912 | call assert_equal("run", job_status(job)) |
Bram Moolenaar | 99fa721 | 2020-04-26 15:59:55 +0200 | [diff] [blame] | 913 | if has('unix') && !a:use_name |
| 914 | call assert_equal(bufnr('%'), ch_getbufnr(job, 'in')) |
| 915 | endif |
Bram Moolenaar | 014069a | 2016-03-03 22:51:40 +0100 | [diff] [blame] | 916 | try |
| 917 | let handle = job_getchannel(job) |
| 918 | call assert_equal('one', ch_read(handle)) |
| 919 | call assert_equal('two', ch_read(handle)) |
| 920 | call assert_equal('three', ch_read(handle)) |
| 921 | bwipe! |
| 922 | finally |
| 923 | call job_stop(job) |
| 924 | endtry |
Bram Moolenaar | 014069a | 2016-03-03 22:51:40 +0100 | [diff] [blame] | 925 | endfunc |
| 926 | |
Bram Moolenaar | 29fd038 | 2016-03-09 23:14:07 +0100 | [diff] [blame] | 927 | func Test_pipe_from_buffer_name() |
| 928 | call Run_test_pipe_from_buffer(1) |
| 929 | endfunc |
| 930 | |
| 931 | func Test_pipe_from_buffer_nr() |
| 932 | call Run_test_pipe_from_buffer(0) |
| 933 | endfunc |
| 934 | |
Bram Moolenaar | 0874a83 | 2016-09-01 15:11:51 +0200 | [diff] [blame] | 935 | func Run_pipe_through_sort(all, use_buffer) |
Bram Moolenaar | 8c5a278 | 2019-08-07 23:07:07 +0200 | [diff] [blame] | 936 | CheckExecutable sort |
| 937 | |
Bram Moolenaar | 0874a83 | 2016-09-01 15:11:51 +0200 | [diff] [blame] | 938 | let options = {'out_io': 'buffer', 'out_name': 'sortout'} |
| 939 | if a:use_buffer |
| 940 | split sortin |
| 941 | call setline(1, ['ccc', 'aaa', 'ddd', 'bbb', 'eee']) |
| 942 | let options.in_io = 'buffer' |
| 943 | let options.in_name = 'sortin' |
| 944 | endif |
Bram Moolenaar | d8b5549 | 2016-09-01 14:35:22 +0200 | [diff] [blame] | 945 | if !a:all |
| 946 | let options.in_top = 2 |
| 947 | let options.in_bot = 4 |
| 948 | endif |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 949 | let job = job_start('sort', options) |
Bram Moolenaar | 0874a83 | 2016-09-01 15:11:51 +0200 | [diff] [blame] | 950 | |
| 951 | if !a:use_buffer |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 952 | call assert_equal("run", job_status(job)) |
| 953 | call ch_sendraw(job, "ccc\naaa\nddd\nbbb\neee\n") |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 954 | eval job->ch_close_in() |
Bram Moolenaar | 0874a83 | 2016-09-01 15:11:51 +0200 | [diff] [blame] | 955 | endif |
| 956 | |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 957 | call WaitForAssert({-> assert_equal("dead", job_status(job))}) |
Bram Moolenaar | 0874a83 | 2016-09-01 15:11:51 +0200 | [diff] [blame] | 958 | |
Bram Moolenaar | d8b5549 | 2016-09-01 14:35:22 +0200 | [diff] [blame] | 959 | sp sortout |
Bram Moolenaar | f7f3e32 | 2016-09-03 18:47:24 +0200 | [diff] [blame] | 960 | call WaitFor('line("$") > 3') |
Bram Moolenaar | d8b5549 | 2016-09-01 14:35:22 +0200 | [diff] [blame] | 961 | call assert_equal('Reading from channel output...', getline(1)) |
| 962 | if a:all |
| 963 | call assert_equal(['aaa', 'bbb', 'ccc', 'ddd', 'eee'], getline(2, 6)) |
| 964 | else |
| 965 | call assert_equal(['aaa', 'bbb', 'ddd'], getline(2, 4)) |
| 966 | endif |
| 967 | |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 968 | call job_stop(job) |
Bram Moolenaar | 0874a83 | 2016-09-01 15:11:51 +0200 | [diff] [blame] | 969 | if a:use_buffer |
| 970 | bwipe! sortin |
| 971 | endif |
Bram Moolenaar | d8b5549 | 2016-09-01 14:35:22 +0200 | [diff] [blame] | 972 | bwipe! sortout |
| 973 | endfunc |
| 974 | |
| 975 | func Test_pipe_through_sort_all() |
Bram Moolenaar | 0874a83 | 2016-09-01 15:11:51 +0200 | [diff] [blame] | 976 | call Run_pipe_through_sort(1, 1) |
Bram Moolenaar | d8b5549 | 2016-09-01 14:35:22 +0200 | [diff] [blame] | 977 | endfunc |
| 978 | |
| 979 | func Test_pipe_through_sort_some() |
Bram Moolenaar | 0874a83 | 2016-09-01 15:11:51 +0200 | [diff] [blame] | 980 | call Run_pipe_through_sort(0, 1) |
| 981 | endfunc |
| 982 | |
| 983 | func Test_pipe_through_sort_feed() |
Bram Moolenaar | 0874a83 | 2016-09-01 15:11:51 +0200 | [diff] [blame] | 984 | call Run_pipe_through_sort(1, 0) |
Bram Moolenaar | d8b5549 | 2016-09-01 14:35:22 +0200 | [diff] [blame] | 985 | endfunc |
| 986 | |
Bram Moolenaar | c7f0ebc | 2016-02-27 21:10:09 +0100 | [diff] [blame] | 987 | func Test_pipe_to_nameless_buffer() |
Bram Moolenaar | c7f0ebc | 2016-02-27 21:10:09 +0100 | [diff] [blame] | 988 | let job = job_start(s:python . " test_channel_pipe.py", |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 989 | \ {'out_io': 'buffer'}) |
Bram Moolenaar | c7f0ebc | 2016-02-27 21:10:09 +0100 | [diff] [blame] | 990 | call assert_equal("run", job_status(job)) |
| 991 | try |
| 992 | let handle = job_getchannel(job) |
| 993 | call ch_sendraw(handle, "echo line one\n") |
| 994 | call ch_sendraw(handle, "echo line two\n") |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 995 | exe handle->ch_getbufnr("out") .. 'sbuf' |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 996 | call WaitFor('line("$") >= 3') |
Bram Moolenaar | c7f0ebc | 2016-02-27 21:10:09 +0100 | [diff] [blame] | 997 | call assert_equal(['Reading from channel output...', 'line one', 'line two'], getline(1, '$')) |
| 998 | bwipe! |
| 999 | finally |
| 1000 | call job_stop(job) |
| 1001 | endtry |
| 1002 | endfunc |
| 1003 | |
Bram Moolenaar | cc7f8be | 2016-02-29 22:55:56 +0100 | [diff] [blame] | 1004 | func Test_pipe_to_buffer_json() |
Bram Moolenaar | 5feabe0 | 2020-01-30 18:24:53 +0100 | [diff] [blame] | 1005 | CheckFunction reltimefloat |
| 1006 | |
Bram Moolenaar | cc7f8be | 2016-02-29 22:55:56 +0100 | [diff] [blame] | 1007 | let job = job_start(s:python . " test_channel_pipe.py", |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 1008 | \ {'out_io': 'buffer', 'out_mode': 'json'}) |
Bram Moolenaar | cc7f8be | 2016-02-29 22:55:56 +0100 | [diff] [blame] | 1009 | call assert_equal("run", job_status(job)) |
| 1010 | try |
| 1011 | let handle = job_getchannel(job) |
| 1012 | call ch_sendraw(handle, "echo [0, \"hello\"]\n") |
| 1013 | call ch_sendraw(handle, "echo [-2, 12.34]\n") |
| 1014 | exe ch_getbufnr(handle, "out") . 'sbuf' |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1015 | call WaitFor('line("$") >= 3') |
Bram Moolenaar | cc7f8be | 2016-02-29 22:55:56 +0100 | [diff] [blame] | 1016 | call assert_equal(['Reading from channel output...', '[0,"hello"]', '[-2,12.34]'], getline(1, '$')) |
| 1017 | bwipe! |
| 1018 | finally |
| 1019 | call job_stop(job) |
| 1020 | endtry |
| 1021 | endfunc |
| 1022 | |
Bram Moolenaar | 3f39f64 | 2016-03-06 21:35:57 +0100 | [diff] [blame] | 1023 | " Wait a little while for the last line, minus "offset", to equal "line". |
Bram Moolenaar | 9fe885e | 2016-03-08 16:06:55 +0100 | [diff] [blame] | 1024 | func s:wait_for_last_line(line, offset) |
Bram Moolenaar | 3f39f64 | 2016-03-06 21:35:57 +0100 | [diff] [blame] | 1025 | for i in range(100) |
Bram Moolenaar | 3f39f64 | 2016-03-06 21:35:57 +0100 | [diff] [blame] | 1026 | if getline(line('$') - a:offset) == a:line |
| 1027 | break |
| 1028 | endif |
Bram Moolenaar | 9fe885e | 2016-03-08 16:06:55 +0100 | [diff] [blame] | 1029 | sleep 10m |
Bram Moolenaar | 3f39f64 | 2016-03-06 21:35:57 +0100 | [diff] [blame] | 1030 | endfor |
| 1031 | endfunc |
| 1032 | |
| 1033 | func Test_pipe_io_two_buffers() |
Bram Moolenaar | 3f39f64 | 2016-03-06 21:35:57 +0100 | [diff] [blame] | 1034 | " Create two buffers, one to read from and one to write to. |
| 1035 | split pipe-output |
| 1036 | set buftype=nofile |
| 1037 | split pipe-input |
| 1038 | set buftype=nofile |
| 1039 | |
| 1040 | let job = job_start(s:python . " test_channel_pipe.py", |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 1041 | \ {'in_io': 'buffer', 'in_name': 'pipe-input', 'in_top': 0, |
Bram Moolenaar | 8b877ac | 2016-03-28 19:16:20 +0200 | [diff] [blame] | 1042 | \ 'out_io': 'buffer', 'out_name': 'pipe-output', |
| 1043 | \ 'block_write': 1}) |
Bram Moolenaar | 3f39f64 | 2016-03-06 21:35:57 +0100 | [diff] [blame] | 1044 | call assert_equal("run", job_status(job)) |
| 1045 | try |
| 1046 | exe "normal Gaecho hello\<CR>" |
| 1047 | exe bufwinnr('pipe-output') . "wincmd w" |
Bram Moolenaar | 9fe885e | 2016-03-08 16:06:55 +0100 | [diff] [blame] | 1048 | call s:wait_for_last_line('hello', 0) |
Bram Moolenaar | 3f39f64 | 2016-03-06 21:35:57 +0100 | [diff] [blame] | 1049 | call assert_equal('hello', getline('$')) |
| 1050 | |
| 1051 | exe bufwinnr('pipe-input') . "wincmd w" |
| 1052 | exe "normal Gadouble this\<CR>" |
| 1053 | exe bufwinnr('pipe-output') . "wincmd w" |
Bram Moolenaar | 9fe885e | 2016-03-08 16:06:55 +0100 | [diff] [blame] | 1054 | call s:wait_for_last_line('AND this', 0) |
Bram Moolenaar | 3f39f64 | 2016-03-06 21:35:57 +0100 | [diff] [blame] | 1055 | call assert_equal('this', getline(line('$') - 1)) |
| 1056 | call assert_equal('AND this', getline('$')) |
| 1057 | |
| 1058 | bwipe! |
| 1059 | exe bufwinnr('pipe-input') . "wincmd w" |
| 1060 | bwipe! |
| 1061 | finally |
| 1062 | call job_stop(job) |
| 1063 | endtry |
| 1064 | endfunc |
| 1065 | |
| 1066 | func Test_pipe_io_one_buffer() |
Bram Moolenaar | 3f39f64 | 2016-03-06 21:35:57 +0100 | [diff] [blame] | 1067 | " Create one buffer to read from and to write to. |
| 1068 | split pipe-io |
| 1069 | set buftype=nofile |
| 1070 | |
| 1071 | let job = job_start(s:python . " test_channel_pipe.py", |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 1072 | \ {'in_io': 'buffer', 'in_name': 'pipe-io', 'in_top': 0, |
Bram Moolenaar | 8b877ac | 2016-03-28 19:16:20 +0200 | [diff] [blame] | 1073 | \ 'out_io': 'buffer', 'out_name': 'pipe-io', |
| 1074 | \ 'block_write': 1}) |
Bram Moolenaar | 3f39f64 | 2016-03-06 21:35:57 +0100 | [diff] [blame] | 1075 | call assert_equal("run", job_status(job)) |
| 1076 | try |
| 1077 | exe "normal Goecho hello\<CR>" |
Bram Moolenaar | 9fe885e | 2016-03-08 16:06:55 +0100 | [diff] [blame] | 1078 | call s:wait_for_last_line('hello', 1) |
Bram Moolenaar | 3f39f64 | 2016-03-06 21:35:57 +0100 | [diff] [blame] | 1079 | call assert_equal('hello', getline(line('$') - 1)) |
| 1080 | |
| 1081 | exe "normal Gadouble this\<CR>" |
Bram Moolenaar | 9fe885e | 2016-03-08 16:06:55 +0100 | [diff] [blame] | 1082 | call s:wait_for_last_line('AND this', 1) |
Bram Moolenaar | 3f39f64 | 2016-03-06 21:35:57 +0100 | [diff] [blame] | 1083 | call assert_equal('this', getline(line('$') - 2)) |
| 1084 | call assert_equal('AND this', getline(line('$') - 1)) |
| 1085 | |
| 1086 | bwipe! |
| 1087 | finally |
| 1088 | call job_stop(job) |
| 1089 | endtry |
| 1090 | endfunc |
| 1091 | |
Bram Moolenaar | 4641a12 | 2019-07-29 22:10:23 +0200 | [diff] [blame] | 1092 | func Test_write_to_buffer_and_scroll() |
Bram Moolenaar | 8c5a278 | 2019-08-07 23:07:07 +0200 | [diff] [blame] | 1093 | CheckScreendump |
| 1094 | |
Bram Moolenaar | 4641a12 | 2019-07-29 22:10:23 +0200 | [diff] [blame] | 1095 | let lines =<< trim END |
| 1096 | new Xscrollbuffer |
| 1097 | call setline(1, range(1, 200)) |
| 1098 | $ |
| 1099 | redraw |
| 1100 | wincmd w |
| 1101 | call deletebufline('Xscrollbuffer', 1, '$') |
| 1102 | if has('win32') |
| 1103 | let cmd = ['cmd', '/c', 'echo sometext'] |
| 1104 | else |
| 1105 | let cmd = [&shell, &shellcmdflag, 'echo sometext'] |
| 1106 | endif |
| 1107 | call job_start(cmd, #{out_io: 'buffer', out_name: 'Xscrollbuffer'}) |
| 1108 | END |
| 1109 | call writefile(lines, 'XtestBufferScroll') |
| 1110 | let buf = RunVimInTerminal('-S XtestBufferScroll', #{rows: 10}) |
Bram Moolenaar | 6a2c5a7 | 2020-04-08 21:50:25 +0200 | [diff] [blame] | 1111 | call TermWait(buf, 50) |
Bram Moolenaar | 4641a12 | 2019-07-29 22:10:23 +0200 | [diff] [blame] | 1112 | call VerifyScreenDump(buf, 'Test_job_buffer_scroll_1', {}) |
| 1113 | |
| 1114 | " clean up |
| 1115 | call StopVimInTerminal(buf) |
| 1116 | call delete('XtestBufferScroll') |
| 1117 | endfunc |
| 1118 | |
Bram Moolenaar | f65333c | 2016-03-08 18:27:21 +0100 | [diff] [blame] | 1119 | func Test_pipe_null() |
Bram Moolenaar | f65333c | 2016-03-08 18:27:21 +0100 | [diff] [blame] | 1120 | " We cannot check that no I/O works, we only check that the job starts |
| 1121 | " properly. |
| 1122 | let job = job_start(s:python . " test_channel_pipe.py something", |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 1123 | \ {'in_io': 'null'}) |
Bram Moolenaar | f65333c | 2016-03-08 18:27:21 +0100 | [diff] [blame] | 1124 | call assert_equal("run", job_status(job)) |
| 1125 | try |
| 1126 | call assert_equal('something', ch_read(job)) |
| 1127 | finally |
| 1128 | call job_stop(job) |
| 1129 | endtry |
| 1130 | |
| 1131 | let job = job_start(s:python . " test_channel_pipe.py err-out", |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 1132 | \ {'out_io': 'null'}) |
Bram Moolenaar | f65333c | 2016-03-08 18:27:21 +0100 | [diff] [blame] | 1133 | call assert_equal("run", job_status(job)) |
| 1134 | try |
| 1135 | call assert_equal('err-out', ch_read(job, {"part": "err"})) |
| 1136 | finally |
| 1137 | call job_stop(job) |
| 1138 | endtry |
| 1139 | |
| 1140 | let job = job_start(s:python . " test_channel_pipe.py something", |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 1141 | \ {'err_io': 'null'}) |
Bram Moolenaar | f65333c | 2016-03-08 18:27:21 +0100 | [diff] [blame] | 1142 | call assert_equal("run", job_status(job)) |
| 1143 | try |
| 1144 | call assert_equal('something', ch_read(job)) |
| 1145 | finally |
| 1146 | call job_stop(job) |
| 1147 | endtry |
| 1148 | |
| 1149 | let job = job_start(s:python . " test_channel_pipe.py something", |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 1150 | \ {'out_io': 'null', 'err_io': 'out'}) |
Bram Moolenaar | f65333c | 2016-03-08 18:27:21 +0100 | [diff] [blame] | 1151 | call assert_equal("run", job_status(job)) |
| 1152 | call job_stop(job) |
| 1153 | |
| 1154 | let job = job_start(s:python . " test_channel_pipe.py something", |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 1155 | \ {'in_io': 'null', 'out_io': 'null', 'err_io': 'null'}) |
Bram Moolenaar | f65333c | 2016-03-08 18:27:21 +0100 | [diff] [blame] | 1156 | call assert_equal("run", job_status(job)) |
| 1157 | call assert_equal('channel fail', string(job_getchannel(job))) |
| 1158 | call assert_equal('fail', ch_status(job)) |
Bram Moolenaar | 92b83cc | 2020-04-25 15:24:44 +0200 | [diff] [blame] | 1159 | call assert_equal('no process', string(test_null_job())) |
| 1160 | call assert_equal('channel fail', string(test_null_channel())) |
Bram Moolenaar | f65333c | 2016-03-08 18:27:21 +0100 | [diff] [blame] | 1161 | call job_stop(job) |
| 1162 | endfunc |
| 1163 | |
Bram Moolenaar | adb78a7 | 2016-06-27 21:10:31 +0200 | [diff] [blame] | 1164 | func Test_pipe_to_buffer_raw() |
Bram Moolenaar | adb78a7 | 2016-06-27 21:10:31 +0200 | [diff] [blame] | 1165 | let options = {'out_mode': 'raw', 'out_io': 'buffer', 'out_name': 'testout'} |
| 1166 | split testout |
| 1167 | let job = job_start([s:python, '-c', |
| 1168 | \ 'import sys; [sys.stdout.write(".") and sys.stdout.flush() for _ in range(10000)]'], options) |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 1169 | " the job may be done quickly, also accept "dead" |
| 1170 | call assert_match('^\%(dead\|run\)$', job_status(job)) |
Bram Moolenaar | 769e9d2 | 2018-04-11 20:53:49 +0200 | [diff] [blame] | 1171 | call WaitFor('len(join(getline(1, "$"), "")) >= 10000') |
Bram Moolenaar | adb78a7 | 2016-06-27 21:10:31 +0200 | [diff] [blame] | 1172 | try |
Bram Moolenaar | 3e1c617 | 2017-11-02 16:58:00 +0100 | [diff] [blame] | 1173 | let totlen = 0 |
| 1174 | for line in getline(1, '$') |
| 1175 | call assert_equal('', substitute(line, '^\.*', '', '')) |
| 1176 | let totlen += len(line) |
Bram Moolenaar | adb78a7 | 2016-06-27 21:10:31 +0200 | [diff] [blame] | 1177 | endfor |
Bram Moolenaar | 3e1c617 | 2017-11-02 16:58:00 +0100 | [diff] [blame] | 1178 | call assert_equal(10000, totlen) |
Bram Moolenaar | adb78a7 | 2016-06-27 21:10:31 +0200 | [diff] [blame] | 1179 | finally |
| 1180 | call job_stop(job) |
| 1181 | bwipe! |
| 1182 | endtry |
| 1183 | endfunc |
| 1184 | |
Bram Moolenaar | de27989 | 2016-03-11 22:19:44 +0100 | [diff] [blame] | 1185 | func Test_reuse_channel() |
Bram Moolenaar | de27989 | 2016-03-11 22:19:44 +0100 | [diff] [blame] | 1186 | let job = job_start(s:python . " test_channel_pipe.py") |
| 1187 | call assert_equal("run", job_status(job)) |
| 1188 | let handle = job_getchannel(job) |
| 1189 | try |
| 1190 | call ch_sendraw(handle, "echo something\n") |
| 1191 | call assert_equal("something", ch_readraw(handle)) |
| 1192 | finally |
| 1193 | call job_stop(job) |
| 1194 | endtry |
| 1195 | |
| 1196 | let job = job_start(s:python . " test_channel_pipe.py", {'channel': handle}) |
| 1197 | call assert_equal("run", job_status(job)) |
| 1198 | let handle = job_getchannel(job) |
| 1199 | try |
| 1200 | call ch_sendraw(handle, "echo again\n") |
| 1201 | call assert_equal("again", ch_readraw(handle)) |
| 1202 | finally |
| 1203 | call job_stop(job) |
| 1204 | endtry |
| 1205 | endfunc |
| 1206 | |
Bram Moolenaar | 75f7265 | 2016-03-20 22:16:56 +0100 | [diff] [blame] | 1207 | func Test_out_cb() |
Bram Moolenaar | 75f7265 | 2016-03-20 22:16:56 +0100 | [diff] [blame] | 1208 | let dict = {'thisis': 'dict: '} |
| 1209 | func dict.outHandler(chan, msg) dict |
Bram Moolenaar | 88989cc | 2017-02-06 21:56:09 +0100 | [diff] [blame] | 1210 | if type(a:msg) == v:t_string |
| 1211 | let g:Ch_outmsg = self.thisis . a:msg |
| 1212 | else |
| 1213 | let g:Ch_outobj = a:msg |
| 1214 | endif |
Bram Moolenaar | 75f7265 | 2016-03-20 22:16:56 +0100 | [diff] [blame] | 1215 | endfunc |
| 1216 | func dict.errHandler(chan, msg) dict |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1217 | let g:Ch_errmsg = self.thisis . a:msg |
Bram Moolenaar | 75f7265 | 2016-03-20 22:16:56 +0100 | [diff] [blame] | 1218 | endfunc |
| 1219 | let job = job_start(s:python . " test_channel_pipe.py", |
| 1220 | \ {'out_cb': dict.outHandler, |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 1221 | \ 'out_mode': 'json', |
| 1222 | \ 'err_cb': dict.errHandler, |
| 1223 | \ 'err_mode': 'json'}) |
Bram Moolenaar | 75f7265 | 2016-03-20 22:16:56 +0100 | [diff] [blame] | 1224 | call assert_equal("run", job_status(job)) |
Bram Moolenaar | 9d8d0b5 | 2020-04-24 22:47:31 +0200 | [diff] [blame] | 1225 | call test_garbagecollect_now() |
Bram Moolenaar | 75f7265 | 2016-03-20 22:16:56 +0100 | [diff] [blame] | 1226 | try |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1227 | let g:Ch_outmsg = '' |
| 1228 | let g:Ch_errmsg = '' |
Bram Moolenaar | 75f7265 | 2016-03-20 22:16:56 +0100 | [diff] [blame] | 1229 | call ch_sendraw(job, "echo [0, \"hello\"]\n") |
| 1230 | call ch_sendraw(job, "echoerr [0, \"there\"]\n") |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1231 | call WaitForAssert({-> assert_equal("dict: hello", g:Ch_outmsg)}) |
| 1232 | call WaitForAssert({-> assert_equal("dict: there", g:Ch_errmsg)}) |
Bram Moolenaar | 88989cc | 2017-02-06 21:56:09 +0100 | [diff] [blame] | 1233 | |
| 1234 | " Receive a json object split in pieces |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1235 | let g:Ch_outobj = '' |
Bram Moolenaar | 9ae3bbd | 2020-02-19 14:31:33 +0100 | [diff] [blame] | 1236 | call ch_sendraw(job, "echosplit [0, {\"one\": 1,| \"tw|o\": 2, \"three\": 3|}]\n") |
Bram Moolenaar | bf54dbe | 2020-03-29 16:18:58 +0200 | [diff] [blame] | 1237 | " For unknown reasons this can be very slow on Mac. |
| 1238 | if has('mac') |
| 1239 | let timeout = 20000 |
| 1240 | else |
| 1241 | let timeout = 5000 |
| 1242 | endif |
| 1243 | call WaitForAssert({-> assert_equal({'one': 1, 'two': 2, 'three': 3}, g:Ch_outobj)}, timeout) |
Bram Moolenaar | 75f7265 | 2016-03-20 22:16:56 +0100 | [diff] [blame] | 1244 | finally |
| 1245 | call job_stop(job) |
| 1246 | endtry |
| 1247 | endfunc |
| 1248 | |
Bram Moolenaar | b2658a1 | 2016-04-26 17:16:24 +0200 | [diff] [blame] | 1249 | func Test_out_close_cb() |
Bram Moolenaar | b2658a1 | 2016-04-26 17:16:24 +0200 | [diff] [blame] | 1250 | let s:counter = 1 |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1251 | let g:Ch_msg1 = '' |
| 1252 | let g:Ch_closemsg = 0 |
Bram Moolenaar | b2658a1 | 2016-04-26 17:16:24 +0200 | [diff] [blame] | 1253 | func! OutHandler(chan, msg) |
Bram Moolenaar | d75263c | 2016-04-30 16:07:23 +0200 | [diff] [blame] | 1254 | if s:counter == 1 |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1255 | let g:Ch_msg1 = a:msg |
Bram Moolenaar | d75263c | 2016-04-30 16:07:23 +0200 | [diff] [blame] | 1256 | endif |
Bram Moolenaar | b2658a1 | 2016-04-26 17:16:24 +0200 | [diff] [blame] | 1257 | let s:counter += 1 |
| 1258 | endfunc |
| 1259 | func! CloseHandler(chan) |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1260 | let g:Ch_closemsg = s:counter |
Bram Moolenaar | b2658a1 | 2016-04-26 17:16:24 +0200 | [diff] [blame] | 1261 | let s:counter += 1 |
| 1262 | endfunc |
| 1263 | let job = job_start(s:python . " test_channel_pipe.py quit now", |
| 1264 | \ {'out_cb': 'OutHandler', |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 1265 | \ 'close_cb': 'CloseHandler'}) |
| 1266 | " the job may be done quickly, also accept "dead" |
| 1267 | call assert_match('^\%(dead\|run\)$', job_status(job)) |
Bram Moolenaar | b2658a1 | 2016-04-26 17:16:24 +0200 | [diff] [blame] | 1268 | try |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1269 | call WaitForAssert({-> assert_equal('quit', g:Ch_msg1)}) |
| 1270 | call WaitForAssert({-> assert_equal(2, g:Ch_closemsg)}) |
Bram Moolenaar | b2658a1 | 2016-04-26 17:16:24 +0200 | [diff] [blame] | 1271 | finally |
| 1272 | call job_stop(job) |
| 1273 | delfunc OutHandler |
| 1274 | delfunc CloseHandler |
| 1275 | endtry |
| 1276 | endfunc |
| 1277 | |
Bram Moolenaar | 437905c | 2016-04-26 19:01:05 +0200 | [diff] [blame] | 1278 | func Test_read_in_close_cb() |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1279 | let g:Ch_received = '' |
Bram Moolenaar | 437905c | 2016-04-26 19:01:05 +0200 | [diff] [blame] | 1280 | func! CloseHandler(chan) |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1281 | let g:Ch_received = ch_read(a:chan) |
Bram Moolenaar | 437905c | 2016-04-26 19:01:05 +0200 | [diff] [blame] | 1282 | endfunc |
| 1283 | let job = job_start(s:python . " test_channel_pipe.py quit now", |
| 1284 | \ {'close_cb': 'CloseHandler'}) |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 1285 | " the job may be done quickly, also accept "dead" |
| 1286 | call assert_match('^\%(dead\|run\)$', job_status(job)) |
Bram Moolenaar | 437905c | 2016-04-26 19:01:05 +0200 | [diff] [blame] | 1287 | try |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1288 | call WaitForAssert({-> assert_equal('quit', g:Ch_received)}) |
Bram Moolenaar | 437905c | 2016-04-26 19:01:05 +0200 | [diff] [blame] | 1289 | finally |
| 1290 | call job_stop(job) |
| 1291 | delfunc CloseHandler |
| 1292 | endtry |
| 1293 | endfunc |
| 1294 | |
Bram Moolenaar | 620ca2d | 2017-12-09 19:13:13 +0100 | [diff] [blame] | 1295 | " Use channel in NL mode but received text does not end in NL. |
| 1296 | func Test_read_in_close_cb_incomplete() |
Bram Moolenaar | 620ca2d | 2017-12-09 19:13:13 +0100 | [diff] [blame] | 1297 | let g:Ch_received = '' |
| 1298 | func! CloseHandler(chan) |
| 1299 | while ch_status(a:chan, {'part': 'out'}) == 'buffered' |
| 1300 | let g:Ch_received .= ch_read(a:chan) |
| 1301 | endwhile |
| 1302 | endfunc |
| 1303 | let job = job_start(s:python . " test_channel_pipe.py incomplete", |
| 1304 | \ {'close_cb': 'CloseHandler'}) |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 1305 | " the job may be done quickly, also accept "dead" |
| 1306 | call assert_match('^\%(dead\|run\)$', job_status(job)) |
Bram Moolenaar | 620ca2d | 2017-12-09 19:13:13 +0100 | [diff] [blame] | 1307 | try |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1308 | call WaitForAssert({-> assert_equal('incomplete', g:Ch_received)}) |
Bram Moolenaar | 620ca2d | 2017-12-09 19:13:13 +0100 | [diff] [blame] | 1309 | finally |
| 1310 | call job_stop(job) |
| 1311 | delfunc CloseHandler |
| 1312 | endtry |
| 1313 | endfunc |
| 1314 | |
Bram Moolenaar | 069c1e7 | 2016-07-15 21:25:08 +0200 | [diff] [blame] | 1315 | func Test_out_cb_lambda() |
Bram Moolenaar | 069c1e7 | 2016-07-15 21:25:08 +0200 | [diff] [blame] | 1316 | let job = job_start(s:python . " test_channel_pipe.py", |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 1317 | \ {'out_cb': {ch, msg -> execute("let g:Ch_outmsg = 'lambda: ' . msg")}, |
| 1318 | \ 'out_mode': 'json', |
| 1319 | \ 'err_cb': {ch, msg -> execute(":let g:Ch_errmsg = 'lambda: ' . msg")}, |
| 1320 | \ 'err_mode': 'json'}) |
Bram Moolenaar | 069c1e7 | 2016-07-15 21:25:08 +0200 | [diff] [blame] | 1321 | call assert_equal("run", job_status(job)) |
| 1322 | try |
| 1323 | let g:Ch_outmsg = '' |
| 1324 | let g:Ch_errmsg = '' |
| 1325 | call ch_sendraw(job, "echo [0, \"hello\"]\n") |
| 1326 | call ch_sendraw(job, "echoerr [0, \"there\"]\n") |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1327 | call WaitForAssert({-> assert_equal("lambda: hello", g:Ch_outmsg)}) |
| 1328 | call WaitForAssert({-> assert_equal("lambda: there", g:Ch_errmsg)}) |
Bram Moolenaar | 069c1e7 | 2016-07-15 21:25:08 +0200 | [diff] [blame] | 1329 | finally |
| 1330 | call job_stop(job) |
| 1331 | endtry |
| 1332 | endfunc |
| 1333 | |
Bram Moolenaar | 7df915d | 2016-11-17 17:25:32 +0100 | [diff] [blame] | 1334 | func Test_close_and_exit_cb() |
Bram Moolenaar | 3e1c617 | 2017-11-02 16:58:00 +0100 | [diff] [blame] | 1335 | let g:retdict = {'ret': {}} |
| 1336 | func g:retdict.close_cb(ch) dict |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 1337 | let self.ret['close_cb'] = a:ch->ch_getjob()->job_status() |
Bram Moolenaar | 7df915d | 2016-11-17 17:25:32 +0100 | [diff] [blame] | 1338 | endfunc |
Bram Moolenaar | 3e1c617 | 2017-11-02 16:58:00 +0100 | [diff] [blame] | 1339 | func g:retdict.exit_cb(job, status) dict |
Bram Moolenaar | 7df915d | 2016-11-17 17:25:32 +0100 | [diff] [blame] | 1340 | let self.ret['exit_cb'] = job_status(a:job) |
| 1341 | endfunc |
| 1342 | |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 1343 | let job = job_start([&shell, &shellcmdflag, 'echo'], |
| 1344 | \ {'close_cb': g:retdict.close_cb, |
| 1345 | \ 'exit_cb': g:retdict.exit_cb}) |
| 1346 | " the job may be done quickly, also accept "dead" |
| 1347 | call assert_match('^\%(dead\|run\)$', job_status(job)) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1348 | call WaitForAssert({-> assert_equal(2, len(g:retdict.ret))}) |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 1349 | call assert_match('^\%(dead\|run\)$', g:retdict.ret['close_cb']) |
Bram Moolenaar | 3e1c617 | 2017-11-02 16:58:00 +0100 | [diff] [blame] | 1350 | call assert_equal('dead', g:retdict.ret['exit_cb']) |
| 1351 | unlet g:retdict |
Bram Moolenaar | 7df915d | 2016-11-17 17:25:32 +0100 | [diff] [blame] | 1352 | endfunc |
| 1353 | |
Bram Moolenaar | d46ae14 | 2016-02-16 13:33:52 +0100 | [diff] [blame] | 1354 | """""""""" |
| 1355 | |
Bram Moolenaar | 0b14688 | 2018-09-06 16:27:24 +0200 | [diff] [blame] | 1356 | function ExitCbWipe(job, status) |
| 1357 | exe g:wipe_buf 'bw!' |
| 1358 | endfunction |
| 1359 | |
| 1360 | " This caused a crash, because messages were handled while peeking for a |
| 1361 | " character. |
| 1362 | func Test_exit_cb_wipes_buf() |
Bram Moolenaar | 6d91bcb | 2020-08-12 18:50:36 +0200 | [diff] [blame] | 1363 | CheckFeature timers |
Bram Moolenaar | 0b14688 | 2018-09-06 16:27:24 +0200 | [diff] [blame] | 1364 | set cursorline lazyredraw |
| 1365 | call test_override('redraw_flag', 1) |
| 1366 | new |
| 1367 | let g:wipe_buf = bufnr('') |
| 1368 | |
Bram Moolenaar | 453ce7c | 2018-10-12 22:15:12 +0200 | [diff] [blame] | 1369 | let job = job_start(has('win32') ? 'cmd /c echo:' : ['true'], |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 1370 | \ {'exit_cb': 'ExitCbWipe'}) |
Bram Moolenaar | 0b14688 | 2018-09-06 16:27:24 +0200 | [diff] [blame] | 1371 | let timer = timer_start(300, {-> feedkeys("\<Esc>", 'nt')}, {'repeat': 5}) |
| 1372 | call feedkeys(repeat('g', 1000) . 'o', 'ntx!') |
| 1373 | call WaitForAssert({-> assert_equal("dead", job_status(job))}) |
| 1374 | call timer_stop(timer) |
| 1375 | |
| 1376 | set nocursorline nolazyredraw |
| 1377 | unlet g:wipe_buf |
| 1378 | call test_override('ALL', 0) |
| 1379 | endfunc |
| 1380 | |
| 1381 | """""""""" |
| 1382 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1383 | let g:Ch_unletResponse = '' |
Bram Moolenaar | 3bece9f | 2016-02-15 20:39:46 +0100 | [diff] [blame] | 1384 | func s:UnletHandler(handle, msg) |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1385 | let g:Ch_unletResponse = a:msg |
Bram Moolenaar | 3bece9f | 2016-02-15 20:39:46 +0100 | [diff] [blame] | 1386 | unlet s:channelfd |
| 1387 | endfunc |
| 1388 | |
| 1389 | " Test that "unlet handle" in a handler doesn't crash Vim. |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1390 | func Ch_unlet_handle(port) |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 1391 | let s:channelfd = ch_open(s:localhost . a:port, s:chopt) |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 1392 | eval s:channelfd->ch_sendexpr("test", {'callback': function('s:UnletHandler')}) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1393 | call WaitForAssert({-> assert_equal('what?', g:Ch_unletResponse)}) |
Bram Moolenaar | 3bece9f | 2016-02-15 20:39:46 +0100 | [diff] [blame] | 1394 | endfunc |
| 1395 | |
| 1396 | func Test_unlet_handle() |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1397 | call s:run_server('Ch_unlet_handle') |
Bram Moolenaar | 3bece9f | 2016-02-15 20:39:46 +0100 | [diff] [blame] | 1398 | endfunc |
Bram Moolenaar | 5cefd40 | 2016-02-16 12:44:26 +0100 | [diff] [blame] | 1399 | |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 1400 | func Test_unlet_handle_ipv6() |
| 1401 | CheckIPv6 |
| 1402 | call Test_unlet_handle() |
| 1403 | endfunc |
| 1404 | |
Bram Moolenaar | d46ae14 | 2016-02-16 13:33:52 +0100 | [diff] [blame] | 1405 | """""""""" |
| 1406 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1407 | let g:Ch_unletResponse = '' |
| 1408 | func Ch_CloseHandler(handle, msg) |
| 1409 | let g:Ch_unletResponse = a:msg |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 1410 | eval s:channelfd->ch_close() |
Bram Moolenaar | d46ae14 | 2016-02-16 13:33:52 +0100 | [diff] [blame] | 1411 | endfunc |
| 1412 | |
| 1413 | " Test that "unlet handle" in a handler doesn't crash Vim. |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1414 | func Ch_close_handle(port) |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 1415 | let s:channelfd = ch_open(s:localhost . a:port, s:chopt) |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1416 | call ch_sendexpr(s:channelfd, "test", {'callback': function('Ch_CloseHandler')}) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1417 | call WaitForAssert({-> assert_equal('what?', g:Ch_unletResponse)}) |
Bram Moolenaar | d46ae14 | 2016-02-16 13:33:52 +0100 | [diff] [blame] | 1418 | endfunc |
| 1419 | |
| 1420 | func Test_close_handle() |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1421 | call s:run_server('Ch_close_handle') |
Bram Moolenaar | d46ae14 | 2016-02-16 13:33:52 +0100 | [diff] [blame] | 1422 | endfunc |
| 1423 | |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 1424 | func Test_close_handle_ipv6() |
| 1425 | CheckIPv6 |
| 1426 | call Test_close_handle() |
| 1427 | endfunc |
| 1428 | |
| 1429 | """""""""" |
| 1430 | |
| 1431 | func Ch_open_ipv6(port) |
| 1432 | let handle = ch_open('[::1]:' .. a:port, s:chopt) |
| 1433 | call assert_notequal('fail', ch_status(handle)) |
| 1434 | endfunc |
| 1435 | |
| 1436 | func Test_open_ipv6() |
| 1437 | CheckIPv6 |
| 1438 | call s:run_server('Ch_open_ipv6') |
| 1439 | endfunc |
| 1440 | |
Bram Moolenaar | d46ae14 | 2016-02-16 13:33:52 +0100 | [diff] [blame] | 1441 | """""""""" |
| 1442 | |
Bram Moolenaar | 5cefd40 | 2016-02-16 12:44:26 +0100 | [diff] [blame] | 1443 | func Test_open_fail() |
Bram Moolenaar | ca68ae1 | 2020-03-30 19:32:53 +0200 | [diff] [blame] | 1444 | call assert_fails("let ch = ch_open('noserver')", 'E475:') |
Bram Moolenaar | 5cefd40 | 2016-02-16 12:44:26 +0100 | [diff] [blame] | 1445 | echo ch |
| 1446 | let d = ch |
Bram Moolenaar | ca68ae1 | 2020-03-30 19:32:53 +0200 | [diff] [blame] | 1447 | call assert_fails("let ch = ch_open('noserver', 10)", 'E474:') |
| 1448 | call assert_fails("let ch = ch_open('localhost:-1')", 'E475:') |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 1449 | call assert_fails("let ch = ch_open('localhost:65537')", 'E475:') |
Bram Moolenaar | ca68ae1 | 2020-03-30 19:32:53 +0200 | [diff] [blame] | 1450 | call assert_fails("let ch = ch_open('localhost:8765', {'timeout' : -1})", |
| 1451 | \ 'E474:') |
| 1452 | call assert_fails("let ch = ch_open('localhost:8765', {'axby' : 1})", |
| 1453 | \ 'E475:') |
| 1454 | call assert_fails("let ch = ch_open('localhost:8765', {'mode' : 'abc'})", |
| 1455 | \ 'E475:') |
| 1456 | call assert_fails("let ch = ch_open('localhost:8765', {'part' : 'out'})", |
| 1457 | \ 'E475:') |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 1458 | call assert_fails("let ch = ch_open('[::]')", 'E475:') |
| 1459 | call assert_fails("let ch = ch_open('[::.80')", 'E475:') |
| 1460 | call assert_fails("let ch = ch_open('[::]8080')", 'E475:') |
Bram Moolenaar | ca68ae1 | 2020-03-30 19:32:53 +0200 | [diff] [blame] | 1461 | endfunc |
| 1462 | |
| 1463 | func Test_ch_info_fail() |
| 1464 | call assert_fails("let x = ch_info(10)", 'E475:') |
Bram Moolenaar | 5cefd40 | 2016-02-16 12:44:26 +0100 | [diff] [blame] | 1465 | endfunc |
Bram Moolenaar | 81661fb | 2016-02-18 22:23:34 +0100 | [diff] [blame] | 1466 | |
| 1467 | """""""""" |
| 1468 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1469 | func Ch_open_delay(port) |
Bram Moolenaar | 81661fb | 2016-02-18 22:23:34 +0100 | [diff] [blame] | 1470 | " Wait up to a second for the port to open. |
| 1471 | let s:chopt.waittime = 1000 |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 1472 | let channel = ch_open(s:localhost . a:port, s:chopt) |
Bram Moolenaar | 81661fb | 2016-02-18 22:23:34 +0100 | [diff] [blame] | 1473 | if ch_status(channel) == "fail" |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 1474 | call assert_report("Can't open channel") |
Bram Moolenaar | 81661fb | 2016-02-18 22:23:34 +0100 | [diff] [blame] | 1475 | return |
| 1476 | endif |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 1477 | call assert_equal('got it', channel->ch_evalexpr('hello!')) |
Bram Moolenaar | 81661fb | 2016-02-18 22:23:34 +0100 | [diff] [blame] | 1478 | call ch_close(channel) |
| 1479 | endfunc |
| 1480 | |
| 1481 | func Test_open_delay() |
Bram Moolenaar | 81661fb | 2016-02-18 22:23:34 +0100 | [diff] [blame] | 1482 | " The server will wait half a second before creating the port. |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1483 | call s:run_server('Ch_open_delay', 'delay') |
Bram Moolenaar | 81661fb | 2016-02-18 22:23:34 +0100 | [diff] [blame] | 1484 | endfunc |
Bram Moolenaar | ece61b0 | 2016-02-20 21:39:05 +0100 | [diff] [blame] | 1485 | |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 1486 | func Test_open_delay_ipv6() |
| 1487 | CheckIPv6 |
| 1488 | call Test_open_delay() |
| 1489 | endfunc |
| 1490 | |
Bram Moolenaar | ece61b0 | 2016-02-20 21:39:05 +0100 | [diff] [blame] | 1491 | """"""""" |
| 1492 | |
| 1493 | function MyFunction(a,b,c) |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1494 | let g:Ch_call_ret = [a:a, a:b, a:c] |
Bram Moolenaar | ece61b0 | 2016-02-20 21:39:05 +0100 | [diff] [blame] | 1495 | endfunc |
| 1496 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1497 | function Ch_test_call(port) |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 1498 | let handle = ch_open(s:localhost . a:port, s:chopt) |
Bram Moolenaar | ece61b0 | 2016-02-20 21:39:05 +0100 | [diff] [blame] | 1499 | if ch_status(handle) == "fail" |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 1500 | call assert_report("Can't open channel") |
Bram Moolenaar | ece61b0 | 2016-02-20 21:39:05 +0100 | [diff] [blame] | 1501 | return |
| 1502 | endif |
| 1503 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1504 | let g:Ch_call_ret = [] |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 1505 | call assert_equal('ok', ch_evalexpr(handle, 'call-func')) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1506 | call WaitForAssert({-> assert_equal([1, 2, 3], g:Ch_call_ret)}) |
Bram Moolenaar | ca68ae1 | 2020-03-30 19:32:53 +0200 | [diff] [blame] | 1507 | |
| 1508 | call assert_fails("let i = ch_evalexpr(handle, '2 + 2', {'callback' : 'abc'})", 'E917:') |
| 1509 | call assert_fails("let i = ch_evalexpr(handle, '2 + 2', {'drop' : ''})", 'E475:') |
| 1510 | call assert_fails("let i = ch_evalexpr(test_null_job(), '2 + 2')", 'E906:') |
Bram Moolenaar | ece61b0 | 2016-02-20 21:39:05 +0100 | [diff] [blame] | 1511 | endfunc |
| 1512 | |
| 1513 | func Test_call() |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1514 | call s:run_server('Ch_test_call') |
Bram Moolenaar | ece61b0 | 2016-02-20 21:39:05 +0100 | [diff] [blame] | 1515 | endfunc |
Bram Moolenaar | ee1cffc | 2016-02-21 19:14:41 +0100 | [diff] [blame] | 1516 | |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 1517 | func Test_call_ipv6() |
| 1518 | CheckIPv6 |
| 1519 | call Test_call() |
| 1520 | endfunc |
| 1521 | |
Bram Moolenaar | ee1cffc | 2016-02-21 19:14:41 +0100 | [diff] [blame] | 1522 | """"""""" |
| 1523 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1524 | let g:Ch_job_exit_ret = 'not yet' |
Bram Moolenaar | ee1cffc | 2016-02-21 19:14:41 +0100 | [diff] [blame] | 1525 | function MyExitCb(job, status) |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1526 | let g:Ch_job_exit_ret = 'done' |
Bram Moolenaar | ee1cffc | 2016-02-21 19:14:41 +0100 | [diff] [blame] | 1527 | endfunc |
| 1528 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1529 | function Ch_test_exit_callback(port) |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 1530 | eval g:currentJob->job_setoptions({'exit_cb': 'MyExitCb'}) |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1531 | let g:Ch_exit_job = g:currentJob |
| 1532 | call assert_equal('MyExitCb', job_info(g:currentJob)['exit_cb']) |
Bram Moolenaar | ee1cffc | 2016-02-21 19:14:41 +0100 | [diff] [blame] | 1533 | endfunc |
| 1534 | |
| 1535 | func Test_exit_callback() |
Bram Moolenaar | f386f08 | 2019-07-29 23:03:03 +0200 | [diff] [blame] | 1536 | call s:run_server('Ch_test_exit_callback') |
Bram Moolenaar | ee1cffc | 2016-02-21 19:14:41 +0100 | [diff] [blame] | 1537 | |
Bram Moolenaar | f386f08 | 2019-07-29 23:03:03 +0200 | [diff] [blame] | 1538 | " wait up to a second for the job to exit |
| 1539 | for i in range(100) |
| 1540 | if g:Ch_job_exit_ret == 'done' |
| 1541 | break |
| 1542 | endif |
| 1543 | sleep 10m |
| 1544 | " calling job_status() triggers the callback |
| 1545 | call job_status(g:Ch_exit_job) |
| 1546 | endfor |
Bram Moolenaar | ee1cffc | 2016-02-21 19:14:41 +0100 | [diff] [blame] | 1547 | |
Bram Moolenaar | f386f08 | 2019-07-29 23:03:03 +0200 | [diff] [blame] | 1548 | call assert_equal('done', g:Ch_job_exit_ret) |
| 1549 | call assert_equal('dead', job_info(g:Ch_exit_job).status) |
| 1550 | unlet g:Ch_exit_job |
Bram Moolenaar | ee1cffc | 2016-02-21 19:14:41 +0100 | [diff] [blame] | 1551 | endfunc |
Bram Moolenaar | 4e221c9 | 2016-02-23 13:20:22 +0100 | [diff] [blame] | 1552 | |
Bram Moolenaar | 97792de | 2016-10-15 18:36:49 +0200 | [diff] [blame] | 1553 | function MyExitTimeCb(job, status) |
Bram Moolenaar | 01688ad | 2016-10-27 20:00:07 +0200 | [diff] [blame] | 1554 | if job_info(a:job).process == g:exit_cb_val.process |
| 1555 | let g:exit_cb_val.end = reltime(g:exit_cb_val.start) |
| 1556 | endif |
| 1557 | call Resume() |
Bram Moolenaar | 97792de | 2016-10-15 18:36:49 +0200 | [diff] [blame] | 1558 | endfunction |
| 1559 | |
| 1560 | func Test_exit_callback_interval() |
Bram Moolenaar | 5feabe0 | 2020-01-30 18:24:53 +0100 | [diff] [blame] | 1561 | CheckFunction reltimefloat |
| 1562 | |
Bram Moolenaar | 01688ad | 2016-10-27 20:00:07 +0200 | [diff] [blame] | 1563 | let g:exit_cb_val = {'start': reltime(), 'end': 0, 'process': 0} |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 1564 | let job = [s:python, '-c', 'import time;time.sleep(0.5)']->job_start({'exit_cb': 'MyExitTimeCb'}) |
Bram Moolenaar | 01688ad | 2016-10-27 20:00:07 +0200 | [diff] [blame] | 1565 | let g:exit_cb_val.process = job_info(job).process |
Bram Moolenaar | 769e9d2 | 2018-04-11 20:53:49 +0200 | [diff] [blame] | 1566 | call WaitFor('type(g:exit_cb_val.end) != v:t_number || g:exit_cb_val.end != 0') |
Bram Moolenaar | 01688ad | 2016-10-27 20:00:07 +0200 | [diff] [blame] | 1567 | let elapsed = reltimefloat(g:exit_cb_val.end) |
| 1568 | call assert_true(elapsed > 0.5) |
| 1569 | call assert_true(elapsed < 1.0) |
| 1570 | |
| 1571 | " case: unreferenced job, using timer |
| 1572 | if !has('timers') |
| 1573 | return |
| 1574 | endif |
| 1575 | |
| 1576 | let g:exit_cb_val = {'start': reltime(), 'end': 0, 'process': 0} |
| 1577 | let g:job = job_start([s:python, '-c', 'import time;time.sleep(0.5)'], {'exit_cb': 'MyExitTimeCb'}) |
| 1578 | let g:exit_cb_val.process = job_info(g:job).process |
| 1579 | unlet g:job |
| 1580 | call Standby(1000) |
| 1581 | if type(g:exit_cb_val.end) != v:t_number || g:exit_cb_val.end != 0 |
| 1582 | let elapsed = reltimefloat(g:exit_cb_val.end) |
| 1583 | else |
| 1584 | let elapsed = 1.0 |
| 1585 | endif |
Bram Moolenaar | 772153f | 2019-03-04 12:09:49 +0100 | [diff] [blame] | 1586 | call assert_inrange(0.5, 1.0, elapsed) |
Bram Moolenaar | 97792de | 2016-10-15 18:36:49 +0200 | [diff] [blame] | 1587 | endfunc |
| 1588 | |
Bram Moolenaar | 4e221c9 | 2016-02-23 13:20:22 +0100 | [diff] [blame] | 1589 | """"""""" |
| 1590 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1591 | let g:Ch_close_ret = 'alive' |
Bram Moolenaar | 4e221c9 | 2016-02-23 13:20:22 +0100 | [diff] [blame] | 1592 | function MyCloseCb(ch) |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1593 | let g:Ch_close_ret = 'closed' |
Bram Moolenaar | 4e221c9 | 2016-02-23 13:20:22 +0100 | [diff] [blame] | 1594 | endfunc |
| 1595 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1596 | function Ch_test_close_callback(port) |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 1597 | let handle = ch_open(s:localhost . a:port, s:chopt) |
Bram Moolenaar | 4e221c9 | 2016-02-23 13:20:22 +0100 | [diff] [blame] | 1598 | if ch_status(handle) == "fail" |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 1599 | call assert_report("Can't open channel") |
Bram Moolenaar | 4e221c9 | 2016-02-23 13:20:22 +0100 | [diff] [blame] | 1600 | return |
| 1601 | endif |
Bram Moolenaar | d6c2f05 | 2016-03-14 23:22:59 +0100 | [diff] [blame] | 1602 | call ch_setoptions(handle, {'close_cb': 'MyCloseCb'}) |
Bram Moolenaar | 4e221c9 | 2016-02-23 13:20:22 +0100 | [diff] [blame] | 1603 | |
Bram Moolenaar | 8b1862a | 2016-02-27 19:21:24 +0100 | [diff] [blame] | 1604 | call assert_equal('', ch_evalexpr(handle, 'close me')) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1605 | call WaitForAssert({-> assert_equal('closed', g:Ch_close_ret)}) |
Bram Moolenaar | 4e221c9 | 2016-02-23 13:20:22 +0100 | [diff] [blame] | 1606 | endfunc |
| 1607 | |
| 1608 | func Test_close_callback() |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1609 | call s:run_server('Ch_test_close_callback') |
Bram Moolenaar | 4e221c9 | 2016-02-23 13:20:22 +0100 | [diff] [blame] | 1610 | endfunc |
| 1611 | |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 1612 | func Test_close_callback_ipv6() |
| 1613 | CheckIPv6 |
| 1614 | call Test_close_callback() |
| 1615 | endfunc |
| 1616 | |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1617 | function Ch_test_close_partial(port) |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 1618 | let handle = ch_open(s:localhost . a:port, s:chopt) |
Bram Moolenaar | bdf0bda | 2016-03-30 21:06:57 +0200 | [diff] [blame] | 1619 | if ch_status(handle) == "fail" |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 1620 | call assert_report("Can't open channel") |
Bram Moolenaar | bdf0bda | 2016-03-30 21:06:57 +0200 | [diff] [blame] | 1621 | return |
| 1622 | endif |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1623 | let g:Ch_d = {} |
| 1624 | func g:Ch_d.closeCb(ch) dict |
Bram Moolenaar | bdf0bda | 2016-03-30 21:06:57 +0200 | [diff] [blame] | 1625 | let self.close_ret = 'closed' |
| 1626 | endfunc |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1627 | call ch_setoptions(handle, {'close_cb': g:Ch_d.closeCb}) |
Bram Moolenaar | bdf0bda | 2016-03-30 21:06:57 +0200 | [diff] [blame] | 1628 | |
| 1629 | call assert_equal('', ch_evalexpr(handle, 'close me')) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1630 | call WaitForAssert({-> assert_equal('closed', g:Ch_d.close_ret)}) |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1631 | unlet g:Ch_d |
Bram Moolenaar | bdf0bda | 2016-03-30 21:06:57 +0200 | [diff] [blame] | 1632 | endfunc |
| 1633 | |
| 1634 | func Test_close_partial() |
Bram Moolenaar | 321efdd | 2016-07-15 17:09:11 +0200 | [diff] [blame] | 1635 | call s:run_server('Ch_test_close_partial') |
Bram Moolenaar | bdf0bda | 2016-03-30 21:06:57 +0200 | [diff] [blame] | 1636 | endfunc |
| 1637 | |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 1638 | func Test_close_partial_ipv6() |
| 1639 | CheckIPv6 |
| 1640 | call Test_close_partial() |
| 1641 | endfunc |
| 1642 | |
Bram Moolenaar | ca68ae1 | 2020-03-30 19:32:53 +0200 | [diff] [blame] | 1643 | func Test_job_start_fails() |
| 1644 | " this was leaking memory |
| 1645 | call assert_fails("call job_start([''])", "E474:") |
Bram Moolenaar | 8038568 | 2016-03-27 19:13:35 +0200 | [diff] [blame] | 1646 | call assert_fails('call job_start($x)', 'E474:') |
| 1647 | call assert_fails('call job_start("")', 'E474:') |
Bram Moolenaar | ca68ae1 | 2020-03-30 19:32:53 +0200 | [diff] [blame] | 1648 | call assert_fails('call job_start("ls", {"out_io" : "abc"})', 'E475:') |
| 1649 | call assert_fails('call job_start("ls", {"err_io" : "abc"})', 'E475:') |
| 1650 | call assert_fails('call job_start("ls", [])', 'E715:') |
| 1651 | call assert_fails("call job_start('ls', {'in_top' : -1})", 'E475:') |
| 1652 | call assert_fails("call job_start('ls', {'in_bot' : -1})", 'E475:') |
| 1653 | call assert_fails("call job_start('ls', {'channel' : -1})", 'E475:') |
Bram Moolenaar | 9b7bf9e | 2020-07-11 22:14:59 +0200 | [diff] [blame] | 1654 | call assert_fails("call job_start('ls', {'callback' : -1})", 'E921:') |
| 1655 | call assert_fails("call job_start('ls', {'out_cb' : -1})", 'E921:') |
| 1656 | call assert_fails("call job_start('ls', {'err_cb' : -1})", 'E921:') |
| 1657 | call assert_fails("call job_start('ls', {'close_cb' : -1})", 'E921:') |
| 1658 | call assert_fails("call job_start('ls', {'exit_cb' : -1})", 'E921:') |
Bram Moolenaar | ca68ae1 | 2020-03-30 19:32:53 +0200 | [diff] [blame] | 1659 | call assert_fails("call job_start('ls', {'term_name' : []})", 'E475:') |
| 1660 | call assert_fails("call job_start('ls', {'term_finish' : 'run'})", 'E475:') |
| 1661 | call assert_fails("call job_start('ls', {'term_api' : []})", 'E475:') |
Bram Moolenaar | 9b7bf9e | 2020-07-11 22:14:59 +0200 | [diff] [blame] | 1662 | call assert_fails("call job_start('ls', {'stoponexit' : []})", 'E730:') |
Bram Moolenaar | ca68ae1 | 2020-03-30 19:32:53 +0200 | [diff] [blame] | 1663 | call assert_fails("call job_start('ls', {'in_io' : 'file'})", 'E920:') |
| 1664 | call assert_fails("call job_start('ls', {'out_io' : 'file'})", 'E920:') |
| 1665 | call assert_fails("call job_start('ls', {'err_io' : 'file'})", 'E920:') |
| 1666 | call assert_fails("call job_start('ls', {'in_mode' : 'abc'})", 'E475:') |
| 1667 | call assert_fails("call job_start('ls', {'out_mode' : 'abc'})", 'E475:') |
| 1668 | call assert_fails("call job_start('ls', {'err_mode' : 'abc'})", 'E475:') |
| 1669 | call assert_fails("call job_start('ls', |
| 1670 | \ {'in_io' : 'buffer', 'in_buf' : 99999})", 'E86:') |
| 1671 | call assert_fails("call job_start('ls', |
| 1672 | \ {'out_io' : 'buffer', 'out_buf' : 99999})", 'E86:') |
| 1673 | call assert_fails("call job_start('ls', |
| 1674 | \ {'err_io' : 'buffer', 'err_buf' : 99999})", 'E86:') |
| 1675 | |
| 1676 | call assert_fails("call job_start('ls', |
| 1677 | \ {'in_io' : 'buffer', 'in_buf' : -1})", 'E475:') |
| 1678 | call assert_fails("call job_start('ls', |
| 1679 | \ {'out_io' : 'buffer', 'out_buf' : -1})", 'E475:') |
| 1680 | call assert_fails("call job_start('ls', |
| 1681 | \ {'err_io' : 'buffer', 'err_buf' : -1})", 'E475:') |
| 1682 | |
| 1683 | set nomodifiable |
| 1684 | call assert_fails("call job_start('cmd /c dir', |
| 1685 | \ {'out_io' : 'buffer', 'out_buf' :" .. bufnr() .. "})", 'E21:') |
| 1686 | call assert_fails("call job_start('cmd /c dir', |
| 1687 | \ {'err_io' : 'buffer', 'err_buf' :" .. bufnr() .. "})", 'E21:') |
| 1688 | set modifiable |
| 1689 | |
| 1690 | call assert_fails("call job_start('ls', {'in_io' : 'buffer'})", 'E915:') |
| 1691 | |
| 1692 | edit! XXX |
| 1693 | let bnum = bufnr() |
| 1694 | enew |
| 1695 | call assert_fails("call job_start('ls', |
| 1696 | \ {'in_io' : 'buffer', 'in_buf' : bnum})", 'E918:') |
| 1697 | |
| 1698 | " Empty job tests |
| 1699 | " This was crashing on MS-Windows. |
| 1700 | call assert_fails('let job = job_start([""])', 'E474:') |
| 1701 | call assert_fails('let job = job_start([" "])', 'E474:') |
| 1702 | call assert_fails('let job = job_start("")', 'E474:') |
| 1703 | call assert_fails('let job = job_start(" ")', 'E474:') |
Bram Moolenaar | 0015795 | 2020-04-13 17:44:47 +0200 | [diff] [blame] | 1704 | call assert_fails('let job = job_start(["ls", []])', 'E730:') |
Bram Moolenaar | ad48e6c | 2020-04-21 22:19:45 +0200 | [diff] [blame] | 1705 | call assert_fails('call job_setoptions(test_null_job(), {})', 'E916:') |
Bram Moolenaar | ca68ae1 | 2020-03-30 19:32:53 +0200 | [diff] [blame] | 1706 | %bw! |
Bram Moolenaar | 8038568 | 2016-03-27 19:13:35 +0200 | [diff] [blame] | 1707 | endfunc |
| 1708 | |
Bram Moolenaar | bb09ceb | 2016-10-18 16:27:23 +0200 | [diff] [blame] | 1709 | func Test_job_stop_immediately() |
Bram Moolenaar | 3e1c617 | 2017-11-02 16:58:00 +0100 | [diff] [blame] | 1710 | let g:job = job_start([s:python, '-c', 'import time;time.sleep(10)']) |
Bram Moolenaar | bb09ceb | 2016-10-18 16:27:23 +0200 | [diff] [blame] | 1711 | try |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 1712 | eval g:job->job_stop() |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1713 | call WaitForAssert({-> assert_equal('dead', job_status(g:job))}) |
Bram Moolenaar | bb09ceb | 2016-10-18 16:27:23 +0200 | [diff] [blame] | 1714 | finally |
Bram Moolenaar | 3e1c617 | 2017-11-02 16:58:00 +0100 | [diff] [blame] | 1715 | call job_stop(g:job, 'kill') |
| 1716 | unlet g:job |
Bram Moolenaar | bb09ceb | 2016-10-18 16:27:23 +0200 | [diff] [blame] | 1717 | endtry |
| 1718 | endfunc |
| 1719 | |
Bram Moolenaar | ebf7dfa | 2016-04-14 12:46:51 +0200 | [diff] [blame] | 1720 | " This was leaking memory. |
Bram Moolenaar | 0e4c1de | 2016-04-07 21:40:38 +0200 | [diff] [blame] | 1721 | func Test_partial_in_channel_cycle() |
| 1722 | let d = {} |
| 1723 | let d.a = function('string', [d]) |
| 1724 | try |
| 1725 | let d.b = ch_open('nowhere:123', {'close_cb': d.a}) |
Bram Moolenaar | 92b83cc | 2020-04-25 15:24:44 +0200 | [diff] [blame] | 1726 | call test_garbagecollect_now() |
Bram Moolenaar | 0e4c1de | 2016-04-07 21:40:38 +0200 | [diff] [blame] | 1727 | catch |
| 1728 | call assert_exception('E901:') |
| 1729 | endtry |
| 1730 | unlet d |
| 1731 | endfunc |
| 1732 | |
Bram Moolenaar | ebf7dfa | 2016-04-14 12:46:51 +0200 | [diff] [blame] | 1733 | func Test_using_freed_memory() |
| 1734 | let g:a = job_start(['ls']) |
| 1735 | sleep 10m |
Bram Moolenaar | 574860b | 2016-05-24 17:33:34 +0200 | [diff] [blame] | 1736 | call test_garbagecollect_now() |
Bram Moolenaar | ebf7dfa | 2016-04-14 12:46:51 +0200 | [diff] [blame] | 1737 | endfunc |
| 1738 | |
Bram Moolenaar | b8aefa4 | 2016-06-10 23:02:56 +0200 | [diff] [blame] | 1739 | func Test_collapse_buffers() |
Bram Moolenaar | 8c5a278 | 2019-08-07 23:07:07 +0200 | [diff] [blame] | 1740 | CheckExecutable cat |
| 1741 | |
Bram Moolenaar | b8aefa4 | 2016-06-10 23:02:56 +0200 | [diff] [blame] | 1742 | sp test_channel.vim |
| 1743 | let g:linecount = line('$') |
| 1744 | close |
| 1745 | split testout |
| 1746 | 1,$delete |
| 1747 | call job_start('cat test_channel.vim', {'out_io': 'buffer', 'out_name': 'testout'}) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1748 | call WaitForAssert({-> assert_inrange(g:linecount, g:linecount + 1, line('$'))}) |
Bram Moolenaar | b8aefa4 | 2016-06-10 23:02:56 +0200 | [diff] [blame] | 1749 | bwipe! |
| 1750 | endfunc |
Bram Moolenaar | ebf7dfa | 2016-04-14 12:46:51 +0200 | [diff] [blame] | 1751 | |
Bram Moolenaar | 8b62d87 | 2019-01-05 00:02:57 +0100 | [diff] [blame] | 1752 | func Test_write_to_deleted_buffer() |
Bram Moolenaar | 8c5a278 | 2019-08-07 23:07:07 +0200 | [diff] [blame] | 1753 | CheckExecutable echo |
Bram Moolenaar | 5a4c308 | 2019-12-01 15:23:11 +0100 | [diff] [blame] | 1754 | CheckFeature quickfix |
Bram Moolenaar | 8c5a278 | 2019-08-07 23:07:07 +0200 | [diff] [blame] | 1755 | |
Bram Moolenaar | 8b62d87 | 2019-01-05 00:02:57 +0100 | [diff] [blame] | 1756 | let job = job_start('echo hello', {'out_io': 'buffer', 'out_name': 'test_buffer', 'out_msg': 0}) |
Bram Moolenaar | 8b62d87 | 2019-01-05 00:02:57 +0100 | [diff] [blame] | 1757 | let bufnr = bufnr('test_buffer') |
Bram Moolenaar | f780b8a | 2019-01-05 00:35:22 +0100 | [diff] [blame] | 1758 | call WaitForAssert({-> assert_equal(['hello'], getbufline(bufnr, 1, '$'))}) |
Bram Moolenaar | 8b62d87 | 2019-01-05 00:02:57 +0100 | [diff] [blame] | 1759 | call assert_equal('nofile', getbufvar(bufnr, '&buftype')) |
| 1760 | call assert_equal('hide', getbufvar(bufnr, '&bufhidden')) |
Bram Moolenaar | f780b8a | 2019-01-05 00:35:22 +0100 | [diff] [blame] | 1761 | |
Bram Moolenaar | 8b62d87 | 2019-01-05 00:02:57 +0100 | [diff] [blame] | 1762 | bdel test_buffer |
| 1763 | call assert_equal([], getbufline(bufnr, 1, '$')) |
| 1764 | |
| 1765 | let job = job_start('echo hello', {'out_io': 'buffer', 'out_name': 'test_buffer', 'out_msg': 0}) |
Bram Moolenaar | f780b8a | 2019-01-05 00:35:22 +0100 | [diff] [blame] | 1766 | call WaitForAssert({-> assert_equal(['hello'], getbufline(bufnr, 1, '$'))}) |
Bram Moolenaar | 8b62d87 | 2019-01-05 00:02:57 +0100 | [diff] [blame] | 1767 | call assert_equal('nofile', getbufvar(bufnr, '&buftype')) |
| 1768 | call assert_equal('hide', getbufvar(bufnr, '&bufhidden')) |
| 1769 | |
| 1770 | bwipe! test_buffer |
| 1771 | endfunc |
| 1772 | |
Bram Moolenaar | d78f03f | 2017-10-06 01:07:41 +0200 | [diff] [blame] | 1773 | func Test_cmd_parsing() |
Bram Moolenaar | ec9b017 | 2020-06-19 19:10:59 +0200 | [diff] [blame] | 1774 | CheckUnix |
| 1775 | |
Bram Moolenaar | d78f03f | 2017-10-06 01:07:41 +0200 | [diff] [blame] | 1776 | call assert_false(filereadable("file with space")) |
| 1777 | let job = job_start('touch "file with space"') |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1778 | call WaitForAssert({-> assert_true(filereadable("file with space"))}) |
Bram Moolenaar | d78f03f | 2017-10-06 01:07:41 +0200 | [diff] [blame] | 1779 | call delete("file with space") |
| 1780 | |
| 1781 | let job = job_start('touch file\ with\ space') |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1782 | call WaitForAssert({-> assert_true(filereadable("file with space"))}) |
Bram Moolenaar | d78f03f | 2017-10-06 01:07:41 +0200 | [diff] [blame] | 1783 | call delete("file with space") |
| 1784 | endfunc |
| 1785 | |
Bram Moolenaar | 8211798 | 2016-08-27 19:21:48 +0200 | [diff] [blame] | 1786 | func Test_raw_passes_nul() |
Bram Moolenaar | 8c5a278 | 2019-08-07 23:07:07 +0200 | [diff] [blame] | 1787 | CheckExecutable cat |
Bram Moolenaar | 8211798 | 2016-08-27 19:21:48 +0200 | [diff] [blame] | 1788 | |
| 1789 | " Test lines from the job containing NUL are stored correctly in a buffer. |
| 1790 | new |
| 1791 | call setline(1, ["asdf\nasdf", "xxx\n", "\nyyy"]) |
| 1792 | w! Xtestread |
| 1793 | bwipe! |
| 1794 | split testout |
| 1795 | 1,$delete |
| 1796 | call job_start('cat Xtestread', {'out_io': 'buffer', 'out_name': 'testout'}) |
| 1797 | call WaitFor('line("$") > 2') |
Bram Moolenaar | 169ebb0 | 2016-09-07 23:32:23 +0200 | [diff] [blame] | 1798 | call assert_equal("asdf\nasdf", getline(1)) |
| 1799 | call assert_equal("xxx\n", getline(2)) |
| 1800 | call assert_equal("\nyyy", getline(3)) |
Bram Moolenaar | 8211798 | 2016-08-27 19:21:48 +0200 | [diff] [blame] | 1801 | |
| 1802 | call delete('Xtestread') |
| 1803 | bwipe! |
| 1804 | |
| 1805 | " Test lines from a buffer with NUL bytes are written correctly to the job. |
| 1806 | new mybuffer |
| 1807 | call setline(1, ["asdf\nasdf", "xxx\n", "\nyyy"]) |
| 1808 | let g:Ch_job = job_start('cat', {'in_io': 'buffer', 'in_name': 'mybuffer', 'out_io': 'file', 'out_name': 'Xtestwrite'}) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1809 | call WaitForAssert({-> assert_equal("dead", job_status(g:Ch_job))}) |
Bram Moolenaar | 8211798 | 2016-08-27 19:21:48 +0200 | [diff] [blame] | 1810 | bwipe! |
| 1811 | split Xtestwrite |
| 1812 | call assert_equal("asdf\nasdf", getline(1)) |
| 1813 | call assert_equal("xxx\n", getline(2)) |
| 1814 | call assert_equal("\nyyy", getline(3)) |
Bram Moolenaar | 81952470 | 2018-02-27 19:10:00 +0100 | [diff] [blame] | 1815 | call assert_equal(-1, match(s:get_resources(), '\(^\|/\)Xtestwrite$')) |
Bram Moolenaar | 8211798 | 2016-08-27 19:21:48 +0200 | [diff] [blame] | 1816 | |
| 1817 | call delete('Xtestwrite') |
| 1818 | bwipe! |
| 1819 | endfunc |
| 1820 | |
Bram Moolenaar | ec68a99 | 2016-10-03 21:37:41 +0200 | [diff] [blame] | 1821 | func Test_read_nonl_line() |
Bram Moolenaar | ec68a99 | 2016-10-03 21:37:41 +0200 | [diff] [blame] | 1822 | let g:linecount = 0 |
Bram Moolenaar | dcaa613 | 2017-08-13 17:13:09 +0200 | [diff] [blame] | 1823 | let arg = 'import sys;sys.stdout.write("1\n2\n3")' |
Bram Moolenaar | 772153f | 2019-03-04 12:09:49 +0100 | [diff] [blame] | 1824 | call job_start([s:python, '-c', arg], {'callback': {-> execute('let g:linecount += 1')}}) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1825 | call WaitForAssert({-> assert_equal(3, g:linecount)}) |
Bram Moolenaar | 772153f | 2019-03-04 12:09:49 +0100 | [diff] [blame] | 1826 | unlet g:linecount |
| 1827 | endfunc |
| 1828 | |
| 1829 | func Test_read_nonl_in_close_cb() |
Bram Moolenaar | 772153f | 2019-03-04 12:09:49 +0100 | [diff] [blame] | 1830 | func s:close_cb(ch) |
| 1831 | while ch_status(a:ch) == 'buffered' |
| 1832 | let g:out .= ch_read(a:ch) |
| 1833 | endwhile |
| 1834 | endfunc |
| 1835 | |
| 1836 | let g:out = '' |
| 1837 | let arg = 'import sys;sys.stdout.write("1\n2\n3")' |
| 1838 | call job_start([s:python, '-c', arg], {'close_cb': function('s:close_cb')}) |
Bram Moolenaar | 9d8d0b5 | 2020-04-24 22:47:31 +0200 | [diff] [blame] | 1839 | call test_garbagecollect_now() |
Bram Moolenaar | 772153f | 2019-03-04 12:09:49 +0100 | [diff] [blame] | 1840 | call WaitForAssert({-> assert_equal('123', g:out)}) |
| 1841 | unlet g:out |
| 1842 | delfunc s:close_cb |
Bram Moolenaar | ec68a99 | 2016-10-03 21:37:41 +0200 | [diff] [blame] | 1843 | endfunc |
| 1844 | |
Bram Moolenaar | dc0ccae | 2016-10-09 17:28:01 +0200 | [diff] [blame] | 1845 | func Test_read_from_terminated_job() |
Bram Moolenaar | dc0ccae | 2016-10-09 17:28:01 +0200 | [diff] [blame] | 1846 | let g:linecount = 0 |
Bram Moolenaar | dcaa613 | 2017-08-13 17:13:09 +0200 | [diff] [blame] | 1847 | let arg = 'import os,sys;os.close(1);sys.stderr.write("test\n")' |
Bram Moolenaar | 772153f | 2019-03-04 12:09:49 +0100 | [diff] [blame] | 1848 | call job_start([s:python, '-c', arg], {'callback': {-> execute('let g:linecount += 1')}}) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1849 | call WaitForAssert({-> assert_equal(1, g:linecount)}) |
Bram Moolenaar | 9d8d0b5 | 2020-04-24 22:47:31 +0200 | [diff] [blame] | 1850 | call test_garbagecollect_now() |
Bram Moolenaar | 772153f | 2019-03-04 12:09:49 +0100 | [diff] [blame] | 1851 | unlet g:linecount |
Bram Moolenaar | dc0ccae | 2016-10-09 17:28:01 +0200 | [diff] [blame] | 1852 | endfunc |
| 1853 | |
Bram Moolenaar | 1df2fa4 | 2018-10-07 21:36:11 +0200 | [diff] [blame] | 1854 | func Test_job_start_windows() |
Bram Moolenaar | 4641a12 | 2019-07-29 22:10:23 +0200 | [diff] [blame] | 1855 | CheckMSWindows |
Bram Moolenaar | 1df2fa4 | 2018-10-07 21:36:11 +0200 | [diff] [blame] | 1856 | |
| 1857 | " Check that backslash in $COMSPEC is handled properly. |
| 1858 | let g:echostr = '' |
| 1859 | let cmd = $COMSPEC . ' /c echo 123' |
| 1860 | let job = job_start(cmd, {'callback': {ch,msg -> execute(":let g:echostr .= msg")}}) |
| 1861 | let info = job_info(job) |
| 1862 | call assert_equal([$COMSPEC, '/c', 'echo', '123'], info.cmd) |
| 1863 | |
| 1864 | call WaitForAssert({-> assert_equal("123", g:echostr)}) |
| 1865 | unlet g:echostr |
| 1866 | endfunc |
| 1867 | |
Bram Moolenaar | 05aafed | 2017-08-11 19:12:11 +0200 | [diff] [blame] | 1868 | func Test_env() |
Bram Moolenaar | dcaa613 | 2017-08-13 17:13:09 +0200 | [diff] [blame] | 1869 | let g:envstr = '' |
Bram Moolenaar | 05aafed | 2017-08-11 19:12:11 +0200 | [diff] [blame] | 1870 | if has('win32') |
Bram Moolenaar | 22efba4 | 2018-04-07 13:22:21 +0200 | [diff] [blame] | 1871 | let cmd = ['cmd', '/c', 'echo %FOO%'] |
Bram Moolenaar | 05aafed | 2017-08-11 19:12:11 +0200 | [diff] [blame] | 1872 | else |
Bram Moolenaar | 22efba4 | 2018-04-07 13:22:21 +0200 | [diff] [blame] | 1873 | let cmd = [&shell, &shellcmdflag, 'echo $FOO'] |
Bram Moolenaar | 05aafed | 2017-08-11 19:12:11 +0200 | [diff] [blame] | 1874 | endif |
Bram Moolenaar | 22efba4 | 2018-04-07 13:22:21 +0200 | [diff] [blame] | 1875 | call assert_fails('call job_start(cmd, {"env": 1})', 'E475:') |
| 1876 | call job_start(cmd, {'callback': {ch,msg -> execute(":let g:envstr .= msg")}, 'env': {'FOO': 'bar'}}) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1877 | call WaitForAssert({-> assert_equal("bar", g:envstr)}) |
Bram Moolenaar | dcaa613 | 2017-08-13 17:13:09 +0200 | [diff] [blame] | 1878 | unlet g:envstr |
Bram Moolenaar | 05aafed | 2017-08-11 19:12:11 +0200 | [diff] [blame] | 1879 | endfunc |
| 1880 | |
| 1881 | func Test_cwd() |
Bram Moolenaar | dcaa613 | 2017-08-13 17:13:09 +0200 | [diff] [blame] | 1882 | let g:envstr = '' |
Bram Moolenaar | 05aafed | 2017-08-11 19:12:11 +0200 | [diff] [blame] | 1883 | if has('win32') |
| 1884 | let expect = $TEMP |
Bram Moolenaar | 22efba4 | 2018-04-07 13:22:21 +0200 | [diff] [blame] | 1885 | let cmd = ['cmd', '/c', 'echo %CD%'] |
Bram Moolenaar | 05aafed | 2017-08-11 19:12:11 +0200 | [diff] [blame] | 1886 | else |
| 1887 | let expect = $HOME |
Bram Moolenaar | 22efba4 | 2018-04-07 13:22:21 +0200 | [diff] [blame] | 1888 | let cmd = ['pwd'] |
Bram Moolenaar | 05aafed | 2017-08-11 19:12:11 +0200 | [diff] [blame] | 1889 | endif |
Bram Moolenaar | 22efba4 | 2018-04-07 13:22:21 +0200 | [diff] [blame] | 1890 | let job = job_start(cmd, {'callback': {ch,msg -> execute(":let g:envstr .= msg")}, 'cwd': expect}) |
Bram Moolenaar | 2482069 | 2017-12-02 16:38:12 +0100 | [diff] [blame] | 1891 | try |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1892 | call WaitForAssert({-> assert_notequal("", g:envstr)}) |
Bram Moolenaar | 2482069 | 2017-12-02 16:38:12 +0100 | [diff] [blame] | 1893 | let expect = substitute(expect, '[/\\]$', '', '') |
| 1894 | let g:envstr = substitute(g:envstr, '[/\\]$', '', '') |
| 1895 | if $CI != '' && stridx(g:envstr, '/private/') == 0 |
| 1896 | let g:envstr = g:envstr[8:] |
| 1897 | endif |
| 1898 | call assert_equal(expect, g:envstr) |
| 1899 | finally |
| 1900 | call job_stop(job) |
| 1901 | unlet g:envstr |
| 1902 | endtry |
Bram Moolenaar | 05aafed | 2017-08-11 19:12:11 +0200 | [diff] [blame] | 1903 | endfunc |
| 1904 | |
Bram Moolenaar | 069c1e7 | 2016-07-15 21:25:08 +0200 | [diff] [blame] | 1905 | function Ch_test_close_lambda(port) |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 1906 | let handle = ch_open(s:localhost . a:port, s:chopt) |
Bram Moolenaar | 069c1e7 | 2016-07-15 21:25:08 +0200 | [diff] [blame] | 1907 | if ch_status(handle) == "fail" |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 1908 | call assert_report("Can't open channel") |
Bram Moolenaar | 069c1e7 | 2016-07-15 21:25:08 +0200 | [diff] [blame] | 1909 | return |
| 1910 | endif |
| 1911 | let g:Ch_close_ret = '' |
| 1912 | call ch_setoptions(handle, {'close_cb': {ch -> execute("let g:Ch_close_ret = 'closed'")}}) |
Bram Moolenaar | 92b83cc | 2020-04-25 15:24:44 +0200 | [diff] [blame] | 1913 | call test_garbagecollect_now() |
Bram Moolenaar | 069c1e7 | 2016-07-15 21:25:08 +0200 | [diff] [blame] | 1914 | |
| 1915 | call assert_equal('', ch_evalexpr(handle, 'close me')) |
Bram Moolenaar | 50182fa | 2018-04-28 21:34:40 +0200 | [diff] [blame] | 1916 | call WaitForAssert({-> assert_equal('closed', g:Ch_close_ret)}) |
Bram Moolenaar | 069c1e7 | 2016-07-15 21:25:08 +0200 | [diff] [blame] | 1917 | endfunc |
| 1918 | |
| 1919 | func Test_close_lambda() |
Bram Moolenaar | 069c1e7 | 2016-07-15 21:25:08 +0200 | [diff] [blame] | 1920 | call s:run_server('Ch_test_close_lambda') |
| 1921 | endfunc |
Bram Moolenaar | dcaa613 | 2017-08-13 17:13:09 +0200 | [diff] [blame] | 1922 | |
Bram Moolenaar | bfe13cc | 2020-04-12 17:53:12 +0200 | [diff] [blame] | 1923 | func Test_close_lambda_ipv6() |
| 1924 | CheckIPv6 |
| 1925 | call Test_close_lambda() |
| 1926 | endfunc |
| 1927 | |
Bram Moolenaar | dcaa613 | 2017-08-13 17:13:09 +0200 | [diff] [blame] | 1928 | func s:test_list_args(cmd, out, remove_lf) |
| 1929 | try |
| 1930 | let g:out = '' |
Bram Moolenaar | 2482069 | 2017-12-02 16:38:12 +0100 | [diff] [blame] | 1931 | let job = job_start([s:python, '-c', a:cmd], {'callback': {ch, msg -> execute('let g:out .= msg')}, 'out_mode': 'raw'}) |
Bram Moolenaar | dcaa613 | 2017-08-13 17:13:09 +0200 | [diff] [blame] | 1932 | call WaitFor('"" != g:out') |
| 1933 | if has('win32') |
| 1934 | let g:out = substitute(g:out, '\r', '', 'g') |
| 1935 | endif |
| 1936 | if a:remove_lf |
| 1937 | let g:out = substitute(g:out, '\n$', '', 'g') |
| 1938 | endif |
| 1939 | call assert_equal(a:out, g:out) |
| 1940 | finally |
Bram Moolenaar | 2482069 | 2017-12-02 16:38:12 +0100 | [diff] [blame] | 1941 | call job_stop(job) |
Bram Moolenaar | dcaa613 | 2017-08-13 17:13:09 +0200 | [diff] [blame] | 1942 | unlet g:out |
| 1943 | endtry |
| 1944 | endfunc |
| 1945 | |
| 1946 | func Test_list_args() |
Bram Moolenaar | dcaa613 | 2017-08-13 17:13:09 +0200 | [diff] [blame] | 1947 | call s:test_list_args('import sys;sys.stdout.write("hello world")', "hello world", 0) |
| 1948 | call s:test_list_args('import sys;sys.stdout.write("hello\nworld")', "hello\nworld", 0) |
| 1949 | call s:test_list_args('import sys;sys.stdout.write(''hello\nworld'')', "hello\nworld", 0) |
| 1950 | call s:test_list_args('import sys;sys.stdout.write(''hello"world'')', "hello\"world", 0) |
| 1951 | call s:test_list_args('import sys;sys.stdout.write(''hello^world'')', "hello^world", 0) |
| 1952 | call s:test_list_args('import sys;sys.stdout.write("hello&&world")', "hello&&world", 0) |
| 1953 | call s:test_list_args('import sys;sys.stdout.write(''hello\\world'')', "hello\\world", 0) |
| 1954 | call s:test_list_args('import sys;sys.stdout.write(''hello\\\\world'')', "hello\\\\world", 0) |
| 1955 | call s:test_list_args('import sys;sys.stdout.write("hello\"world\"")', 'hello"world"', 0) |
| 1956 | call s:test_list_args('import sys;sys.stdout.write("h\"ello worl\"d")', 'h"ello worl"d', 0) |
| 1957 | call s:test_list_args('import sys;sys.stdout.write("h\"e\\\"llo wor\\\"l\"d")', 'h"e\"llo wor\"l"d', 0) |
| 1958 | call s:test_list_args('import sys;sys.stdout.write("h\"e\\\"llo world")', 'h"e\"llo world', 0) |
| 1959 | call s:test_list_args('import sys;sys.stdout.write("hello\tworld")', "hello\tworld", 0) |
| 1960 | |
| 1961 | " tests which not contain spaces in the argument |
| 1962 | call s:test_list_args('print("hello\nworld")', "hello\nworld", 1) |
| 1963 | call s:test_list_args('print(''hello\nworld'')', "hello\nworld", 1) |
| 1964 | call s:test_list_args('print(''hello"world'')', "hello\"world", 1) |
| 1965 | call s:test_list_args('print(''hello^world'')', "hello^world", 1) |
| 1966 | call s:test_list_args('print("hello&&world")', "hello&&world", 1) |
| 1967 | call s:test_list_args('print(''hello\\world'')', "hello\\world", 1) |
| 1968 | call s:test_list_args('print(''hello\\\\world'')', "hello\\\\world", 1) |
| 1969 | call s:test_list_args('print("hello\"world\"")', 'hello"world"', 1) |
| 1970 | call s:test_list_args('print("hello\tworld")', "hello\tworld", 1) |
| 1971 | endfunc |
Bram Moolenaar | d5359b2 | 2018-04-05 22:44:39 +0200 | [diff] [blame] | 1972 | |
Bram Moolenaar | 4e9d443 | 2018-04-24 20:54:07 +0200 | [diff] [blame] | 1973 | func Test_keep_pty_open() |
Bram Moolenaar | ec9b017 | 2020-06-19 19:10:59 +0200 | [diff] [blame] | 1974 | CheckUnix |
Bram Moolenaar | 4e9d443 | 2018-04-24 20:54:07 +0200 | [diff] [blame] | 1975 | |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 1976 | let job = job_start(s:python . ' -c "import time;time.sleep(0.2)"', |
| 1977 | \ {'out_io': 'null', 'err_io': 'null', 'pty': 1}) |
Bram Moolenaar | 4e9d443 | 2018-04-24 20:54:07 +0200 | [diff] [blame] | 1978 | let elapsed = WaitFor({-> job_status(job) ==# 'dead'}) |
| 1979 | call assert_inrange(200, 1000, elapsed) |
| 1980 | call job_stop(job) |
| 1981 | endfunc |
Bram Moolenaar | c46af53 | 2019-01-09 22:24:49 +0100 | [diff] [blame] | 1982 | |
| 1983 | func Test_job_start_in_timer() |
Bram Moolenaar | 4641a12 | 2019-07-29 22:10:23 +0200 | [diff] [blame] | 1984 | CheckFeature timers |
Bram Moolenaar | 4f32f9c | 2020-03-15 14:53:35 +0100 | [diff] [blame] | 1985 | CheckFunction reltimefloat |
Bram Moolenaar | c46af53 | 2019-01-09 22:24:49 +0100 | [diff] [blame] | 1986 | |
| 1987 | func OutCb(chan, msg) |
Bram Moolenaar | cfc1523 | 2019-01-23 22:33:18 +0100 | [diff] [blame] | 1988 | let g:val += 1 |
Bram Moolenaar | c46af53 | 2019-01-09 22:24:49 +0100 | [diff] [blame] | 1989 | endfunc |
| 1990 | |
| 1991 | func ExitCb(job, status) |
Bram Moolenaar | cfc1523 | 2019-01-23 22:33:18 +0100 | [diff] [blame] | 1992 | let g:val += 1 |
Bram Moolenaar | c46af53 | 2019-01-09 22:24:49 +0100 | [diff] [blame] | 1993 | call Resume() |
| 1994 | endfunc |
| 1995 | |
| 1996 | func TimerCb(timer) |
| 1997 | if has('win32') |
| 1998 | let cmd = ['cmd', '/c', 'echo.'] |
| 1999 | else |
| 2000 | let cmd = ['echo'] |
| 2001 | endif |
| 2002 | let g:job = job_start(cmd, {'out_cb': 'OutCb', 'exit_cb': 'ExitCb'}) |
| 2003 | call substitute(repeat('a', 100000), '.', '', 'g') |
| 2004 | endfunc |
| 2005 | |
| 2006 | " We should be interrupted before 'updatetime' elapsed. |
| 2007 | let g:val = 0 |
| 2008 | call timer_start(1, 'TimerCb') |
| 2009 | let elapsed = Standby(&ut) |
| 2010 | call assert_inrange(1, &ut / 2, elapsed) |
Bram Moolenaar | cfc1523 | 2019-01-23 22:33:18 +0100 | [diff] [blame] | 2011 | |
| 2012 | " Wait for both OutCb() and ExitCb() to have been called before deleting |
| 2013 | " them. |
| 2014 | call WaitForAssert({-> assert_equal(2, g:val)}) |
Bram Moolenaar | c46af53 | 2019-01-09 22:24:49 +0100 | [diff] [blame] | 2015 | call job_stop(g:job) |
| 2016 | |
| 2017 | delfunc OutCb |
| 2018 | delfunc ExitCb |
| 2019 | delfunc TimerCb |
| 2020 | unlet! g:val |
| 2021 | unlet! g:job |
| 2022 | endfunc |
Bram Moolenaar | 2405838 | 2019-01-24 23:11:49 +0100 | [diff] [blame] | 2023 | |
| 2024 | func Test_raw_large_data() |
| 2025 | try |
| 2026 | let g:out = '' |
| 2027 | let job = job_start(s:python . " test_channel_pipe.py", |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 2028 | \ {'mode': 'raw', 'drop': 'never', 'noblock': 1, |
| 2029 | \ 'callback': {ch, msg -> execute('let g:out .= msg')}}) |
Bram Moolenaar | 2405838 | 2019-01-24 23:11:49 +0100 | [diff] [blame] | 2030 | |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 2031 | let outlen = 79999 |
| 2032 | let want = repeat('X', outlen) . "\n" |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 2033 | eval job->ch_sendraw(want) |
Bram Moolenaar | e295609 | 2019-01-25 21:01:17 +0100 | [diff] [blame] | 2034 | call WaitFor({-> len(g:out) >= outlen}, 10000) |
| 2035 | call WaitForAssert({-> assert_equal("dead", job_status(job))}) |
Bram Moolenaar | 2405838 | 2019-01-24 23:11:49 +0100 | [diff] [blame] | 2036 | call assert_equal(want, substitute(g:out, '\r', '', 'g')) |
| 2037 | finally |
| 2038 | call job_stop(job) |
| 2039 | unlet g:out |
| 2040 | endtry |
| 2041 | endfunc |
Bram Moolenaar | b3051ce | 2019-01-31 15:52:11 +0100 | [diff] [blame] | 2042 | |
Bram Moolenaar | 6524068 | 2019-02-10 22:23:26 +0100 | [diff] [blame] | 2043 | func Test_no_hang_windows() |
Bram Moolenaar | 4641a12 | 2019-07-29 22:10:23 +0200 | [diff] [blame] | 2044 | CheckMSWindows |
Bram Moolenaar | 6524068 | 2019-02-10 22:23:26 +0100 | [diff] [blame] | 2045 | |
| 2046 | try |
| 2047 | let job = job_start(s:python . " test_channel_pipe.py busy", |
| 2048 | \ {'mode': 'raw', 'drop': 'never', 'noblock': 0}) |
| 2049 | call assert_fails('call ch_sendraw(job, repeat("X", 80000))', 'E631:') |
| 2050 | finally |
| 2051 | call job_stop(job) |
| 2052 | endtry |
| 2053 | endfunc |
| 2054 | |
Bram Moolenaar | b3051ce | 2019-01-31 15:52:11 +0100 | [diff] [blame] | 2055 | func Test_job_exitval_and_termsig() |
Bram Moolenaar | ec9b017 | 2020-06-19 19:10:59 +0200 | [diff] [blame] | 2056 | CheckUnix |
Bram Moolenaar | b3051ce | 2019-01-31 15:52:11 +0100 | [diff] [blame] | 2057 | |
| 2058 | " Terminate job normally |
| 2059 | let cmd = ['echo'] |
| 2060 | let job = job_start(cmd) |
| 2061 | call WaitForAssert({-> assert_equal("dead", job_status(job))}) |
| 2062 | let info = job_info(job) |
| 2063 | call assert_equal(0, info.exitval) |
| 2064 | call assert_equal("", info.termsig) |
| 2065 | |
| 2066 | " Terminate job by signal |
| 2067 | let cmd = ['sleep', '10'] |
| 2068 | let job = job_start(cmd) |
Bram Moolenaar | 08d2e79 | 2019-12-07 17:10:25 +0100 | [diff] [blame] | 2069 | " 10m usually works but 50m is needed when running Valgrind |
| 2070 | sleep 50m |
Bram Moolenaar | b3051ce | 2019-01-31 15:52:11 +0100 | [diff] [blame] | 2071 | call job_stop(job) |
| 2072 | call WaitForAssert({-> assert_equal("dead", job_status(job))}) |
| 2073 | let info = job_info(job) |
| 2074 | call assert_equal(-1, info.exitval) |
| 2075 | call assert_equal("term", info.termsig) |
| 2076 | endfunc |
Bram Moolenaar | 5938648 | 2019-02-10 22:43:46 +0100 | [diff] [blame] | 2077 | |
| 2078 | func Test_job_tty_in_out() |
Bram Moolenaar | 4641a12 | 2019-07-29 22:10:23 +0200 | [diff] [blame] | 2079 | CheckUnix |
Bram Moolenaar | 5938648 | 2019-02-10 22:43:46 +0100 | [diff] [blame] | 2080 | |
| 2081 | call writefile(['test'], 'Xtestin') |
| 2082 | let in_opts = [{}, |
| 2083 | \ {'in_io': 'null'}, |
| 2084 | \ {'in_io': 'file', 'in_name': 'Xtestin'}] |
| 2085 | let out_opts = [{}, |
| 2086 | \ {'out_io': 'null'}, |
| 2087 | \ {'out_io': 'file', 'out_name': 'Xtestout'}] |
| 2088 | let err_opts = [{}, |
| 2089 | \ {'err_io': 'null'}, |
| 2090 | \ {'err_io': 'file', 'err_name': 'Xtesterr'}, |
| 2091 | \ {'err_io': 'out'}] |
| 2092 | let opts = [] |
| 2093 | |
| 2094 | for in_opt in in_opts |
| 2095 | let x = copy(in_opt) |
| 2096 | for out_opt in out_opts |
Bram Moolenaar | 05c00c0 | 2019-02-11 22:00:11 +0100 | [diff] [blame] | 2097 | let x = extend(copy(x), out_opt) |
Bram Moolenaar | 5938648 | 2019-02-10 22:43:46 +0100 | [diff] [blame] | 2098 | for err_opt in err_opts |
Bram Moolenaar | 05c00c0 | 2019-02-11 22:00:11 +0100 | [diff] [blame] | 2099 | let x = extend(copy(x), err_opt) |
Bram Moolenaar | 5938648 | 2019-02-10 22:43:46 +0100 | [diff] [blame] | 2100 | let opts += [extend({'pty': 1}, x)] |
| 2101 | endfor |
| 2102 | endfor |
| 2103 | endfor |
| 2104 | |
| 2105 | for opt in opts |
| 2106 | let job = job_start('echo', opt) |
| 2107 | let info = job_info(job) |
| 2108 | let msg = printf('option={"in_io": "%s", "out_io": "%s", "err_io": "%s"}', |
| 2109 | \ get(opt, 'in_io', 'tty'), |
| 2110 | \ get(opt, 'out_io', 'tty'), |
| 2111 | \ get(opt, 'err_io', 'tty')) |
| 2112 | |
| 2113 | if !has_key(opt, 'in_io') || !has_key(opt, 'out_io') || !has_key(opt, 'err_io') |
| 2114 | call assert_notequal('', info.tty_in, msg) |
| 2115 | else |
| 2116 | call assert_equal('', info.tty_in, msg) |
| 2117 | endif |
| 2118 | call assert_equal(info.tty_in, info.tty_out, msg) |
| 2119 | |
| 2120 | call WaitForAssert({-> assert_equal('dead', job_status(job))}) |
| 2121 | endfor |
| 2122 | |
| 2123 | call delete('Xtestin') |
| 2124 | call delete('Xtestout') |
| 2125 | call delete('Xtesterr') |
| 2126 | endfunc |
Bram Moolenaar | f386f08 | 2019-07-29 23:03:03 +0200 | [diff] [blame] | 2127 | |
| 2128 | " Do this last, it stops any channel log. |
| 2129 | func Test_zz_nl_err_to_out_pipe() |
Bram Moolenaar | ec9b017 | 2020-06-19 19:10:59 +0200 | [diff] [blame] | 2130 | |
Bram Moolenaar | 570497a | 2019-08-22 22:55:13 +0200 | [diff] [blame] | 2131 | eval 'Xlog'->ch_logfile() |
Bram Moolenaar | f386f08 | 2019-07-29 23:03:03 +0200 | [diff] [blame] | 2132 | call ch_log('Test_zz_nl_err_to_out_pipe()') |
| 2133 | let job = job_start(s:python . " test_channel_pipe.py", {'err_io': 'out'}) |
| 2134 | call assert_equal("run", job_status(job)) |
| 2135 | try |
| 2136 | let handle = job_getchannel(job) |
| 2137 | call ch_sendraw(handle, "echo something\n") |
| 2138 | call assert_equal("something", ch_readraw(handle)) |
| 2139 | |
| 2140 | call ch_sendraw(handle, "echoerr wrong\n") |
| 2141 | call assert_equal("wrong", ch_readraw(handle)) |
| 2142 | finally |
| 2143 | call job_stop(job) |
| 2144 | call ch_logfile('') |
| 2145 | let loglines = readfile('Xlog') |
| 2146 | call assert_true(len(loglines) > 10) |
| 2147 | let found_test = 0 |
| 2148 | let found_send = 0 |
| 2149 | let found_recv = 0 |
| 2150 | let found_stop = 0 |
| 2151 | for l in loglines |
| 2152 | if l =~ 'Test_zz_nl_err_to_out_pipe' |
| 2153 | let found_test = 1 |
| 2154 | endif |
| 2155 | if l =~ 'SEND on.*echo something' |
| 2156 | let found_send = 1 |
| 2157 | endif |
| 2158 | if l =~ 'RECV on.*something' |
| 2159 | let found_recv = 1 |
| 2160 | endif |
| 2161 | if l =~ 'Stopping job with' |
| 2162 | let found_stop = 1 |
| 2163 | endif |
| 2164 | endfor |
| 2165 | call assert_equal(1, found_test) |
| 2166 | call assert_equal(1, found_send) |
| 2167 | call assert_equal(1, found_recv) |
| 2168 | call assert_equal(1, found_stop) |
| 2169 | " On MS-Windows need to sleep for a moment to be able to delete the file. |
| 2170 | sleep 10m |
| 2171 | call delete('Xlog') |
| 2172 | endtry |
| 2173 | endfunc |
| 2174 | |
| 2175 | " Do this last, it stops any channel log. |
| 2176 | func Test_zz_ch_log() |
| 2177 | call ch_logfile('Xlog', 'w') |
| 2178 | call ch_log('hello there') |
| 2179 | call ch_log('%s%s') |
| 2180 | call ch_logfile('') |
| 2181 | let text = readfile('Xlog') |
| 2182 | call assert_match("hello there", text[1]) |
| 2183 | call assert_match("%s%s", text[2]) |
Bram Moolenaar | ca68ae1 | 2020-03-30 19:32:53 +0200 | [diff] [blame] | 2184 | call mkdir("Xdir1") |
| 2185 | call assert_fails("call ch_logfile('Xdir1')", 'E484:') |
| 2186 | cal delete("Xdir1", 'd') |
Bram Moolenaar | f386f08 | 2019-07-29 23:03:03 +0200 | [diff] [blame] | 2187 | call delete('Xlog') |
| 2188 | endfunc |
Bram Moolenaar | 538feb5 | 2020-01-20 21:59:39 +0100 | [diff] [blame] | 2189 | |
Bram Moolenaar | b3e195c | 2020-02-10 21:32:19 +0100 | [diff] [blame] | 2190 | func Test_issue_5150() |
Bram Moolenaar | d0d440f | 2020-03-07 17:24:59 +0100 | [diff] [blame] | 2191 | if has('win32') |
| 2192 | let cmd = 'cmd /c pause' |
| 2193 | else |
| 2194 | let cmd = 'grep foo' |
| 2195 | endif |
Bram Moolenaar | 18dc355 | 2020-11-22 14:24:00 +0100 | [diff] [blame] | 2196 | |
Bram Moolenaar | d0d440f | 2020-03-07 17:24:59 +0100 | [diff] [blame] | 2197 | let g:job = job_start(cmd, {}) |
Bram Moolenaar | 18dc355 | 2020-11-22 14:24:00 +0100 | [diff] [blame] | 2198 | sleep 50m " give the job time to start |
Bram Moolenaar | b3e195c | 2020-02-10 21:32:19 +0100 | [diff] [blame] | 2199 | call job_stop(g:job) |
Bram Moolenaar | 18dc355 | 2020-11-22 14:24:00 +0100 | [diff] [blame] | 2200 | call WaitForAssert({-> assert_equal(-1, job_info(g:job).exitval)}) |
| 2201 | |
Bram Moolenaar | d0d440f | 2020-03-07 17:24:59 +0100 | [diff] [blame] | 2202 | let g:job = job_start(cmd, {}) |
Bram Moolenaar | 18dc355 | 2020-11-22 14:24:00 +0100 | [diff] [blame] | 2203 | sleep 50m |
Bram Moolenaar | b3e195c | 2020-02-10 21:32:19 +0100 | [diff] [blame] | 2204 | call job_stop(g:job, 'term') |
Bram Moolenaar | 18dc355 | 2020-11-22 14:24:00 +0100 | [diff] [blame] | 2205 | call WaitForAssert({-> assert_equal(-1, job_info(g:job).exitval)}) |
| 2206 | |
Bram Moolenaar | d0d440f | 2020-03-07 17:24:59 +0100 | [diff] [blame] | 2207 | let g:job = job_start(cmd, {}) |
Bram Moolenaar | 353c351 | 2020-03-15 14:19:26 +0100 | [diff] [blame] | 2208 | sleep 50m |
Bram Moolenaar | 18dc355 | 2020-11-22 14:24:00 +0100 | [diff] [blame] | 2209 | call job_stop(g:job, 'kill') |
| 2210 | call WaitForAssert({-> assert_equal(-1, job_info(g:job).exitval)}) |
Bram Moolenaar | b3e195c | 2020-02-10 21:32:19 +0100 | [diff] [blame] | 2211 | endfunc |
Bram Moolenaar | 355757a | 2020-02-10 22:06:32 +0100 | [diff] [blame] | 2212 | |
| 2213 | func Test_issue_5485() |
| 2214 | let $VAR1 = 'global' |
| 2215 | let g:Ch_reply = "" |
| 2216 | let l:job = job_start([&shell, &shellcmdflag, has('win32') ? 'echo %VAR1% %VAR2%' : 'echo $VAR1 $VAR2'], {'env': {'VAR1': 'local', 'VAR2': 'local'}, 'callback': 'Ch_handler'}) |
| 2217 | let g:Ch_job = l:job |
| 2218 | call WaitForAssert({-> assert_equal("local local", trim(g:Ch_reply))}) |
| 2219 | unlet $VAR1 |
| 2220 | endfunc |
Bram Moolenaar | 8b63313 | 2020-03-20 18:20:51 +0100 | [diff] [blame] | 2221 | |
Bram Moolenaar | 7851b1c | 2020-03-26 16:27:38 +0100 | [diff] [blame] | 2222 | func Test_job_trailing_space_unix() |
| 2223 | CheckUnix |
| 2224 | CheckExecutable cat |
Bram Moolenaar | ec9b017 | 2020-06-19 19:10:59 +0200 | [diff] [blame] | 2225 | |
Bram Moolenaar | 7851b1c | 2020-03-26 16:27:38 +0100 | [diff] [blame] | 2226 | let job = job_start("cat ", #{in_io: 'null'}) |
| 2227 | call WaitForAssert({-> assert_equal("dead", job_status(job))}) |
| 2228 | call assert_equal(0, job_info(job).exitval) |
| 2229 | endfunc |
| 2230 | |
Bram Moolenaar | ca68ae1 | 2020-03-30 19:32:53 +0200 | [diff] [blame] | 2231 | func Test_ch_getbufnr() |
| 2232 | let ch = test_null_channel() |
| 2233 | call assert_equal(-1, ch_getbufnr(ch, 'in')) |
| 2234 | call assert_equal(-1, ch_getbufnr(ch, 'out')) |
| 2235 | call assert_equal(-1, ch_getbufnr(ch, 'err')) |
| 2236 | call assert_equal(-1, ch_getbufnr(ch, '')) |
| 2237 | endfunc |
| 2238 | |
| 2239 | " Test for unsupported options passed to ch_status() |
| 2240 | func Test_invalid_job_chan_options() |
| 2241 | let ch = test_null_channel() |
| 2242 | let invalid_opts = [ |
| 2243 | \ {'in_io' : 'null'}, |
| 2244 | \ {'out_io' : 'null'}, |
| 2245 | \ {'err_io' : 'null'}, |
| 2246 | \ {'mode' : 'json'}, |
| 2247 | \ {'out_mode' : 'json'}, |
| 2248 | \ {'err_mode' : 'json'}, |
| 2249 | \ {'noblock' : 1}, |
| 2250 | \ {'in_name' : '/a/b'}, |
| 2251 | \ {'pty' : 1}, |
| 2252 | \ {'in_buf' : 1}, |
| 2253 | \ {'out_buf' : 1}, |
| 2254 | \ {'err_buf' : 1}, |
| 2255 | \ {'out_modifiable' : 1}, |
| 2256 | \ {'err_modifiable' : 1}, |
| 2257 | \ {'out_msg' : 1}, |
| 2258 | \ {'err_msg' : 1}, |
| 2259 | \ {'in_top' : 1}, |
| 2260 | \ {'in_bot' : 1}, |
| 2261 | \ {'channel' : ch}, |
| 2262 | \ {'callback' : ''}, |
| 2263 | \ {'out_cb' : ''}, |
| 2264 | \ {'err_cb' : ''}, |
| 2265 | \ {'close_cb' : ''}, |
| 2266 | \ {'exit_cb' : ''}, |
| 2267 | \ {'term_opencmd' : ''}, |
| 2268 | \ {'eof_chars' : ''}, |
| 2269 | \ {'term_rows' : 10}, |
| 2270 | \ {'term_cols' : 10}, |
| 2271 | \ {'vertical' : 0}, |
| 2272 | \ {'curwin' : 1}, |
| 2273 | \ {'bufnr' : 1}, |
| 2274 | \ {'hidden' : 0}, |
| 2275 | \ {'norestore' : 0}, |
| 2276 | \ {'term_kill' : 'kill'}, |
| 2277 | \ {'tty_type' : ''}, |
| 2278 | \ {'term_highlight' : ''}, |
| 2279 | \ {'env' : {}}, |
| 2280 | \ {'cwd' : ''}, |
| 2281 | \ {'timeout' : 0}, |
| 2282 | \ {'out_timeout' : 0}, |
| 2283 | \ {'err_timeout' : 0}, |
| 2284 | \ {'id' : 0}, |
| 2285 | \ {'stoponexit' : ''}, |
| 2286 | \ {'block_write' : 1} |
| 2287 | \ ] |
| 2288 | if has('gui') |
| 2289 | call add(invalid_opts, {'ansi_colors' : []}) |
| 2290 | endif |
| 2291 | |
| 2292 | for opt in invalid_opts |
| 2293 | call assert_fails("let x = ch_status(ch, opt)", 'E475:') |
| 2294 | endfor |
Bram Moolenaar | ad48e6c | 2020-04-21 22:19:45 +0200 | [diff] [blame] | 2295 | call assert_equal('fail', ch_status(ch, test_null_dict())) |
Bram Moolenaar | ca68ae1 | 2020-03-30 19:32:53 +0200 | [diff] [blame] | 2296 | endfunc |
| 2297 | |
| 2298 | " Test for passing the command and the arguments as List on MS-Windows |
| 2299 | func Test_job_with_list_args() |
| 2300 | CheckMSWindows |
| 2301 | |
| 2302 | enew! |
| 2303 | let bnum = bufnr() |
| 2304 | let job = job_start(['cmd', '/c', 'echo', 'Hello', 'World'], {'out_io' : 'buffer', 'out_buf' : bnum}) |
| 2305 | call WaitForAssert({-> assert_equal("dead", job_status(job))}) |
| 2306 | call assert_equal('Hello World', getline(1)) |
| 2307 | %bw! |
| 2308 | endfunc |
| 2309 | |
Bram Moolenaar | dfc33a6 | 2020-04-29 22:30:13 +0200 | [diff] [blame] | 2310 | func ExitCb_cb_with_input(job, status) |
| 2311 | call feedkeys(":\<C-u>echo input('', 'default')\<CR>\<CR>", 'nx') |
| 2312 | call assert_equal('default', Screenline(&lines)) |
| 2313 | let g:wait_exit_cb = 0 |
| 2314 | endfunc |
| 2315 | |
| 2316 | func Test_cb_with_input() |
| 2317 | let g:wait_exit_cb = 1 |
| 2318 | |
Bram Moolenaar | f637bce | 2020-11-23 18:14:56 +0100 | [diff] [blame] | 2319 | if has('win32') |
| 2320 | let cmd = 'cmd /c echo "Vim''s test"' |
| 2321 | else |
| 2322 | let cmd = 'echo "Vim''s test"' |
| 2323 | endif |
| 2324 | |
| 2325 | let job = job_start(cmd, {'out_cb': 'ExitCb_cb_with_input'}) |
| 2326 | call WaitFor({-> job_status(job) == "dead"}) |
Bram Moolenaar | dfc33a6 | 2020-04-29 22:30:13 +0200 | [diff] [blame] | 2327 | call WaitForAssert({-> assert_equal(0, g:wait_exit_cb)}) |
| 2328 | |
| 2329 | unlet g:wait_exit_cb |
| 2330 | endfunc |
| 2331 | |
Bram Moolenaar | 8b63313 | 2020-03-20 18:20:51 +0100 | [diff] [blame] | 2332 | " vim: shiftwidth=2 sts=2 expandtab |