| " Test for channel and job functions. |
| |
| " When +channel is supported then +job is too, so we don't check for that. |
| source check.vim |
| CheckFeature channel |
| |
| source shared.vim |
| source screendump.vim |
| source view_util.vim |
| |
| let s:python = PythonProg() |
| if s:python == '' |
| " Can't run this test without Python. |
| throw 'Skipped: Python command missing' |
| endif |
| |
| " Uncomment the next line to see what happens. Output is in |
| " src/testdir/channellog. |
| " Add ch_log() calls where you want to see what happens. |
| " call ch_logfile('channellog', 'w') |
| |
| func SetUp() |
| if g:testfunc =~ '_ipv6()$' |
| let s:localhost = '[::1]:' |
| let s:testscript = 'test_channel_6.py' |
| elseif g:testfunc =~ '_unix()$' |
| let s:localhost = 'unix:Xtestsocket' |
| let s:testscript = 'test_channel_unix.py' |
| else |
| let s:localhost = 'localhost:' |
| let s:testscript = 'test_channel.py' |
| endif |
| let s:chopt = {} |
| call ch_log(g:testfunc) |
| |
| " Most tests use job_start(), which can be flaky |
| let g:test_is_flaky = 1 |
| endfunc |
| |
| " Run "testfunc" after starting the server and stop the server afterwards. |
| func s:run_server(testfunc, ...) |
| call RunServer(s:testscript, a:testfunc, a:000) |
| endfunc |
| |
| " Returns the address of the test server. |
| func s:address(port) |
| if s:localhost =~ '^unix:' |
| return s:localhost |
| else |
| return s:localhost . a:port |
| end |
| endfunc |
| |
| " Return a list of open files. |
| " Can be used to make sure no resources leaked. |
| " Returns an empty list on systems where this is not supported. |
| func s:get_resources() |
| let pid = getpid() |
| |
| if executable('lsof') |
| return systemlist('lsof -p ' . pid . ' | awk ''$4~/^[0-9]*[rwu]$/&&$5=="REG"{print$NF}''') |
| elseif isdirectory('/proc/' . pid . '/fd/') |
| return systemlist('readlink /proc/' . pid . '/fd/* | grep -v ''^/dev/''') |
| else |
| return [] |
| endif |
| endfunc |
| |
| let g:Ch_responseMsg = '' |
| func Ch_requestHandler(handle, msg) |
| let g:Ch_responseHandle = a:handle |
| let g:Ch_responseMsg = a:msg |
| endfunc |
| |
| func Ch_communicate(port) |
| " Avoid dropping messages, since we don't use a callback here. |
| let s:chopt.drop = 'never' |
| " Also add the noblock flag to try it out. |
| let s:chopt.noblock = 1 |
| let handle = ch_open(s:address(a:port), s:chopt) |
| if ch_status(handle) == "fail" |
| call assert_report("Can't open channel") |
| return |
| endif |
| |
| " check that getjob without a job is handled correctly |
| call assert_equal('no process', string(ch_getjob(handle))) |
| |
| let dict = handle->ch_info() |
| call assert_true(dict.id != 0) |
| call assert_equal('open', dict.status) |
| if has_key(dict, 'port') |
| " Channels using Unix sockets have no 'port' entry. |
| call assert_equal(a:port, string(dict.port)) |
| end |
| call assert_equal('open', dict.sock_status) |
| call assert_equal('socket', dict.sock_io) |
| |
| " Simple string request and reply. |
| call assert_equal('got it', ch_evalexpr(handle, 'hello!')) |
| |
| " Malformed command should be ignored. |
| call assert_equal('ok', ch_evalexpr(handle, 'malformed1')) |
| call assert_equal('ok', ch_evalexpr(handle, 'malformed2')) |
| call assert_equal('ok', ch_evalexpr(handle, 'malformed3')) |
| |
| " split command should work |
| call assert_equal('ok', ch_evalexpr(handle, 'split')) |
| call WaitFor('exists("g:split")') |
| call assert_equal(123, g:split) |
| |
| " string with ][ should work |
| call assert_equal('this][that', ch_evalexpr(handle, 'echo this][that')) |
| |
| " nothing to read now |
| call assert_equal(0, ch_canread(handle)) |
| |
| " sending three messages quickly then reading should work |
| for i in range(3) |
| call ch_sendexpr(handle, 'echo hello ' . i) |
| endfor |
| call assert_equal('hello 0', ch_read(handle)[1]) |
| call assert_equal('hello 1', ch_read(handle)[1]) |
| call assert_equal('hello 2', ch_read(handle)[1]) |
| |
| " Request that triggers sending two ex commands. These will usually be |
| " handled before getting the response, but it's not guaranteed, thus wait a |
| " tiny bit for the commands to get executed. |
| call assert_equal('ok', ch_evalexpr(handle, 'make change')) |
| call WaitForAssert({-> assert_equal("added2", getline("$"))}) |
| call assert_equal('added1', getline(line('$') - 1)) |
| |
| " Request command "echoerr 'this is an error'". |
| " This will throw an exception, catch it here. |
| let caught = 'no' |
| try |
| call assert_equal('ok', ch_evalexpr(handle, 'echoerr')) |
| catch /this is an error/ |
| let caught = 'yes' |
| endtry |
| if caught != 'yes' |
| call assert_report("Expected exception from error message") |
| endif |
| |
| " Request command "foo bar", which fails silently. |
| call assert_equal('ok', ch_evalexpr(handle, 'bad command')) |
| call WaitForAssert({-> assert_match("E492:.*foo bar", v:errmsg)}) |
| |
| call assert_equal('ok', ch_evalexpr(handle, 'do normal', {'timeout': 100})) |
| call WaitForAssert({-> assert_equal('added more', getline('$'))}) |
| |
| " Send a request with a specific handler. |
| call ch_sendexpr(handle, 'hello!', {'callback': 'Ch_requestHandler'}) |
| call WaitFor('exists("g:Ch_responseHandle")') |
| if !exists('g:Ch_responseHandle') |
| call assert_report('g:Ch_responseHandle was not set') |
| else |
| call assert_equal(handle, g:Ch_responseHandle) |
| unlet g:Ch_responseHandle |
| endif |
| call assert_equal('got it', g:Ch_responseMsg) |
| |
| let g:Ch_responseMsg = '' |
| call ch_sendexpr(handle, 'hello!', {'callback': function('Ch_requestHandler')}) |
| call WaitFor('exists("g:Ch_responseHandle")') |
| if !exists('g:Ch_responseHandle') |
| call assert_report('g:Ch_responseHandle was not set') |
| else |
| call assert_equal(handle, g:Ch_responseHandle) |
| unlet g:Ch_responseHandle |
| endif |
| call assert_equal('got it', g:Ch_responseMsg) |
| |
| " Using lambda. |
| let g:Ch_responseMsg = '' |
| call ch_sendexpr(handle, 'hello!', {'callback': {a, b -> Ch_requestHandler(a, b)}}) |
| call WaitFor('exists("g:Ch_responseHandle")') |
| if !exists('g:Ch_responseHandle') |
| call assert_report('g:Ch_responseHandle was not set') |
| else |
| call assert_equal(handle, g:Ch_responseHandle) |
| unlet g:Ch_responseHandle |
| endif |
| call assert_equal('got it', g:Ch_responseMsg) |
| |
| " Collect garbage, tests that our handle isn't collected. |
| call test_garbagecollect_now() |
| |
| " check setting options (without testing the effect) |
| eval handle->ch_setoptions({'callback': 's:NotUsed'}) |
| call ch_setoptions(handle, {'timeout': 1111}) |
| call ch_setoptions(handle, {'mode': 'json'}) |
| call assert_fails("call ch_setoptions(handle, {'waittime': 111})", 'E475:') |
| call ch_setoptions(handle, {'callback': ''}) |
| call ch_setoptions(handle, {'drop': 'never'}) |
| call ch_setoptions(handle, {'drop': 'auto'}) |
| call assert_fails("call ch_setoptions(handle, {'drop': 'bad'})", 'E475:') |
| call assert_equal(0, ch_setoptions(handle, test_null_dict())) |
| call assert_equal(0, ch_setoptions(test_null_channel(), {'drop' : 'never'})) |
| |
| " Send an eval request that works. |
| call assert_equal('ok', ch_evalexpr(handle, 'eval-works')) |
| sleep 10m |
| call assert_equal([-1, 'foo123'], ch_evalexpr(handle, 'eval-result')) |
| |
| " Send an eval request with special characters. |
| call assert_equal('ok', ch_evalexpr(handle, 'eval-special')) |
| sleep 10m |
| call assert_equal([-2, "foo\x7f\x10\x01bar"], ch_evalexpr(handle, 'eval-result')) |
| |
| " Send an eval request to get a line with special characters. |
| call setline(3, "a\nb\<CR>c\x01d\x7fe") |
| call assert_equal('ok', ch_evalexpr(handle, 'eval-getline')) |
| sleep 10m |
| call assert_equal([-3, "a\nb\<CR>c\x01d\x7fe"], ch_evalexpr(handle, 'eval-result')) |
| |
| " Send an eval request that fails. |
| call assert_equal('ok', ch_evalexpr(handle, 'eval-fails')) |
| sleep 10m |
| call assert_equal([-4, 'ERROR'], ch_evalexpr(handle, 'eval-result')) |
| |
| " Send an eval request that works but can't be encoded. |
| call assert_equal('ok', ch_evalexpr(handle, 'eval-error')) |
| sleep 10m |
| call assert_equal([-5, 'ERROR'], ch_evalexpr(handle, 'eval-result')) |
| |
| " Send a bad eval request. There will be no response. |
| call assert_equal('ok', ch_evalexpr(handle, 'eval-bad')) |
| sleep 10m |
| call assert_equal([-5, 'ERROR'], ch_evalexpr(handle, 'eval-result')) |
| |
| " Send an expr request |
| call assert_equal('ok', ch_evalexpr(handle, 'an expr')) |
| call WaitForAssert({-> assert_equal('three', getline('$'))}) |
| call assert_equal('one', getline(line('$') - 2)) |
| call assert_equal('two', getline(line('$') - 1)) |
| |
| " Request a redraw, we don't check for the effect. |
| call assert_equal('ok', ch_evalexpr(handle, 'redraw')) |
| call assert_equal('ok', ch_evalexpr(handle, 'redraw!')) |
| |
| call assert_equal('ok', ch_evalexpr(handle, 'empty-request')) |
| |
| " Reading while there is nothing available. |
| call assert_equal(v:none, ch_read(handle, {'timeout': 0})) |
| if exists('*reltimefloat') |
| let start = reltime() |
| call assert_equal(v:none, ch_read(handle, {'timeout': 333})) |
| let elapsed = reltime(start) |
| call assert_inrange(0.3, 0.6, reltimefloat(reltime(start))) |
| endif |
| |
| " Send without waiting for a response, then wait for a response. |
| call ch_sendexpr(handle, 'wait a bit') |
| let resp = ch_read(handle) |
| call assert_equal(type([]), type(resp)) |
| call assert_equal(type(11), type(resp[0])) |
| call assert_equal('waited', resp[1]) |
| |
| " make the server quit, can't check if this works, should not hang. |
| call ch_sendexpr(handle, '!quit!') |
| endfunc |
| |
| func Test_communicate() |
| call s:run_server('Ch_communicate') |
| endfunc |
| |
| func Test_communicate_ipv6() |
| CheckIPv6 |
| call Test_communicate() |
| endfunc |
| |
| func Test_communicate_unix() |
| CheckUnix |
| call Test_communicate() |
| call delete('Xtestsocket') |
| endfunc |
| |
| |
| " Test that we can open two channels. |
| func Ch_two_channels(port) |
| let handle = ch_open(s:address(a:port), s:chopt) |
| call assert_equal(v:t_channel, type(handle)) |
| if handle->ch_status() == "fail" |
| call assert_report("Can't open channel") |
| return |
| endif |
| |
| call assert_equal('got it', ch_evalexpr(handle, 'hello!')) |
| |
| let newhandle = ch_open(s:address(a:port), s:chopt) |
| if ch_status(newhandle) == "fail" |
| call assert_report("Can't open second channel") |
| return |
| endif |
| call assert_equal('got it', ch_evalexpr(newhandle, 'hello!')) |
| call assert_equal('got it', ch_evalexpr(handle, 'hello!')) |
| |
| call ch_close(handle) |
| call assert_equal('got it', ch_evalexpr(newhandle, 'hello!')) |
| |
| call ch_close(newhandle) |
| call assert_fails("call ch_close(newhandle)", 'E906:') |
| endfunc |
| |
| func Test_two_channels() |
| eval 'Test_two_channels()'->ch_log() |
| call s:run_server('Ch_two_channels') |
| endfunc |
| |
| func Test_two_channels_ipv6() |
| CheckIPv6 |
| call Test_two_channels() |
| endfunc |
| |
| func Test_two_channels_unix() |
| CheckUnix |
| call Test_two_channels() |
| call delete('Xtestsocket') |
| endfunc |
| |
| " Test that a server crash is handled gracefully. |
| func Ch_server_crash(port) |
| let handle = ch_open(s:address(a:port), s:chopt) |
| if ch_status(handle) == "fail" |
| call assert_report("Can't open channel") |
| return |
| endif |
| |
| call ch_evalexpr(handle, '!crash!') |
| |
| sleep 10m |
| endfunc |
| |
| func Test_server_crash() |
| call s:run_server('Ch_server_crash') |
| endfunc |
| |
| func Test_server_crash_ipv6() |
| CheckIPv6 |
| call Test_server_crash() |
| endfunc |
| |
| func Test_server_crash_unix() |
| CheckUnix |
| call Test_server_crash() |
| call delete('Xtestsocket') |
| endfunc |
| |
| """"""""" |
| |
| func Ch_handler(chan, msg) |
| call ch_log('Ch_handler()') |
| unlet g:Ch_reply |
| let g:Ch_reply = a:msg |
| endfunc |
| |
| func Ch_channel_handler(port) |
| let handle = ch_open(s:address(a:port), s:chopt) |
| if ch_status(handle) == "fail" |
| call assert_report("Can't open channel") |
| return |
| endif |
| |
| " Test that it works while waiting on a numbered message. |
| call assert_equal('ok', ch_evalexpr(handle, 'call me')) |
| call WaitForAssert({-> assert_equal('we called you', g:Ch_reply)}) |
| |
| " Test that it works while not waiting on a numbered message. |
| call ch_sendexpr(handle, 'call me again') |
| call WaitForAssert({-> assert_equal('we did call you', g:Ch_reply)}) |
| endfunc |
| |
| func Test_channel_handler() |
| let g:Ch_reply = "" |
| let s:chopt.callback = 'Ch_handler' |
| call s:run_server('Ch_channel_handler') |
| let g:Ch_reply = "" |
| let s:chopt.callback = function('Ch_handler') |
| call s:run_server('Ch_channel_handler') |
| endfunc |
| |
| func Test_channel_handler_ipv6() |
| CheckIPv6 |
| call Test_channel_handler() |
| endfunc |
| |
| func Test_channel_handler_unix() |
| CheckUnix |
| call Test_channel_handler() |
| call delete('Xtestsocket') |
| endfunc |
| |
| """"""""" |
| |
| let g:Ch_reply = '' |
| func Ch_zeroHandler(chan, msg) |
| unlet g:Ch_reply |
| let g:Ch_reply = a:msg |
| endfunc |
| |
| let g:Ch_zero_reply = '' |
| func Ch_oneHandler(chan, msg) |
| unlet g:Ch_zero_reply |
| let g:Ch_zero_reply = a:msg |
| endfunc |
| |
| func Ch_channel_zero(port) |
| let handle = (s:address(a:port))->ch_open(s:chopt) |
| if ch_status(handle) == "fail" |
| call assert_report("Can't open channel") |
| return |
| endif |
| |
| " Check that eval works. |
| call assert_equal('got it', ch_evalexpr(handle, 'hello!')) |
| |
| " Check that eval works if a zero id message is sent back. |
| let g:Ch_reply = '' |
| call assert_equal('sent zero', ch_evalexpr(handle, 'send zero')) |
| if s:has_handler |
| call WaitForAssert({-> assert_equal('zero index', g:Ch_reply)}) |
| else |
| sleep 20m |
| call assert_equal('', g:Ch_reply) |
| endif |
| |
| " Check that handler works if a zero id message is sent back. |
| let g:Ch_reply = '' |
| let g:Ch_zero_reply = '' |
| call ch_sendexpr(handle, 'send zero', {'callback': 'Ch_oneHandler'}) |
| call WaitForAssert({-> assert_equal('sent zero', g:Ch_zero_reply)}) |
| if s:has_handler |
| call assert_equal('zero index', g:Ch_reply) |
| else |
| call assert_equal('', g:Ch_reply) |
| endif |
| endfunc |
| |
| func Test_zero_reply() |
| " Run with channel handler |
| let s:has_handler = 1 |
| let s:chopt.callback = 'Ch_zeroHandler' |
| call s:run_server('Ch_channel_zero') |
| unlet s:chopt.callback |
| |
| " Run without channel handler |
| let s:has_handler = 0 |
| call s:run_server('Ch_channel_zero') |
| endfunc |
| |
| func Test_zero_reply_ipv6() |
| CheckIPv6 |
| call Test_zero_reply() |
| endfunc |
| |
| func Test_zero_reply_unix() |
| CheckUnix |
| call Test_zero_reply() |
| call delete('Xtestsocket') |
| endfunc |
| |
| |
| """"""""" |
| |
| let g:Ch_reply1 = "" |
| func Ch_handleRaw1(chan, msg) |
| unlet g:Ch_reply1 |
| let g:Ch_reply1 = a:msg |
| endfunc |
| |
| let g:Ch_reply2 = "" |
| func Ch_handleRaw2(chan, msg) |
| unlet g:Ch_reply2 |
| let g:Ch_reply2 = a:msg |
| endfunc |
| |
| let g:Ch_reply3 = "" |
| func Ch_handleRaw3(chan, msg) |
| unlet g:Ch_reply3 |
| let g:Ch_reply3 = a:msg |
| endfunc |
| |
| func Ch_raw_one_time_callback(port) |
| let handle = ch_open(s:address(a:port), s:chopt) |
| if ch_status(handle) == "fail" |
| call assert_report("Can't open channel") |
| return |
| endif |
| call ch_setoptions(handle, {'mode': 'raw'}) |
| |
| " The messages are sent raw, we do our own JSON strings here. |
| call ch_sendraw(handle, "[1, \"hello!\"]\n", {'callback': 'Ch_handleRaw1'}) |
| call WaitForAssert({-> assert_equal("[1, \"got it\"]", g:Ch_reply1)}) |
| call ch_sendraw(handle, "[2, \"echo something\"]\n", {'callback': 'Ch_handleRaw2'}) |
| call ch_sendraw(handle, "[3, \"wait a bit\"]\n", {'callback': 'Ch_handleRaw3'}) |
| call WaitForAssert({-> assert_equal("[2, \"something\"]", g:Ch_reply2)}) |
| " wait for the 200 msec delayed reply |
| call WaitForAssert({-> assert_equal("[3, \"waited\"]", g:Ch_reply3)}) |
| endfunc |
| |
| func Test_raw_one_time_callback() |
| call s:run_server('Ch_raw_one_time_callback') |
| endfunc |
| |
| func Test_raw_one_time_callback_ipv6() |
| CheckIPv6 |
| call Test_raw_one_time_callback() |
| endfunc |
| |
| func Test_raw_one_time_callback_unix() |
| CheckUnix |
| call Test_raw_one_time_callback() |
| call delete('Xtestsocket') |
| endfunc |
| |
| """"""""" |
| |
| " Test that trying to connect to a non-existing port fails quickly. |
| func Test_connect_waittime() |
| CheckFunction reltimefloat |
| " this is timing sensitive |
| |
| let start = reltime() |
| let handle = ch_open('localhost:9876', s:chopt) |
| if ch_status(handle) != "fail" |
| " Oops, port does exists. |
| call ch_close(handle) |
| else |
| let elapsed = reltime(start) |
| call assert_inrange(0.0, 1.0, reltimefloat(elapsed)) |
| endif |
| |
| " We intend to use a socket that doesn't exist and wait for half a second |
| " before giving up. If the socket does exist it can fail in various ways. |
| " Check for "Connection reset by peer" to avoid flakiness. |
| let start = reltime() |
| try |
| let handle = ch_open('localhost:9867', {'waittime': 500}) |
| if ch_status(handle) != "fail" |
| " Oops, port does exists. |
| call ch_close(handle) |
| else |
| " Failed connection should wait about 500 msec. Can be longer if the |
| " computer is busy with other things. |
| call assert_inrange(0.3, 1.5, reltimefloat(reltime(start))) |
| endif |
| catch |
| if v:exception !~ 'Connection reset by peer' |
| call assert_report("Caught exception: " . v:exception) |
| endif |
| endtry |
| endfunc |
| |
| """"""""" |
| |
| func Test_raw_pipe() |
| " Add a dummy close callback to avoid that messages are dropped when calling |
| " ch_canread(). |
| " Also test the non-blocking option. |
| let job = job_start(s:python . " test_channel_pipe.py", |
| \ {'mode': 'raw', 'drop': 'never', 'noblock': 1}) |
| call assert_equal(v:t_job, type(job)) |
| call assert_equal("run", job_status(job)) |
| |
| call assert_equal("open", ch_status(job)) |
| call assert_equal("open", ch_status(job), {"part": "out"}) |
| call assert_equal("open", ch_status(job), {"part": "err"}) |
| call assert_fails('call ch_status(job, {"in_mode": "raw"})', 'E475:') |
| call assert_fails('call ch_status(job, {"part": "in"})', 'E475:') |
| |
| let dict = ch_info(job) |
| call assert_true(dict.id != 0) |
| call assert_equal('open', dict.status) |
| call assert_equal('open', dict.out_status) |
| call assert_equal('RAW', dict.out_mode) |
| call assert_equal('pipe', dict.out_io) |
| call assert_equal('open', dict.err_status) |
| call assert_equal('RAW', dict.err_mode) |
| call assert_equal('pipe', dict.err_io) |
| |
| try |
| " For a change use the job where a channel is expected. |
| call ch_sendraw(job, "echo something\n") |
| let msg = ch_readraw(job) |
| call assert_equal("something\n", substitute(msg, "\r", "", 'g')) |
| |
| call ch_sendraw(job, "double this\n") |
| let g:handle = job->job_getchannel() |
| call WaitFor('g:handle->ch_canread()') |
| unlet g:handle |
| let msg = ch_readraw(job) |
| call assert_equal("this\nAND this\n", substitute(msg, "\r", "", 'g')) |
| |
| let g:Ch_reply = "" |
| call ch_sendraw(job, "double this\n", {'callback': 'Ch_handler'}) |
| call WaitForAssert({-> assert_equal("this\nAND this\n", substitute(g:Ch_reply, "\r", "", 'g'))}) |
| |
| call assert_fails("let i = ch_evalraw(job, '2 + 2', {'callback' : 'abc'})", 'E917:') |
| call assert_fails("let i = ch_evalexpr(job, '2 + 2')", 'E912:') |
| call assert_fails("let i = ch_evalraw(job, '2 + 2', {'drop' : ''})", 'E475:') |
| call assert_fails("let i = ch_evalraw(test_null_job(), '2 + 2')", 'E906:') |
| |
| let reply = job->ch_evalraw("quit\n", {'timeout': 100}) |
| call assert_equal("Goodbye!\n", substitute(reply, "\r", "", 'g')) |
| finally |
| call job_stop(job) |
| endtry |
| |
| let g:Ch_job = job |
| call WaitForAssert({-> assert_equal("dead", job_status(g:Ch_job))}) |
| let info = job->job_info() |
| call assert_equal("dead", info.status) |
| call assert_equal("term", info.stoponexit) |
| call assert_equal(2, len(info.cmd)) |
| call assert_equal("test_channel_pipe.py", info.cmd[1]) |
| |
| let found = 0 |
| for j in job_info() |
| if j == job |
| let found += 1 |
| endif |
| endfor |
| call assert_equal(1, found) |
| |
| call assert_fails("call job_stop('abc')", 'E475:') |
| call assert_fails("call job_stop(job, [])", 'E730:') |
| call assert_fails("call job_stop(test_null_job())", 'E916:') |
| |
| " Try to use the job and channel where a number is expected. This is not |
| " related to testing the raw pipe. This test is here just to reuse the |
| " already created job/channel. |
| let ch = job_getchannel(job) |
| call assert_fails('let i = job + 1', 'E910:') |
| call assert_fails('let j = ch + 1', 'E913:') |
| call assert_fails('echo 2.0 == job', 'E911:') |
| call assert_fails('echo 2.0 == ch', 'E914:') |
| endfunc |
| |
| func Test_raw_pipe_blob() |
| " Add a dummy close callback to avoid that messages are dropped when calling |
| " ch_canread(). |
| " Also test the non-blocking option. |
| let job = job_start(s:python . " test_channel_pipe.py", |
| \ {'mode': 'raw', 'drop': 'never', 'noblock': 1}) |
| call assert_equal(v:t_job, type(job)) |
| call assert_equal("run", job_status(job)) |
| |
| call assert_equal("open", ch_status(job)) |
| call assert_equal("open", ch_status(job), {"part": "out"}) |
| |
| try |
| " Create a blob with the echo command and write it. |
| let blob = 0z00 |
| let cmd = "echo something\n" |
| for i in range(0, len(cmd) - 1) |
| let blob[i] = char2nr(cmd[i]) |
| endfor |
| call assert_equal(len(cmd), len(blob)) |
| call ch_sendraw(job, blob) |
| |
| " Read a blob with the reply. |
| let msg = job->ch_readblob() |
| let expected = 'something' |
| for i in range(0, len(expected) - 1) |
| call assert_equal(char2nr(expected[i]), msg[i]) |
| endfor |
| |
| let reply = ch_evalraw(job, "quit\n", {'timeout': 100}) |
| call assert_equal("Goodbye!\n", substitute(reply, "\r", "", 'g')) |
| finally |
| call job_stop(job) |
| endtry |
| |
| let g:Ch_job = job |
| call WaitForAssert({-> assert_equal("dead", job_status(g:Ch_job))}) |
| let info = job_info(job) |
| call assert_equal("dead", info.status) |
| endfunc |
| |
| func Test_nl_pipe() |
| let job = job_start([s:python, "test_channel_pipe.py"]) |
| call assert_equal("run", job_status(job)) |
| try |
| let handle = job_getchannel(job) |
| call ch_sendraw(handle, "echo something\n") |
| call assert_equal("something", handle->ch_readraw()) |
| |
| call ch_sendraw(handle, "echoerr wrong\n") |
| call assert_equal("wrong", ch_readraw(handle, {'part': 'err'})) |
| |
| call ch_sendraw(handle, "double this\n") |
| call assert_equal("this", ch_readraw(handle)) |
| call assert_equal("AND this", ch_readraw(handle)) |
| |
| call ch_sendraw(handle, "split this line\n") |
| call assert_equal("this linethis linethis line", handle->ch_read()) |
| |
| let reply = ch_evalraw(handle, "quit\n") |
| call assert_equal("Goodbye!", reply) |
| finally |
| call job_stop(job) |
| endtry |
| endfunc |
| |
| func Stop_g_job() |
| call job_stop(g:job) |
| if has('win32') |
| " On MS-Windows the server must close the file handle before we are able |
| " to delete the file. |
| call WaitForAssert({-> assert_equal('dead', job_status(g:job))}) |
| sleep 10m |
| endif |
| endfunc |
| |
| func Test_nl_read_file() |
| call writefile(['echo something', 'echoerr wrong', 'double this'], 'Xinput', 'D') |
| let g:job = job_start(s:python . " test_channel_pipe.py", |
| \ {'in_io': 'file', 'in_name': 'Xinput'}) |
| call assert_equal("run", job_status(g:job)) |
| try |
| let handle = job_getchannel(g:job) |
| call assert_equal("something", ch_readraw(handle)) |
| call assert_equal("wrong", ch_readraw(handle, {'part': 'err'})) |
| call assert_equal("this", ch_readraw(handle)) |
| call assert_equal("AND this", ch_readraw(handle)) |
| finally |
| call Stop_g_job() |
| endtry |
| call assert_fails("echo ch_read(test_null_channel(), {'callback' : 'abc'})", 'E475:') |
| endfunc |
| |
| func Test_nl_write_out_file() |
| let g:job = job_start(s:python . " test_channel_pipe.py", |
| \ {'out_io': 'file', 'out_name': 'Xoutput'}) |
| call assert_equal("run", job_status(g:job)) |
| try |
| let handle = job_getchannel(g:job) |
| call ch_sendraw(handle, "echo line one\n") |
| call ch_sendraw(handle, "echo line two\n") |
| call ch_sendraw(handle, "double this\n") |
| call WaitForAssert({-> assert_equal(['line one', 'line two', 'this', 'AND this'], readfile('Xoutput'))}) |
| finally |
| call Stop_g_job() |
| call assert_equal(-1, match(s:get_resources(), '\(^\|/\)Xoutput$')) |
| call delete('Xoutput') |
| endtry |
| endfunc |
| |
| func Test_nl_write_err_file() |
| let g:job = job_start(s:python . " test_channel_pipe.py", |
| \ {'err_io': 'file', 'err_name': 'Xoutput'}) |
| call assert_equal("run", job_status(g:job)) |
| try |
| let handle = job_getchannel(g:job) |
| call ch_sendraw(handle, "echoerr line one\n") |
| call ch_sendraw(handle, "echoerr line two\n") |
| call ch_sendraw(handle, "doubleerr this\n") |
| call WaitForAssert({-> assert_equal(['line one', 'line two', 'this', 'AND this'], readfile('Xoutput'))}) |
| finally |
| call Stop_g_job() |
| call delete('Xoutput') |
| endtry |
| endfunc |
| |
| func Test_nl_write_both_file() |
| let g:job = job_start(s:python . " test_channel_pipe.py", |
| \ {'out_io': 'file', 'out_name': 'Xoutput', 'err_io': 'out'}) |
| call assert_equal("run", job_status(g:job)) |
| try |
| let handle = job_getchannel(g:job) |
| call ch_sendraw(handle, "echoerr line one\n") |
| call ch_sendraw(handle, "echo line two\n") |
| call ch_sendraw(handle, "double this\n") |
| call ch_sendraw(handle, "doubleerr that\n") |
| call WaitForAssert({-> assert_equal(['line one', 'line two', 'this', 'AND this', 'that', 'AND that'], readfile('Xoutput'))}) |
| finally |
| call Stop_g_job() |
| call assert_equal(-1, match(s:get_resources(), '\(^\|/\)Xoutput$')) |
| call delete('Xoutput') |
| endtry |
| endfunc |
| |
| func BufCloseCb(ch) |
| let g:Ch_bufClosed = 'yes' |
| endfunc |
| |
| func Run_test_pipe_to_buffer(use_name, nomod, do_msg) |
| let g:Ch_bufClosed = 'no' |
| let options = {'out_io': 'buffer', 'close_cb': 'BufCloseCb'} |
| let expected = ['', 'line one', 'line two', 'this', 'AND this', 'Goodbye!'] |
| if a:use_name |
| let options['out_name'] = 'pipe-output' |
| if a:do_msg |
| let expected[0] = 'Reading from channel output...' |
| else |
| let options['out_msg'] = 0 |
| call remove(expected, 0) |
| endif |
| else |
| sp pipe-output |
| let options['out_buf'] = bufnr('%') |
| quit |
| call remove(expected, 0) |
| endif |
| if a:nomod |
| let options['out_modifiable'] = 0 |
| endif |
| let job = job_start(s:python . " test_channel_pipe.py", options) |
| call assert_equal("run", job_status(job)) |
| try |
| let handle = job_getchannel(job) |
| call ch_sendraw(handle, "echo line one\n") |
| call ch_sendraw(handle, "echo line two\n") |
| call ch_sendraw(handle, "double this\n") |
| call ch_sendraw(handle, "quit\n") |
| sp pipe-output |
| call WaitFor('line("$") == ' . len(expected) . ' && g:Ch_bufClosed == "yes"') |
| call assert_equal(expected, getline(1, '$')) |
| if a:nomod |
| call assert_equal(0, &modifiable) |
| else |
| call assert_equal(1, &modifiable) |
| endif |
| call assert_equal('yes', g:Ch_bufClosed) |
| bwipe! |
| finally |
| call job_stop(job) |
| endtry |
| endfunc |
| |
| func Test_pipe_to_buffer_name() |
| call Run_test_pipe_to_buffer(1, 0, 1) |
| endfunc |
| |
| func Test_pipe_to_buffer_nr() |
| call Run_test_pipe_to_buffer(0, 0, 1) |
| endfunc |
| |
| func Test_pipe_to_buffer_name_nomod() |
| call Run_test_pipe_to_buffer(1, 1, 1) |
| endfunc |
| |
| func Test_pipe_to_buffer_name_nomsg() |
| call Run_test_pipe_to_buffer(1, 0, 1) |
| endfunc |
| |
| func Test_close_output_buffer() |
| let g:test_is_flaky = 1 |
| enew! |
| let test_lines = ['one', 'two'] |
| call setline(1, test_lines) |
| let options = {'out_io': 'buffer'} |
| let options['out_name'] = 'buffer-output' |
| let options['out_msg'] = 0 |
| split buffer-output |
| let job = job_start(s:python . " test_channel_write.py", options) |
| call assert_equal("run", job_status(job)) |
| try |
| call WaitForAssert({-> assert_equal(3, line('$'))}) |
| quit! |
| sleep 100m |
| " Make sure the write didn't happen to the wrong buffer. |
| call assert_equal(test_lines, getline(1, line('$'))) |
| call assert_equal(-1, bufwinnr('buffer-output')) |
| sbuf buffer-output |
| call assert_notequal(-1, bufwinnr('buffer-output')) |
| sleep 100m |
| close " no more writes |
| bwipe! |
| finally |
| call job_stop(job) |
| endtry |
| endfunc |
| |
| func Run_test_pipe_err_to_buffer(use_name, nomod, do_msg) |
| let options = {'err_io': 'buffer'} |
| let expected = ['', 'line one', 'line two', 'this', 'AND this'] |
| if a:use_name |
| let options['err_name'] = 'pipe-err' |
| if a:do_msg |
| let expected[0] = 'Reading from channel error...' |
| else |
| let options['err_msg'] = 0 |
| call remove(expected, 0) |
| endif |
| else |
| sp pipe-err |
| let options['err_buf'] = bufnr('%') |
| quit |
| call remove(expected, 0) |
| endif |
| if a:nomod |
| let options['err_modifiable'] = 0 |
| endif |
| let job = job_start(s:python . " test_channel_pipe.py", options) |
| call assert_equal("run", job_status(job)) |
| try |
| let handle = job_getchannel(job) |
| call ch_sendraw(handle, "echoerr line one\n") |
| call ch_sendraw(handle, "echoerr line two\n") |
| call ch_sendraw(handle, "doubleerr this\n") |
| call ch_sendraw(handle, "quit\n") |
| sp pipe-err |
| call WaitForAssert({-> assert_equal(expected, getline(1, '$'))}) |
| if a:nomod |
| call assert_equal(0, &modifiable) |
| else |
| call assert_equal(1, &modifiable) |
| endif |
| bwipe! |
| finally |
| call job_stop(job) |
| endtry |
| endfunc |
| |
| func Test_pipe_err_to_buffer_name() |
| call Run_test_pipe_err_to_buffer(1, 0, 1) |
| endfunc |
| |
| func Test_pipe_err_to_buffer_nr() |
| call Run_test_pipe_err_to_buffer(0, 0, 1) |
| endfunc |
| |
| func Test_pipe_err_to_buffer_name_nomod() |
| call Run_test_pipe_err_to_buffer(1, 1, 1) |
| endfunc |
| |
| func Test_pipe_err_to_buffer_name_nomsg() |
| call Run_test_pipe_err_to_buffer(1, 0, 0) |
| endfunc |
| |
| func Test_pipe_both_to_buffer() |
| let job = job_start(s:python . " test_channel_pipe.py", |
| \ {'out_io': 'buffer', 'out_name': 'pipe-err', 'err_io': 'out'}) |
| call assert_equal("run", job_status(job)) |
| let handle = job_getchannel(job) |
| call assert_equal(bufnr('pipe-err'), ch_getbufnr(handle, 'out')) |
| call assert_equal(bufnr('pipe-err'), ch_getbufnr(handle, 'err')) |
| try |
| call ch_sendraw(handle, "echo line one\n") |
| call ch_sendraw(handle, "echoerr line two\n") |
| call ch_sendraw(handle, "double this\n") |
| call ch_sendraw(handle, "doubleerr that\n") |
| call ch_sendraw(handle, "quit\n") |
| sp pipe-err |
| call WaitForAssert({-> assert_equal(['Reading from channel output...', 'line one', 'line two', 'this', 'AND this', 'that', 'AND that', 'Goodbye!'], getline(1, '$'))}) |
| bwipe! |
| finally |
| call job_stop(job) |
| endtry |
| endfunc |
| |
| func Run_test_pipe_from_buffer(use_name) |
| sp pipe-input |
| call setline(1, ['echo one', 'echo two', 'echo three']) |
| let options = {'in_io': 'buffer', 'block_write': 1} |
| if a:use_name |
| let options['in_name'] = 'pipe-input' |
| else |
| let options['in_buf'] = bufnr('%') |
| endif |
| |
| let job = job_start(s:python . " test_channel_pipe.py", options) |
| call assert_equal("run", job_status(job)) |
| if has('unix') && !a:use_name |
| call assert_equal(bufnr('%'), ch_getbufnr(job, 'in')) |
| endif |
| try |
| let handle = job_getchannel(job) |
| call assert_equal('one', ch_read(handle)) |
| call assert_equal('two', ch_read(handle)) |
| call assert_equal('three', ch_read(handle)) |
| bwipe! |
| finally |
| call job_stop(job) |
| endtry |
| endfunc |
| |
| func Test_pipe_from_buffer_name() |
| call Run_test_pipe_from_buffer(1) |
| endfunc |
| |
| func Test_pipe_from_buffer_nr() |
| call Run_test_pipe_from_buffer(0) |
| endfunc |
| |
| func Run_pipe_through_sort(all, use_buffer) |
| CheckExecutable sort |
| let g:test_is_flaky = 1 |
| |
| let options = {'out_io': 'buffer', 'out_name': 'sortout'} |
| if a:use_buffer |
| split sortin |
| call setline(1, ['ccc', 'aaa', 'ddd', 'bbb', 'eee']) |
| let options.in_io = 'buffer' |
| let options.in_name = 'sortin' |
| endif |
| if !a:all |
| let options.in_top = 2 |
| let options.in_bot = 4 |
| endif |
| let job = job_start('sort', options) |
| |
| if !a:use_buffer |
| call assert_equal("run", job_status(job)) |
| call ch_sendraw(job, "ccc\naaa\nddd\nbbb\neee\n") |
| eval job->ch_close_in() |
| endif |
| |
| call WaitForAssert({-> assert_equal("dead", job_status(job))}) |
| |
| sp sortout |
| call WaitFor('line("$") > 3') |
| call assert_equal('Reading from channel output...', getline(1)) |
| if a:all |
| call assert_equal(['aaa', 'bbb', 'ccc', 'ddd', 'eee'], getline(2, 6)) |
| else |
| call assert_equal(['aaa', 'bbb', 'ddd'], getline(2, 4)) |
| endif |
| |
| call job_stop(job) |
| if a:use_buffer |
| bwipe! sortin |
| endif |
| bwipe! sortout |
| endfunc |
| |
| func Test_pipe_through_sort_all() |
| call Run_pipe_through_sort(1, 1) |
| endfunc |
| |
| func Test_pipe_through_sort_some() |
| call Run_pipe_through_sort(0, 1) |
| endfunc |
| |
| func Test_pipe_through_sort_feed() |
| call Run_pipe_through_sort(1, 0) |
| endfunc |
| |
| func Test_pipe_to_nameless_buffer() |
| let job = job_start(s:python . " test_channel_pipe.py", |
| \ {'out_io': 'buffer'}) |
| call assert_equal("run", job_status(job)) |
| try |
| let handle = job_getchannel(job) |
| call ch_sendraw(handle, "echo line one\n") |
| call ch_sendraw(handle, "echo line two\n") |
| exe handle->ch_getbufnr("out") .. 'sbuf' |
| call WaitFor('line("$") >= 3') |
| call assert_equal(['Reading from channel output...', 'line one', 'line two'], getline(1, '$')) |
| bwipe! |
| finally |
| call job_stop(job) |
| endtry |
| endfunc |
| |
| func Test_pipe_to_buffer_json() |
| CheckFunction reltimefloat |
| |
| let job = job_start(s:python . " test_channel_pipe.py", |
| \ {'out_io': 'buffer', 'out_mode': 'json'}) |
| call assert_equal("run", job_status(job)) |
| try |
| let handle = job_getchannel(job) |
| call ch_sendraw(handle, "echo [0, \"hello\"]\n") |
| call ch_sendraw(handle, "echo [-2, 12.34]\n") |
| exe ch_getbufnr(handle, "out") . 'sbuf' |
| call WaitFor('line("$") >= 3') |
| call assert_equal(['Reading from channel output...', '[0,"hello"]', '[-2,12.34]'], getline(1, '$')) |
| bwipe! |
| finally |
| call job_stop(job) |
| endtry |
| endfunc |
| |
| " Wait a little while for the last line, minus "offset", to equal "line". |
| func s:wait_for_last_line(line, offset) |
| for i in range(100) |
| if getline(line('$') - a:offset) == a:line |
| break |
| endif |
| sleep 10m |
| endfor |
| endfunc |
| |
| func Test_pipe_io_two_buffers() |
| " Create two buffers, one to read from and one to write to. |
| split pipe-output |
| set buftype=nofile |
| split pipe-input |
| set buftype=nofile |
| |
| let job = job_start(s:python . " test_channel_pipe.py", |
| \ {'in_io': 'buffer', 'in_name': 'pipe-input', 'in_top': 0, |
| \ 'out_io': 'buffer', 'out_name': 'pipe-output', |
| \ 'block_write': 1}) |
| call assert_equal("run", job_status(job)) |
| try |
| exe "normal Gaecho hello\<CR>" |
| exe bufwinnr('pipe-output') . "wincmd w" |
| call s:wait_for_last_line('hello', 0) |
| call assert_equal('hello', getline('$')) |
| |
| exe bufwinnr('pipe-input') . "wincmd w" |
| exe "normal Gadouble this\<CR>" |
| exe bufwinnr('pipe-output') . "wincmd w" |
| call s:wait_for_last_line('AND this', 0) |
| call assert_equal('this', getline(line('$') - 1)) |
| call assert_equal('AND this', getline('$')) |
| |
| bwipe! |
| exe bufwinnr('pipe-input') . "wincmd w" |
| bwipe! |
| finally |
| call job_stop(job) |
| endtry |
| endfunc |
| |
| func Test_pipe_io_one_buffer() |
| " Create one buffer to read from and to write to. |
| split pipe-io |
| set buftype=nofile |
| |
| let job = job_start(s:python . " test_channel_pipe.py", |
| \ {'in_io': 'buffer', 'in_name': 'pipe-io', 'in_top': 0, |
| \ 'out_io': 'buffer', 'out_name': 'pipe-io', |
| \ 'block_write': 1}) |
| call assert_equal("run", job_status(job)) |
| try |
| exe "normal Goecho hello\<CR>" |
| call s:wait_for_last_line('hello', 1) |
| call assert_equal('hello', getline(line('$') - 1)) |
| |
| exe "normal Gadouble this\<CR>" |
| call s:wait_for_last_line('AND this', 1) |
| call assert_equal('this', getline(line('$') - 2)) |
| call assert_equal('AND this', getline(line('$') - 1)) |
| |
| bwipe! |
| finally |
| call job_stop(job) |
| endtry |
| endfunc |
| |
| func Test_write_to_buffer_and_scroll() |
| CheckScreendump |
| |
| let lines =<< trim END |
| new Xscrollbuffer |
| call setline(1, range(1, 200)) |
| $ |
| redraw |
| wincmd w |
| call deletebufline('Xscrollbuffer', 1, '$') |
| if has('win32') |
| let cmd = ['cmd', '/c', 'echo sometext'] |
| else |
| let cmd = [&shell, &shellcmdflag, 'echo sometext'] |
| endif |
| call job_start(cmd, #{out_io: 'buffer', out_name: 'Xscrollbuffer'}) |
| END |
| call writefile(lines, 'XtestBufferScroll', 'D') |
| let buf = RunVimInTerminal('-S XtestBufferScroll', #{rows: 10}) |
| call TermWait(buf, 50) |
| call VerifyScreenDump(buf, 'Test_job_buffer_scroll_1', {}) |
| |
| " clean up |
| call StopVimInTerminal(buf) |
| endfunc |
| |
| func Test_pipe_null() |
| " We cannot check that no I/O works, we only check that the job starts |
| " properly. |
| let job = job_start(s:python . " test_channel_pipe.py something", |
| \ {'in_io': 'null'}) |
| call assert_equal("run", job_status(job)) |
| try |
| call assert_equal('something', ch_read(job)) |
| finally |
| call job_stop(job) |
| endtry |
| |
| let job = job_start(s:python . " test_channel_pipe.py err-out", |
| \ {'out_io': 'null'}) |
| call assert_equal("run", job_status(job)) |
| try |
| call assert_equal('err-out', ch_read(job, {"part": "err"})) |
| finally |
| call job_stop(job) |
| endtry |
| |
| let job = job_start(s:python . " test_channel_pipe.py something", |
| \ {'err_io': 'null'}) |
| call assert_equal("run", job_status(job)) |
| try |
| call assert_equal('something', ch_read(job)) |
| finally |
| call job_stop(job) |
| endtry |
| |
| " This causes spurious leak errors with valgrind. |
| if !RunningWithValgrind() |
| let job = job_start(s:python . " test_channel_pipe.py something", |
| \ {'out_io': 'null', 'err_io': 'out'}) |
| call assert_equal("run", job_status(job)) |
| call job_stop(job) |
| |
| let job = job_start(s:python . " test_channel_pipe.py something", |
| \ {'in_io': 'null', 'out_io': 'null', 'err_io': 'null'}) |
| call assert_equal("run", job_status(job)) |
| call assert_equal('channel fail', string(job_getchannel(job))) |
| call assert_equal('fail', ch_status(job)) |
| call assert_equal('no process', string(test_null_job())) |
| call assert_equal('channel fail', string(test_null_channel())) |
| call job_stop(job) |
| endif |
| endfunc |
| |
| func Test_pipe_to_buffer_raw() |
| let options = {'out_mode': 'raw', 'out_io': 'buffer', 'out_name': 'testout'} |
| split testout |
| let job = job_start([s:python, '-c', |
| \ 'import sys; [sys.stdout.write(".") and sys.stdout.flush() for _ in range(10000)]'], options) |
| " the job may be done quickly, also accept "dead" |
| call assert_match('^\%(dead\|run\)$', job_status(job)) |
| call WaitFor('len(join(getline(1, "$"), "")) >= 10000') |
| try |
| let totlen = 0 |
| for line in getline(1, '$') |
| call assert_equal('', substitute(line, '^\.*', '', '')) |
| let totlen += len(line) |
| endfor |
| call assert_equal(10000, totlen) |
| finally |
| call job_stop(job) |
| bwipe! |
| endtry |
| endfunc |
| |
| func Test_reuse_channel() |
| let job = job_start(s:python . " test_channel_pipe.py") |
| call assert_equal("run", job_status(job)) |
| let handle = job_getchannel(job) |
| try |
| call ch_sendraw(handle, "echo something\n") |
| call assert_equal("something", ch_readraw(handle)) |
| finally |
| call job_stop(job) |
| endtry |
| |
| let job = job_start(s:python . " test_channel_pipe.py", {'channel': handle}) |
| call assert_equal("run", job_status(job)) |
| let handle = job_getchannel(job) |
| try |
| call ch_sendraw(handle, "echo again\n") |
| call assert_equal("again", ch_readraw(handle)) |
| finally |
| call job_stop(job) |
| endtry |
| endfunc |
| |
| func Test_out_cb() |
| let g:test_is_flaky = 1 |
| let dict = {'thisis': 'dict: '} |
| func dict.outHandler(chan, msg) dict |
| if type(a:msg) == v:t_string |
| let g:Ch_outmsg = self.thisis . a:msg |
| else |
| let g:Ch_outobj = a:msg |
| endif |
| endfunc |
| func dict.errHandler(chan, msg) dict |
| let g:Ch_errmsg = self.thisis . a:msg |
| endfunc |
| let job = job_start(s:python . " test_channel_pipe.py", |
| \ {'out_cb': dict.outHandler, |
| \ 'out_mode': 'json', |
| \ 'err_cb': dict.errHandler, |
| \ 'err_mode': 'json'}) |
| call assert_equal("run", job_status(job)) |
| call test_garbagecollect_now() |
| try |
| let g:Ch_outmsg = '' |
| let g:Ch_errmsg = '' |
| call ch_sendraw(job, "echo [0, \"hello\"]\n") |
| call ch_sendraw(job, "echoerr [0, \"there\"]\n") |
| call WaitForAssert({-> assert_equal("dict: hello", g:Ch_outmsg)}) |
| call WaitForAssert({-> assert_equal("dict: there", g:Ch_errmsg)}) |
| |
| " Receive a json object split in pieces |
| let g:Ch_outobj = '' |
| call ch_sendraw(job, "echosplit [0, {\"one\": 1,| \"tw|o\": 2, \"three\": 3|}]\n") |
| " For unknown reasons this can be very slow on Mac. |
| " Increase the timeout on every run. |
| if g:run_nr == 1 |
| let timeout = 5000 |
| elseif g:run_nr == 2 |
| let timeout = 10000 |
| elseif g:run_nr == 3 |
| let timeout = 20000 |
| else |
| let timeout = 40000 |
| endif |
| call WaitForAssert({-> assert_equal({'one': 1, 'two': 2, 'three': 3}, g:Ch_outobj)}, timeout) |
| finally |
| call job_stop(job) |
| endtry |
| endfunc |
| |
| func Test_out_close_cb() |
| let s:counter = 1 |
| let g:Ch_msg1 = '' |
| let g:Ch_closemsg = 0 |
| func! OutHandler(chan, msg) |
| if s:counter == 1 |
| let g:Ch_msg1 = a:msg |
| endif |
| let s:counter += 1 |
| endfunc |
| func! CloseHandler(chan) |
| let g:Ch_closemsg = s:counter |
| let s:counter += 1 |
| endfunc |
| let job = job_start(s:python . " test_channel_pipe.py quit now", |
| \ {'out_cb': 'OutHandler', |
| \ 'close_cb': 'CloseHandler'}) |
| " the job may be done quickly, also accept "dead" |
| call assert_match('^\%(dead\|run\)$', job_status(job)) |
| try |
| call WaitForAssert({-> assert_equal('quit', g:Ch_msg1)}) |
| call WaitForAssert({-> assert_equal(2, g:Ch_closemsg)}) |
| finally |
| call job_stop(job) |
| delfunc OutHandler |
| delfunc CloseHandler |
| endtry |
| endfunc |
| |
| func Test_read_in_close_cb() |
| let g:Ch_received = '' |
| func! CloseHandler(chan) |
| let g:Ch_received = ch_read(a:chan) |
| endfunc |
| let job = job_start(s:python . " test_channel_pipe.py quit now", |
| \ {'close_cb': 'CloseHandler'}) |
| " the job may be done quickly, also accept "dead" |
| call assert_match('^\%(dead\|run\)$', job_status(job)) |
| try |
| call WaitForAssert({-> assert_equal('quit', g:Ch_received)}) |
| finally |
| call job_stop(job) |
| delfunc CloseHandler |
| endtry |
| endfunc |
| |
| " Use channel in NL mode but received text does not end in NL. |
| func Test_read_in_close_cb_incomplete() |
| let g:Ch_received = '' |
| func! CloseHandler(chan) |
| while ch_status(a:chan, {'part': 'out'}) == 'buffered' |
| let g:Ch_received .= ch_read(a:chan) |
| endwhile |
| endfunc |
| let job = job_start(s:python . " test_channel_pipe.py incomplete", |
| \ {'close_cb': 'CloseHandler'}) |
| " the job may be done quickly, also accept "dead" |
| call assert_match('^\%(dead\|run\)$', job_status(job)) |
| try |
| call WaitForAssert({-> assert_equal('incomplete', g:Ch_received)}) |
| finally |
| call job_stop(job) |
| delfunc CloseHandler |
| endtry |
| endfunc |
| |
| func Test_out_cb_lambda() |
| let job = job_start(s:python . " test_channel_pipe.py", |
| \ {'out_cb': {ch, msg -> execute("let g:Ch_outmsg = 'lambda: ' . msg")}, |
| \ 'out_mode': 'json', |
| \ 'err_cb': {ch, msg -> execute(":let g:Ch_errmsg = 'lambda: ' . msg")}, |
| \ 'err_mode': 'json'}) |
| call assert_equal("run", job_status(job)) |
| try |
| let g:Ch_outmsg = '' |
| let g:Ch_errmsg = '' |
| call ch_sendraw(job, "echo [0, \"hello\"]\n") |
| call ch_sendraw(job, "echoerr [0, \"there\"]\n") |
| call WaitForAssert({-> assert_equal("lambda: hello", g:Ch_outmsg)}) |
| call WaitForAssert({-> assert_equal("lambda: there", g:Ch_errmsg)}) |
| finally |
| call job_stop(job) |
| endtry |
| endfunc |
| |
| func Test_close_and_exit_cb() |
| let g:test_is_flaky = 1 |
| let g:retdict = {'ret': {}} |
| func g:retdict.close_cb(ch) dict |
| let self.ret['close_cb'] = a:ch->ch_getjob()->job_status() |
| endfunc |
| func g:retdict.exit_cb(job, status) dict |
| let self.ret['exit_cb'] = job_status(a:job) |
| endfunc |
| |
| let job = job_start([&shell, &shellcmdflag, 'echo'], |
| \ {'close_cb': g:retdict.close_cb, |
| \ 'exit_cb': g:retdict.exit_cb}) |
| " the job may be done quickly, also accept "dead" |
| call assert_match('^\%(dead\|run\)$', job_status(job)) |
| call WaitForAssert({-> assert_equal(2, len(g:retdict.ret))}) |
| call assert_match('^\%(dead\|run\)$', g:retdict.ret['close_cb']) |
| call assert_equal('dead', g:retdict.ret['exit_cb']) |
| unlet g:retdict |
| endfunc |
| |
| """""""""" |
| |
| function ExitCbWipe(job, status) |
| exe g:wipe_buf 'bw!' |
| endfunction |
| |
| " This caused a crash, because messages were handled while peeking for a |
| " character. |
| func Test_exit_cb_wipes_buf() |
| CheckFeature timers |
| set cursorline lazyredraw |
| call test_override('redraw_flag', 1) |
| new |
| let g:wipe_buf = bufnr('') |
| |
| let job = job_start(has('win32') ? 'cmd /c echo:' : ['true'], |
| \ {'exit_cb': 'ExitCbWipe'}) |
| let timer = timer_start(300, {-> feedkeys("\<Esc>", 'nt')}, {'repeat': 5}) |
| call feedkeys(repeat('g', 1000) . 'o', 'ntx!') |
| call WaitForAssert({-> assert_equal("dead", job_status(job))}) |
| call timer_stop(timer) |
| |
| set nocursorline nolazyredraw |
| unlet g:wipe_buf |
| call test_override('ALL', 0) |
| endfunc |
| |
| """""""""" |
| |
| let g:Ch_unletResponse = '' |
| func s:UnletHandler(handle, msg) |
| let g:Ch_unletResponse = a:msg |
| unlet s:channelfd |
| endfunc |
| |
| " Test that "unlet handle" in a handler doesn't crash Vim. |
| func Ch_unlet_handle(port) |
| let s:channelfd = ch_open(s:address(a:port), s:chopt) |
| eval s:channelfd->ch_sendexpr("test", {'callback': function('s:UnletHandler')}) |
| call WaitForAssert({-> assert_equal('what?', g:Ch_unletResponse)}) |
| endfunc |
| |
| func Test_unlet_handle() |
| call s:run_server('Ch_unlet_handle') |
| endfunc |
| |
| func Test_unlet_handle_ipv6() |
| CheckIPv6 |
| call Test_unlet_handle() |
| endfunc |
| |
| """""""""" |
| |
| let g:Ch_unletResponse = '' |
| func Ch_CloseHandler(handle, msg) |
| let g:Ch_unletResponse = a:msg |
| eval s:channelfd->ch_close() |
| endfunc |
| |
| " Test that "unlet handle" in a handler doesn't crash Vim. |
| func Ch_close_handle(port) |
| let s:channelfd = ch_open(s:address(a:port), s:chopt) |
| call ch_sendexpr(s:channelfd, "test", {'callback': function('Ch_CloseHandler')}) |
| call WaitForAssert({-> assert_equal('what?', g:Ch_unletResponse)}) |
| endfunc |
| |
| func Test_close_handle() |
| call s:run_server('Ch_close_handle') |
| endfunc |
| |
| func Test_close_handle_ipv6() |
| CheckIPv6 |
| call Test_close_handle() |
| endfunc |
| |
| """""""""" |
| |
| func Ch_open_ipv6(port) |
| let handle = ch_open(s:address(a:port), s:chopt) |
| call assert_notequal('fail', ch_status(handle)) |
| endfunc |
| |
| func Test_open_ipv6() |
| CheckIPv6 |
| call s:run_server('Ch_open_ipv6') |
| endfunc |
| |
| """""""""" |
| |
| func Test_open_fail() |
| call assert_fails("let ch = ch_open('noserver')", 'E475:') |
| echo ch |
| let d = ch |
| call assert_fails("let ch = ch_open('noserver', 10)", 'E1206:') |
| call assert_fails("let ch = ch_open('localhost:-1')", 'E475:') |
| call assert_fails("let ch = ch_open('localhost:65537')", 'E475:') |
| call assert_fails("let ch = ch_open('localhost:8765', {'timeout' : -1})", |
| \ 'E474:') |
| call assert_fails("let ch = ch_open('localhost:8765', {'axby' : 1})", |
| \ 'E475:') |
| call assert_fails("let ch = ch_open('localhost:8765', {'mode' : 'abc'})", |
| \ 'E475:') |
| call assert_fails("let ch = ch_open('localhost:8765', {'part' : 'out'})", |
| \ 'E475:') |
| call assert_fails("let ch = ch_open('[::]')", 'E475:') |
| call assert_fails("let ch = ch_open('[::.80')", 'E475:') |
| call assert_fails("let ch = ch_open('[::]8080')", 'E475:') |
| endfunc |
| |
| func Test_ch_info_fail() |
| call assert_fails("let x = ch_info(10)", 'E475:') |
| endfunc |
| |
| """""""""" |
| |
| func Ch_open_delay(port) |
| " Wait up to a second for the port to open. |
| let s:chopt.waittime = 1000 |
| let channel = ch_open(s:address(a:port), s:chopt) |
| if ch_status(channel) == "fail" |
| call assert_report("Can't open channel") |
| return |
| endif |
| call assert_equal('got it', channel->ch_evalexpr('hello!')) |
| call ch_close(channel) |
| endfunc |
| |
| func Test_open_delay() |
| " The server will wait half a second before creating the port. |
| call s:run_server('Ch_open_delay', 'delay') |
| endfunc |
| |
| func Test_open_delay_ipv6() |
| CheckIPv6 |
| call Test_open_delay() |
| endfunc |
| |
| """"""""" |
| |
| function MyFunction(a,b,c) |
| let g:Ch_call_ret = [a:a, a:b, a:c] |
| endfunc |
| |
| function Ch_test_call(port) |
| let handle = ch_open(s:address(a:port), s:chopt) |
| if ch_status(handle) == "fail" |
| call assert_report("Can't open channel") |
| return |
| endif |
| |
| let g:Ch_call_ret = [] |
| call assert_equal('ok', ch_evalexpr(handle, 'call-func')) |
| call WaitForAssert({-> assert_equal([1, 2, 3], g:Ch_call_ret)}) |
| |
| call assert_fails("let i = ch_evalexpr(handle, '2 + 2', {'callback' : 'abc'})", 'E917:') |
| call assert_fails("let i = ch_evalexpr(handle, '2 + 2', {'drop' : ''})", 'E475:') |
| call assert_fails("let i = ch_evalexpr(test_null_job(), '2 + 2')", 'E906:') |
| endfunc |
| |
| func Test_call() |
| call s:run_server('Ch_test_call') |
| endfunc |
| |
| func Test_call_ipv6() |
| CheckIPv6 |
| call Test_call() |
| endfunc |
| |
| func Test_call_unix() |
| CheckUnix |
| call Test_call() |
| call delete('Xtestsocket') |
| endfunc |
| |
| """"""""" |
| |
| let g:Ch_job_exit_ret = 'not yet' |
| function MyExitCb(job, status) |
| let g:Ch_job_exit_ret = 'done' |
| endfunc |
| |
| function Ch_test_exit_callback(port) |
| eval g:currentJob->job_setoptions({'exit_cb': 'MyExitCb'}) |
| let g:Ch_exit_job = g:currentJob |
| call assert_equal('MyExitCb', job_info(g:currentJob)['exit_cb']) |
| endfunc |
| |
| func Test_exit_callback() |
| call s:run_server('Ch_test_exit_callback') |
| |
| " wait up to a second for the job to exit |
| for i in range(100) |
| if g:Ch_job_exit_ret == 'done' |
| break |
| endif |
| sleep 10m |
| " calling job_status() triggers the callback |
| call job_status(g:Ch_exit_job) |
| endfor |
| |
| call assert_equal('done', g:Ch_job_exit_ret) |
| call assert_equal('dead', job_info(g:Ch_exit_job).status) |
| unlet g:Ch_exit_job |
| endfunc |
| |
| function MyExitTimeCb(job, status) |
| if job_info(a:job).process == g:exit_cb_val.process |
| let g:exit_cb_val.end = reltime(g:exit_cb_val.start) |
| endif |
| call Resume() |
| endfunction |
| |
| func Test_exit_callback_interval() |
| CheckFunction reltimefloat |
| let g:test_is_flaky = 1 |
| |
| let g:exit_cb_val = {'start': reltime(), 'end': 0, 'process': 0} |
| let job = [s:python, '-c', 'import time;time.sleep(0.5)']->job_start({'exit_cb': 'MyExitTimeCb'}) |
| let g:exit_cb_val.process = job_info(job).process |
| try |
| call WaitFor('type(g:exit_cb_val.end) != v:t_number || g:exit_cb_val.end != 0') |
| catch |
| call add(v:errors, "Job status: " .. string(job->job_info())) |
| throw v:exception |
| endtry |
| let elapsed = reltimefloat(g:exit_cb_val.end) |
| call assert_inrange(0.5, 1.0, elapsed) |
| |
| " case: unreferenced job, using timer |
| if !has('timers') |
| return |
| endif |
| |
| let g:exit_cb_val = {'start': reltime(), 'end': 0, 'process': 0} |
| let g:job = job_start([s:python, '-c', 'import time;time.sleep(0.5)'], {'exit_cb': 'MyExitTimeCb'}) |
| let g:exit_cb_val.process = job_info(g:job).process |
| unlet g:job |
| call Standby(1000) |
| if type(g:exit_cb_val.end) != v:t_number || g:exit_cb_val.end != 0 |
| let elapsed = reltimefloat(g:exit_cb_val.end) |
| else |
| let elapsed = 1.0 |
| endif |
| call assert_inrange(0.5, 1.0, elapsed) |
| endfunc |
| |
| """"""""" |
| |
| let g:Ch_close_ret = 'alive' |
| function MyCloseCb(ch) |
| let g:Ch_close_ret = 'closed' |
| endfunc |
| |
| function Ch_test_close_callback(port) |
| let handle = ch_open(s:address(a:port), s:chopt) |
| if ch_status(handle) == "fail" |
| call assert_report("Can't open channel") |
| return |
| endif |
| call ch_setoptions(handle, {'close_cb': 'MyCloseCb'}) |
| |
| call assert_equal('', ch_evalexpr(handle, 'close me')) |
| call WaitForAssert({-> assert_equal('closed', g:Ch_close_ret)}) |
| endfunc |
| |
| func Test_close_callback() |
| call s:run_server('Ch_test_close_callback') |
| endfunc |
| |
| func Test_close_callback_ipv6() |
| CheckIPv6 |
| call Test_close_callback() |
| endfunc |
| |
| func Test_close_callback_unix() |
| CheckUnix |
| call Test_close_callback() |
| call delete('Xtestsocket') |
| endfunc |
| |
| function Ch_test_close_partial(port) |
| let handle = ch_open(s:address(a:port), s:chopt) |
| if ch_status(handle) == "fail" |
| call assert_report("Can't open channel") |
| return |
| endif |
| let g:Ch_d = {} |
| func g:Ch_d.closeCb(ch) dict |
| let self.close_ret = 'closed' |
| endfunc |
| call ch_setoptions(handle, {'close_cb': g:Ch_d.closeCb}) |
| |
| call assert_equal('', ch_evalexpr(handle, 'close me')) |
| call WaitForAssert({-> assert_equal('closed', g:Ch_d.close_ret)}) |
| unlet g:Ch_d |
| endfunc |
| |
| func Test_close_partial() |
| call s:run_server('Ch_test_close_partial') |
| endfunc |
| |
| func Test_close_partial_ipv6() |
| CheckIPv6 |
| call Test_close_partial() |
| endfunc |
| |
| func Test_close_partial_unix() |
| CheckUnix |
| call Test_close_partial() |
| call delete('Xtestsocket') |
| endfunc |
| |
| func Test_job_start_fails() |
| " this was leaking memory |
| call assert_fails("call job_start([''])", "E474:") |
| call assert_fails('call job_start($x)', 'E474:') |
| call assert_fails('call job_start("")', 'E474:') |
| call assert_fails('call job_start("ls", {"out_io" : "abc"})', 'E475:') |
| call assert_fails('call job_start("ls", {"err_io" : "abc"})', 'E475:') |
| call assert_fails('call job_start("ls", [])', 'E715:') |
| call assert_fails("call job_start('ls', {'in_top' : -1})", 'E475:') |
| call assert_fails("call job_start('ls', {'in_bot' : -1})", 'E475:') |
| call assert_fails("call job_start('ls', {'channel' : -1})", 'E475:') |
| call assert_fails("call job_start('ls', {'callback' : -1})", 'E921:') |
| call assert_fails("call job_start('ls', {'out_cb' : -1})", 'E921:') |
| call assert_fails("call job_start('ls', {'err_cb' : -1})", 'E921:') |
| call assert_fails("call job_start('ls', {'close_cb' : -1})", 'E921:') |
| call assert_fails("call job_start('ls', {'exit_cb' : -1})", 'E921:') |
| call assert_fails("call job_start('ls', {'term_name' : []})", 'E475:') |
| call assert_fails("call job_start('ls', {'term_finish' : 'run'})", 'E475:') |
| call assert_fails("call job_start('ls', {'term_api' : []})", 'E475:') |
| call assert_fails("call job_start('ls', {'stoponexit' : []})", 'E730:') |
| call assert_fails("call job_start('ls', {'in_io' : 'file'})", 'E920:') |
| call assert_fails("call job_start('ls', {'out_io' : 'file'})", 'E920:') |
| call assert_fails("call job_start('ls', {'err_io' : 'file'})", 'E920:') |
| call assert_fails("call job_start('ls', {'in_mode' : 'abc'})", 'E475:') |
| call assert_fails("call job_start('ls', {'out_mode' : 'abc'})", 'E475:') |
| call assert_fails("call job_start('ls', {'err_mode' : 'abc'})", 'E475:') |
| call assert_fails("call job_start('ls', |
| \ {'in_io' : 'buffer', 'in_buf' : 99999})", 'E86:') |
| call assert_fails("call job_start('ls', |
| \ {'out_io' : 'buffer', 'out_buf' : 99999})", 'E86:') |
| call assert_fails("call job_start('ls', |
| \ {'err_io' : 'buffer', 'err_buf' : 99999})", 'E86:') |
| |
| call assert_fails("call job_start('ls', |
| \ {'in_io' : 'buffer', 'in_buf' : -1})", 'E475:') |
| call assert_fails("call job_start('ls', |
| \ {'out_io' : 'buffer', 'out_buf' : -1})", 'E475:') |
| call assert_fails("call job_start('ls', |
| \ {'err_io' : 'buffer', 'err_buf' : -1})", 'E475:') |
| |
| let cmd = has('win32') ? "cmd /c dir" : "ls" |
| |
| set nomodifiable |
| call assert_fails("call job_start(cmd, |
| \ {'out_io' : 'buffer', 'out_buf' :" .. bufnr() .. "})", 'E21:') |
| call assert_fails("call job_start(cmd, |
| \ {'err_io' : 'buffer', 'err_buf' :" .. bufnr() .. "})", 'E21:') |
| set modifiable |
| |
| call assert_fails("call job_start(cmd, {'in_io' : 'buffer'})", 'E915:') |
| |
| edit! XXX |
| let bnum = bufnr() |
| enew |
| call assert_fails("call job_start(cmd, |
| \ {'in_io' : 'buffer', 'in_buf' : bnum})", 'E918:') |
| |
| " Empty job tests |
| " This was crashing on MS-Windows. |
| call assert_fails('let job = job_start([""])', 'E474:') |
| call assert_fails('let job = job_start([" "])', 'E474:') |
| call assert_fails('let job = job_start("")', 'E474:') |
| call assert_fails('let job = job_start(" ")', 'E474:') |
| call assert_fails('let job = job_start(["ls", []])', 'E730:') |
| call assert_fails('call job_setoptions(test_null_job(), {})', 'E916:') |
| %bw! |
| endfunc |
| |
| func Test_job_stop_immediately() |
| " With valgrind this causes spurious leak reports |
| CheckNotValgrind |
| |
| let g:job = job_start([s:python, '-c', 'import time;time.sleep(10)']) |
| try |
| eval g:job->job_stop() |
| call WaitForAssert({-> assert_equal('dead', job_status(g:job))}) |
| finally |
| call job_stop(g:job, 'kill') |
| unlet g:job |
| endtry |
| endfunc |
| |
| func Test_null_job_eval() |
| call assert_fails('eval test_null_job()->eval()', 'E121:') |
| endfunc |
| |
| " This was leaking memory. |
| func Test_partial_in_channel_cycle() |
| let d = {} |
| let d.a = function('string', [d]) |
| try |
| let d.b = ch_open('nowhere:123', {'close_cb': d.a}) |
| call test_garbagecollect_now() |
| catch |
| call assert_exception('E901:') |
| endtry |
| unlet d |
| endfunc |
| |
| func Test_using_freed_memory() |
| let g:a = job_start(['ls']) |
| sleep 10m |
| call test_garbagecollect_now() |
| endfunc |
| |
| func Test_collapse_buffers() |
| let g:test_is_flaky = 1 |
| CheckExecutable cat |
| |
| sp test_channel.vim |
| let g:linecount = line('$') |
| close |
| split testout |
| 1,$delete |
| call job_start('cat test_channel.vim', {'out_io': 'buffer', 'out_name': 'testout'}) |
| call WaitForAssert({-> assert_inrange(g:linecount, g:linecount + 1, line('$'))}) |
| bwipe! |
| endfunc |
| |
| func Test_write_to_deleted_buffer() |
| CheckExecutable echo |
| CheckFeature quickfix |
| |
| let job = job_start('echo hello', {'out_io': 'buffer', 'out_name': 'test_buffer', 'out_msg': 0}) |
| let bufnr = bufnr('test_buffer') |
| call WaitForAssert({-> assert_equal(['hello'], getbufline(bufnr, 1, '$'))}) |
| call assert_equal('nofile', getbufvar(bufnr, '&buftype')) |
| call assert_equal('hide', getbufvar(bufnr, '&bufhidden')) |
| |
| bdel test_buffer |
| call assert_equal([], getbufline(bufnr, 1, '$')) |
| |
| let job = job_start('echo hello', {'out_io': 'buffer', 'out_name': 'test_buffer', 'out_msg': 0}) |
| call WaitForAssert({-> assert_equal(['hello'], getbufline(bufnr, 1, '$'))}) |
| call assert_equal('nofile', getbufvar(bufnr, '&buftype')) |
| call assert_equal('hide', getbufvar(bufnr, '&bufhidden')) |
| |
| bwipe! test_buffer |
| endfunc |
| |
| func Test_cmd_parsing() |
| CheckUnix |
| |
| call assert_false(filereadable("file with space")) |
| let job = job_start('touch "file with space"') |
| call WaitForAssert({-> assert_true(filereadable("file with space"))}) |
| call delete("file with space") |
| |
| let job = job_start('touch file\ with\ space') |
| call WaitForAssert({-> assert_true(filereadable("file with space"))}) |
| call delete("file with space") |
| endfunc |
| |
| func Test_raw_passes_nul() |
| CheckExecutable cat |
| |
| " Test lines from the job containing NUL are stored correctly in a buffer. |
| new |
| call setline(1, ["asdf\nasdf", "xxx\n", "\nyyy"]) |
| w! Xtestread |
| bwipe! |
| split testout |
| 1,$delete |
| call job_start('cat Xtestread', {'out_io': 'buffer', 'out_name': 'testout'}) |
| call WaitFor('line("$") > 2') |
| call assert_equal("asdf\nasdf", getline(1)) |
| call assert_equal("xxx\n", getline(2)) |
| call assert_equal("\nyyy", getline(3)) |
| |
| call delete('Xtestread') |
| bwipe! |
| |
| " Test lines from a buffer with NUL bytes are written correctly to the job. |
| new mybuffer |
| call setline(1, ["asdf\nasdf", "xxx\n", "\nyyy"]) |
| let g:Ch_job = job_start('cat', {'in_io': 'buffer', 'in_name': 'mybuffer', 'out_io': 'file', 'out_name': 'Xtestwrite'}) |
| call WaitForAssert({-> assert_equal("dead", job_status(g:Ch_job))}) |
| bwipe! |
| split Xtestwrite |
| call assert_equal("asdf\nasdf", getline(1)) |
| call assert_equal("xxx\n", getline(2)) |
| call assert_equal("\nyyy", getline(3)) |
| call assert_equal(-1, match(s:get_resources(), '\(^\|/\)Xtestwrite$')) |
| |
| call delete('Xtestwrite') |
| bwipe! |
| endfunc |
| |
| func Test_read_nonl_line() |
| let g:linecount = 0 |
| let arg = 'import sys;sys.stdout.write("1\n2\n3")' |
| call job_start([s:python, '-c', arg], {'callback': {-> execute('let g:linecount += 1')}}) |
| call WaitForAssert({-> assert_equal(3, g:linecount)}) |
| unlet g:linecount |
| endfunc |
| |
| func Test_read_nonl_in_close_cb() |
| func s:close_cb(ch) |
| while ch_status(a:ch) == 'buffered' |
| let g:out .= ch_read(a:ch) |
| endwhile |
| endfunc |
| |
| let g:out = '' |
| let arg = 'import sys;sys.stdout.write("1\n2\n3")' |
| call job_start([s:python, '-c', arg], {'close_cb': function('s:close_cb')}) |
| call test_garbagecollect_now() |
| call WaitForAssert({-> assert_equal('123', g:out)}) |
| unlet g:out |
| delfunc s:close_cb |
| endfunc |
| |
| func Test_read_from_terminated_job() |
| let g:linecount = 0 |
| let arg = 'import os,sys;os.close(1);sys.stderr.write("test\n")' |
| call job_start([s:python, '-c', arg], {'callback': {-> execute('let g:linecount += 1')}}) |
| call WaitForAssert({-> assert_equal(1, g:linecount)}) |
| call test_garbagecollect_now() |
| unlet g:linecount |
| endfunc |
| |
| func Test_job_start_windows() |
| CheckMSWindows |
| |
| " Check that backslash in $COMSPEC is handled properly. |
| let g:echostr = '' |
| let cmd = $COMSPEC . ' /c echo 123' |
| let job = job_start(cmd, {'callback': {ch,msg -> execute(":let g:echostr .= msg")}}) |
| let info = job_info(job) |
| call assert_equal([$COMSPEC, '/c', 'echo', '123'], info.cmd) |
| |
| call WaitForAssert({-> assert_equal("123", g:echostr)}) |
| unlet g:echostr |
| endfunc |
| |
| func Test_env() |
| let g:envstr = '' |
| if has('win32') |
| let cmd = ['cmd', '/c', 'echo %FOO%'] |
| else |
| let cmd = [&shell, &shellcmdflag, 'echo $FOO'] |
| endif |
| call assert_fails('call job_start(cmd, {"env": 1})', 'E475:') |
| let job = job_start(cmd, {'callback': {ch,msg -> execute(":let g:envstr .= msg")}, 'env': {'FOO': 'bar'}}) |
| if WaitForAssert({-> assert_equal("bar", g:envstr)}, 500) != 0 |
| call add(v:errors, "Job status: " .. string(job->job_info())) |
| endif |
| unlet g:envstr |
| endfunc |
| |
| func Test_cwd() |
| let g:test_is_flaky = 1 |
| let g:envstr = '' |
| if has('win32') |
| let expect = $TEMP |
| let cmd = ['cmd', '/c', 'echo %CD%'] |
| else |
| let expect = $HOME |
| let cmd = ['pwd'] |
| endif |
| let job = job_start(cmd, {'callback': {ch,msg -> execute(":let g:envstr .= msg")}, 'cwd': expect}) |
| try |
| call WaitForAssert({-> assert_notequal("", g:envstr)}) |
| let expect = substitute(expect, '[/\\]$', '', '') |
| let g:envstr = substitute(g:envstr, '[/\\]$', '', '') |
| if $CI != '' && stridx(g:envstr, '/private/') == 0 |
| let g:envstr = g:envstr[8:] |
| endif |
| call assert_equal(expect, g:envstr) |
| finally |
| call job_stop(job) |
| unlet g:envstr |
| endtry |
| endfunc |
| |
| function Ch_test_close_lambda(port) |
| let handle = ch_open(s:address(a:port), s:chopt) |
| if ch_status(handle) == "fail" |
| call assert_report("Can't open channel") |
| return |
| endif |
| let g:Ch_close_ret = '' |
| call ch_setoptions(handle, {'close_cb': {ch -> execute("let g:Ch_close_ret = 'closed'")}}) |
| call test_garbagecollect_now() |
| |
| call assert_equal('', ch_evalexpr(handle, 'close me')) |
| call WaitForAssert({-> assert_equal('closed', g:Ch_close_ret)}) |
| endfunc |
| |
| func Test_close_lambda() |
| call s:run_server('Ch_test_close_lambda') |
| endfunc |
| |
| func Test_close_lambda_ipv6() |
| CheckIPv6 |
| call Test_close_lambda() |
| endfunc |
| |
| func Test_close_lambda_unix() |
| CheckUnix |
| call Test_close_lambda() |
| call delete('Xtestsocket') |
| endfunc |
| |
| func s:test_list_args(cmd, out, remove_lf) |
| try |
| let g:out = '' |
| let job = job_start([s:python, '-c', a:cmd], {'callback': {ch, msg -> execute('let g:out .= msg')}, 'out_mode': 'raw'}) |
| try |
| call WaitFor('"" != g:out') |
| catch |
| call add(v:errors, "Job status: " .. string(job->job_info())) |
| throw v:exception |
| endtry |
| if has('win32') |
| let g:out = substitute(g:out, '\r', '', 'g') |
| endif |
| if a:remove_lf |
| let g:out = substitute(g:out, '\n$', '', 'g') |
| endif |
| call assert_equal(a:out, g:out) |
| finally |
| call job_stop(job) |
| unlet g:out |
| endtry |
| endfunc |
| |
| func Test_list_args() |
| call s:test_list_args('import sys;sys.stdout.write("hello world")', "hello world", 0) |
| call s:test_list_args('import sys;sys.stdout.write("hello\nworld")', "hello\nworld", 0) |
| call s:test_list_args('import sys;sys.stdout.write(''hello\nworld'')', "hello\nworld", 0) |
| call s:test_list_args('import sys;sys.stdout.write(''hello"world'')', "hello\"world", 0) |
| call s:test_list_args('import sys;sys.stdout.write(''hello^world'')', "hello^world", 0) |
| call s:test_list_args('import sys;sys.stdout.write("hello&&world")', "hello&&world", 0) |
| call s:test_list_args('import sys;sys.stdout.write(''hello\\world'')', "hello\\world", 0) |
| call s:test_list_args('import sys;sys.stdout.write(''hello\\\\world'')', "hello\\\\world", 0) |
| call s:test_list_args('import sys;sys.stdout.write("hello\"world\"")', 'hello"world"', 0) |
| call s:test_list_args('import sys;sys.stdout.write("h\"ello worl\"d")', 'h"ello worl"d', 0) |
| call s:test_list_args('import sys;sys.stdout.write("h\"e\\\"llo wor\\\"l\"d")', 'h"e\"llo wor\"l"d', 0) |
| call s:test_list_args('import sys;sys.stdout.write("h\"e\\\"llo world")', 'h"e\"llo world', 0) |
| call s:test_list_args('import sys;sys.stdout.write("hello\tworld")', "hello\tworld", 0) |
| |
| " tests which not contain spaces in the argument |
| call s:test_list_args('print("hello\nworld")', "hello\nworld", 1) |
| call s:test_list_args('print(''hello\nworld'')', "hello\nworld", 1) |
| call s:test_list_args('print(''hello"world'')', "hello\"world", 1) |
| call s:test_list_args('print(''hello^world'')', "hello^world", 1) |
| call s:test_list_args('print("hello&&world")', "hello&&world", 1) |
| call s:test_list_args('print(''hello\\world'')', "hello\\world", 1) |
| call s:test_list_args('print(''hello\\\\world'')', "hello\\\\world", 1) |
| call s:test_list_args('print("hello\"world\"")', 'hello"world"', 1) |
| call s:test_list_args('print("hello\tworld")', "hello\tworld", 1) |
| endfunc |
| |
| func Test_keep_pty_open() |
| CheckUnix |
| |
| let job = job_start(s:python . ' -c "import time;time.sleep(0.2)"', |
| \ {'out_io': 'null', 'err_io': 'null', 'pty': 1}) |
| let elapsed = WaitFor({-> job_status(job) ==# 'dead'}) |
| call assert_inrange(200, 1000, elapsed) |
| call job_stop(job) |
| endfunc |
| |
| func Test_job_start_in_timer() |
| CheckFeature timers |
| CheckFunction reltimefloat |
| |
| func OutCb(chan, msg) |
| let g:val += 1 |
| endfunc |
| |
| func ExitCb(job, status) |
| let g:val += 1 |
| call Resume() |
| endfunc |
| |
| func TimerCb(timer) |
| if has('win32') |
| let cmd = ['cmd', '/c', 'echo.'] |
| else |
| let cmd = ['echo'] |
| endif |
| let g:job = job_start(cmd, {'out_cb': 'OutCb', 'exit_cb': 'ExitCb'}) |
| call substitute(repeat('a', 100000), '.', '', 'g') |
| endfunc |
| |
| " We should be interrupted before 'updatetime' elapsed. |
| let g:val = 0 |
| call timer_start(1, 'TimerCb') |
| let elapsed = Standby(&ut) |
| call assert_inrange(1, &ut / 2, elapsed) |
| |
| " Wait for both OutCb() and ExitCb() to have been called before deleting |
| " them. |
| call WaitForAssert({-> assert_equal(2, g:val)}) |
| call job_stop(g:job) |
| |
| delfunc OutCb |
| delfunc ExitCb |
| delfunc TimerCb |
| unlet! g:val |
| unlet! g:job |
| endfunc |
| |
| func Test_raw_large_data() |
| try |
| let g:out = '' |
| let job = job_start(s:python . " test_channel_pipe.py", |
| \ {'mode': 'raw', 'drop': 'never', 'noblock': 1, |
| \ 'callback': {ch, msg -> execute('let g:out .= msg')}}) |
| |
| let outlen = 79999 |
| let want = repeat('X', outlen) . "\n" |
| eval job->ch_sendraw(want) |
| call WaitFor({-> len(g:out) >= outlen}, 10000) |
| call WaitForAssert({-> assert_equal("dead", job_status(job))}) |
| call assert_equal(want, substitute(g:out, '\r', '', 'g')) |
| finally |
| call job_stop(job) |
| unlet g:out |
| endtry |
| endfunc |
| |
| func Test_no_hang_windows() |
| CheckMSWindows |
| |
| try |
| let job = job_start(s:python . " test_channel_pipe.py busy", |
| \ {'mode': 'raw', 'drop': 'never', 'noblock': 0}) |
| call assert_fails('call ch_sendraw(job, repeat("X", 80000))', 'E631:') |
| finally |
| call job_stop(job) |
| endtry |
| endfunc |
| |
| func Test_job_exitval_and_termsig() |
| CheckUnix |
| |
| " Terminate job normally |
| let cmd = ['echo'] |
| let job = job_start(cmd) |
| call WaitForAssert({-> assert_equal("dead", job_status(job))}) |
| let info = job_info(job) |
| call assert_equal(0, info.exitval) |
| call assert_equal("", info.termsig) |
| |
| " Terminate job by signal |
| let cmd = ['sleep', '10'] |
| let job = job_start(cmd) |
| " 10m usually works but 50m is needed when running Valgrind |
| sleep 50m |
| call job_stop(job) |
| call WaitForAssert({-> assert_equal("dead", job_status(job))}) |
| let info = job_info(job) |
| call assert_equal(-1, info.exitval) |
| call assert_equal("term", info.termsig) |
| endfunc |
| |
| func Test_job_tty_in_out() |
| CheckUnix |
| |
| call writefile(['test'], 'Xtestin', 'D') |
| let in_opts = [{}, |
| \ {'in_io': 'null'}, |
| \ {'in_io': 'file', 'in_name': 'Xtestin'}] |
| let out_opts = [{}, |
| \ {'out_io': 'null'}, |
| \ {'out_io': 'file', 'out_name': 'Xtestout'}] |
| let err_opts = [{}, |
| \ {'err_io': 'null'}, |
| \ {'err_io': 'file', 'err_name': 'Xtesterr'}, |
| \ {'err_io': 'out'}] |
| let opts = [] |
| |
| for in_opt in in_opts |
| let x = copy(in_opt) |
| for out_opt in out_opts |
| let x = extend(copy(x), out_opt) |
| for err_opt in err_opts |
| let x = extend(copy(x), err_opt) |
| let opts += [extend({'pty': 1}, x)] |
| endfor |
| endfor |
| endfor |
| |
| for opt in opts |
| let job = job_start('echo', opt) |
| let info = job_info(job) |
| let msg = printf('option={"in_io": "%s", "out_io": "%s", "err_io": "%s"}', |
| \ get(opt, 'in_io', 'tty'), |
| \ get(opt, 'out_io', 'tty'), |
| \ get(opt, 'err_io', 'tty')) |
| |
| if !has_key(opt, 'in_io') || !has_key(opt, 'out_io') || !has_key(opt, 'err_io') |
| call assert_notequal('', info.tty_in, msg) |
| else |
| call assert_equal('', info.tty_in, msg) |
| endif |
| call assert_equal(info.tty_in, info.tty_out, msg) |
| |
| call WaitForAssert({-> assert_equal('dead', job_status(job))}) |
| endfor |
| |
| call delete('Xtestout') |
| call delete('Xtesterr') |
| endfunc |
| |
| " Do this last, it stops any channel log. |
| func Test_zz_nl_err_to_out_pipe() |
| |
| eval 'Xlog'->ch_logfile() |
| call ch_log('Test_zz_nl_err_to_out_pipe()') |
| let job = job_start(s:python . " test_channel_pipe.py", {'err_io': 'out'}) |
| call assert_equal("run", job_status(job)) |
| try |
| let handle = job_getchannel(job) |
| call ch_sendraw(handle, "echo something\n") |
| call assert_equal("something", ch_readraw(handle)) |
| |
| call ch_sendraw(handle, "echoerr wrong\n") |
| call assert_equal("wrong", ch_readraw(handle)) |
| finally |
| call job_stop(job) |
| call ch_logfile('') |
| let loglines = readfile('Xlog') |
| call assert_true(len(loglines) > 10) |
| let found_test = 0 |
| let found_send = 0 |
| let found_recv = 0 |
| let found_stop = 0 |
| for l in loglines |
| if l =~ 'Test_zz_nl_err_to_out_pipe' |
| let found_test = 1 |
| endif |
| if l =~ 'SEND on.*echo something' |
| let found_send = 1 |
| endif |
| if l =~ 'RECV on.*something' |
| let found_recv = 1 |
| endif |
| if l =~ 'Stopping job with' |
| let found_stop = 1 |
| endif |
| endfor |
| call assert_equal(1, found_test) |
| call assert_equal(1, found_send) |
| call assert_equal(1, found_recv) |
| call assert_equal(1, found_stop) |
| " On MS-Windows need to sleep for a moment to be able to delete the file. |
| sleep 10m |
| call delete('Xlog') |
| endtry |
| endfunc |
| |
| " Do this last, it stops any channel log. |
| func Test_zz_ch_log() |
| call ch_logfile('Xlog', 'w') |
| call ch_log('hello there') |
| call ch_log('%s%s') |
| call ch_logfile('') |
| let text = readfile('Xlog') |
| call assert_match("hello there", text[1]) |
| call assert_match("%s%s", text[2]) |
| call mkdir("Xchlogdir1", 'D') |
| call assert_fails("call ch_logfile('Xchlogdir1')", 'E484:') |
| |
| call delete('Xlog') |
| endfunc |
| |
| func Test_issue_5150() |
| if has('win32') |
| let cmd = 'cmd /c pause' |
| else |
| let cmd = 'grep foo' |
| endif |
| |
| let g:job = job_start(cmd, {}) |
| sleep 50m " give the job time to start |
| call job_stop(g:job) |
| call WaitForAssert({-> assert_equal(-1, job_info(g:job).exitval)}) |
| |
| let g:job = job_start(cmd, {}) |
| sleep 50m |
| call job_stop(g:job, 'term') |
| call WaitForAssert({-> assert_equal(-1, job_info(g:job).exitval)}) |
| |
| let g:job = job_start(cmd, {}) |
| sleep 50m |
| call job_stop(g:job, 'kill') |
| call WaitForAssert({-> assert_equal(-1, job_info(g:job).exitval)}) |
| endfunc |
| |
| func Test_issue_5485() |
| let $VAR1 = 'global' |
| let g:Ch_reply = "" |
| let l:job = job_start([&shell, &shellcmdflag, has('win32') ? 'echo %VAR1% %VAR2%' : 'echo $VAR1 $VAR2'], {'env': {'VAR1': 'local', 'VAR2': 'local'}, 'callback': 'Ch_handler'}) |
| let g:Ch_job = l:job |
| call WaitForAssert({-> assert_equal("local local", trim(g:Ch_reply))}) |
| unlet $VAR1 |
| endfunc |
| |
| func Test_job_trailing_space_unix() |
| CheckUnix |
| CheckExecutable cat |
| |
| let job = job_start("cat ", #{in_io: 'null'}) |
| call WaitForAssert({-> assert_equal("dead", job_status(job))}) |
| call assert_equal(0, job_info(job).exitval) |
| |
| call delete('Xtestsocket') |
| endfunc |
| |
| func Test_ch_getbufnr() |
| let ch = test_null_channel() |
| call assert_equal(-1, ch_getbufnr(ch, 'in')) |
| call assert_equal(-1, ch_getbufnr(ch, 'out')) |
| call assert_equal(-1, ch_getbufnr(ch, 'err')) |
| call assert_equal(-1, ch_getbufnr(ch, '')) |
| endfunc |
| |
| " Test for unsupported options passed to ch_status() |
| func Test_invalid_job_chan_options() |
| let ch = test_null_channel() |
| let invalid_opts = [ |
| \ {'in_io' : 'null'}, |
| \ {'out_io' : 'null'}, |
| \ {'err_io' : 'null'}, |
| \ {'mode' : 'json'}, |
| \ {'out_mode' : 'json'}, |
| \ {'err_mode' : 'json'}, |
| \ {'noblock' : 1}, |
| \ {'in_name' : '/a/b'}, |
| \ {'pty' : 1}, |
| \ {'in_buf' : 1}, |
| \ {'out_buf' : 1}, |
| \ {'err_buf' : 1}, |
| \ {'out_modifiable' : 1}, |
| \ {'err_modifiable' : 1}, |
| \ {'out_msg' : 1}, |
| \ {'err_msg' : 1}, |
| \ {'in_top' : 1}, |
| \ {'in_bot' : 1}, |
| \ {'channel' : ch}, |
| \ {'callback' : ''}, |
| \ {'out_cb' : ''}, |
| \ {'err_cb' : ''}, |
| \ {'close_cb' : ''}, |
| \ {'exit_cb' : ''}, |
| \ {'term_opencmd' : ''}, |
| \ {'eof_chars' : ''}, |
| \ {'term_rows' : 10}, |
| \ {'term_cols' : 10}, |
| \ {'vertical' : 0}, |
| \ {'curwin' : 1}, |
| \ {'bufnr' : 1}, |
| \ {'hidden' : 0}, |
| \ {'norestore' : 0}, |
| \ {'term_kill' : 'kill'}, |
| \ {'tty_type' : ''}, |
| \ {'term_highlight' : ''}, |
| \ {'env' : {}}, |
| \ {'cwd' : ''}, |
| \ {'timeout' : 0}, |
| \ {'out_timeout' : 0}, |
| \ {'err_timeout' : 0}, |
| \ {'id' : 0}, |
| \ {'stoponexit' : ''}, |
| \ {'block_write' : 1} |
| \ ] |
| if has('gui') |
| call add(invalid_opts, {'ansi_colors' : []}) |
| endif |
| |
| for opt in invalid_opts |
| call assert_fails("let x = ch_status(ch, opt)", 'E475:') |
| endfor |
| call assert_equal('fail', ch_status(ch, test_null_dict())) |
| endfunc |
| |
| " Test for passing the command and the arguments as List on MS-Windows |
| func Test_job_with_list_args() |
| CheckMSWindows |
| |
| enew! |
| let bnum = bufnr() |
| let job = job_start(['cmd', '/c', 'echo', 'Hello', 'World'], {'out_io' : 'buffer', 'out_buf' : bnum}) |
| call WaitForAssert({-> assert_equal("dead", job_status(job))}) |
| call assert_equal('Hello World', getline(1)) |
| %bw! |
| endfunc |
| |
| func ExitCb_cb_with_input(job, status) |
| call feedkeys(":\<C-u>echo input('', 'default')\<CR>\<CR>", 'nx') |
| call assert_equal('default', Screenline(&lines)) |
| let g:wait_exit_cb = 0 |
| endfunc |
| |
| func Test_cb_with_input() |
| let g:wait_exit_cb = 1 |
| |
| if has('win32') |
| let cmd = 'cmd /c echo "Vim''s test"' |
| else |
| let cmd = 'echo "Vim''s test"' |
| endif |
| |
| let job = job_start(cmd, {'out_cb': 'ExitCb_cb_with_input'}) |
| call WaitFor({-> job_status(job) == "dead"}) |
| call WaitForAssert({-> assert_equal(0, g:wait_exit_cb)}) |
| |
| unlet g:wait_exit_cb |
| endfunc |
| |
| function s:HandleBufEnter() abort |
| let queue = [] |
| let job = job_start(['date'], {'callback': { j, d -> add(queue, d) }}) |
| while empty(queue) |
| sleep! 10m |
| endwhile |
| endfunction |
| |
| func Test_parse_messages_in_autocmd() |
| CheckUnix |
| |
| " Check that in the BufEnter autocommand events are being handled |
| augroup bufenterjob |
| autocmd! |
| autocmd BufEnter Xbufenterjob call s:HandleBufEnter() |
| augroup END |
| |
| only |
| split Xbufenterjob |
| wincmd p |
| redraw |
| |
| close |
| augroup bufenterjob |
| autocmd! |
| augroup END |
| endfunc |
| |
| func Test_job_start_with_invalid_argument() |
| call assert_fails('call job_start([0zff])', 'E976:') |
| endfunc |
| |
| " Test for the 'lsp' channel mode |
| func LspCb(chan, msg) |
| call add(g:lspNotif, a:msg) |
| endfunc |
| |
| func LspOtCb(chan, msg) |
| call add(g:lspOtMsgs, a:msg) |
| endfunc |
| |
| func LspTests(port) |
| " call ch_logfile('Xlspclient.log', 'w') |
| let ch = ch_open(s:localhost .. a:port, #{mode: 'lsp', callback: 'LspCb'}) |
| if ch_status(ch) == "fail" |
| call assert_report("Can't open the lsp channel") |
| return |
| endif |
| |
| " check for channel information |
| let info = ch_info(ch) |
| call assert_equal('LSP', info.sock_mode) |
| |
| " Evaluate an expression |
| let resp = ch_evalexpr(ch, #{method: 'simple-rpc', params: [10, 20]}) |
| call assert_false(empty(resp)) |
| call assert_equal(#{id: 1, jsonrpc: '2.0', result: 'simple-rpc'}, resp) |
| |
| " Evaluate an expression. While waiting for the response, a notification |
| " message is delivered. |
| let g:lspNotif = [] |
| let resp = ch_evalexpr(ch, #{method: 'rpc-with-notif', params: {'v': 10}}) |
| call assert_false(empty(resp)) |
| call assert_equal(#{id: 2, jsonrpc: '2.0', result: 'rpc-with-notif-resp'}, |
| \ resp) |
| call assert_equal([#{jsonrpc: '2.0', result: 'rpc-with-notif-notif'}], |
| \ g:lspNotif) |
| |
| " Wrong payload notification test |
| let g:lspNotif = [] |
| let r = ch_sendexpr(ch, #{method: 'wrong-payload', params: {}}) |
| call assert_equal({}, r) |
| " Send a ping to wait for all the notification messages to arrive |
| call assert_equal('alive', ch_evalexpr(ch, #{method: 'ping'}).result) |
| call assert_equal([#{jsonrpc: '2.0', result: 'wrong-payload'}], g:lspNotif) |
| |
| " Test for receiving a response with incorrect 'id' and additional |
| " notification messages while evaluating an expression. |
| let g:lspNotif = [] |
| let resp = ch_evalexpr(ch, #{method: 'rpc-resp-incorrect-id', |
| \ params: {'a': [1, 2]}}) |
| call assert_false(empty(resp)) |
| call assert_equal(#{id: 4, jsonrpc: '2.0', |
| \ result: 'rpc-resp-incorrect-id-4'}, resp) |
| call assert_equal([#{jsonrpc: '2.0', result: 'rpc-resp-incorrect-id-1'}, |
| \ #{jsonrpc: '2.0', result: 'rpc-resp-incorrect-id-2'}, |
| \ #{jsonrpc: '2.0', id: 1, result: 'rpc-resp-incorrect-id-3'}], |
| \ g:lspNotif) |
| |
| " simple notification test |
| let g:lspNotif = [] |
| call ch_sendexpr(ch, #{method: 'simple-notif', params: [#{a: 10, b: []}]}) |
| " Send a ping to wait for all the notification messages to arrive |
| call assert_equal('alive', ch_evalexpr(ch, #{method: 'ping'}).result) |
| call assert_equal([#{jsonrpc: '2.0', result: 'simple-notif'}], g:lspNotif) |
| |
| " multiple notifications test |
| let g:lspNotif = [] |
| call ch_sendexpr(ch, #{method: 'multi-notif', params: [#{a: {}, b: {}}]}) |
| " Send a ping to wait for all the notification messages to arrive |
| call assert_equal('alive', ch_evalexpr(ch, #{method: 'ping'}).result) |
| call assert_equal([#{jsonrpc: '2.0', result: 'multi-notif1'}, |
| \ #{jsonrpc: '2.0', result: 'multi-notif2'}], g:lspNotif) |
| |
| " Test for sending a message with an identifier. |
| let g:lspNotif = [] |
| call ch_sendexpr(ch, #{method: 'msg-with-id', id: 93, params: #{s: 'str'}}) |
| " Send a ping to wait for all the notification messages to arrive |
| call assert_equal('alive', ch_evalexpr(ch, #{method: 'ping'}).result) |
| call assert_equal([#{jsonrpc: '2.0', id: 93, result: 'msg-with-id'}], |
| \ g:lspNotif) |
| |
| " Test for setting the 'id' value in a request message |
| let resp = ch_evalexpr(ch, #{method: 'ping', id: 1, params: {}}) |
| call assert_equal(#{id: 8, jsonrpc: '2.0', result: 'alive'}, resp) |
| |
| " Test for using a one time callback function to process a response |
| let g:lspOtMsgs = [] |
| let r = ch_sendexpr(ch, #{method: 'msg-specifc-cb', params: {}}, |
| \ #{callback: 'LspOtCb'}) |
| call assert_equal(9, r.id) |
| call assert_equal('alive', ch_evalexpr(ch, #{method: 'ping'}).result) |
| call assert_equal([#{id: 9, jsonrpc: '2.0', result: 'msg-specifc-cb'}], |
| \ g:lspOtMsgs) |
| |
| " Test for generating a request message from the other end (server) |
| let g:lspNotif = [] |
| call ch_sendexpr(ch, #{method: 'server-req', params: #{}}) |
| call assert_equal('alive', ch_evalexpr(ch, #{method: 'ping'}).result) |
| call assert_equal([{'id': 201, 'jsonrpc': '2.0', |
| \ 'result': {'method': 'checkhealth', 'params': {'a': 20}}}], |
| \ g:lspNotif) |
| |
| " Test for sending a message without an id |
| let g:lspNotif = [] |
| call ch_sendexpr(ch, #{method: 'echo', params: #{s: 'msg-without-id'}}) |
| " Send a ping to wait for all the notification messages to arrive |
| call assert_equal('alive', ch_evalexpr(ch, #{method: 'ping'}).result) |
| call assert_equal([#{jsonrpc: '2.0', result: |
| \ #{method: 'echo', jsonrpc: '2.0', params: #{s: 'msg-without-id'}}}], |
| \ g:lspNotif) |
| |
| " Test for sending a notification message with an id |
| let g:lspNotif = [] |
| call ch_sendexpr(ch, #{method: 'echo', id: 110, params: #{s: 'msg-with-id'}}) |
| " Send a ping to wait for all the notification messages to arrive |
| call assert_equal('alive', ch_evalexpr(ch, #{method: 'ping'}).result) |
| call assert_equal([#{jsonrpc: '2.0', result: |
| \ #{method: 'echo', jsonrpc: '2.0', id: 110, |
| \ params: #{s: 'msg-with-id'}}}], g:lspNotif) |
| |
| " Test for processing the extra fields in the HTTP header |
| let resp = ch_evalexpr(ch, #{method: 'extra-hdr-fields', params: {}}) |
| call assert_equal({'id': 14, 'jsonrpc': '2.0', 'result': 'extra-hdr-fields'}, |
| \ resp) |
| |
| " Test for processing delayed payload |
| let resp = ch_evalexpr(ch, #{method: 'delayed-payload', params: {}}) |
| call assert_equal({'id': 15, 'jsonrpc': '2.0', 'result': 'delayed-payload'}, |
| \ resp) |
| |
| " Test for processing a HTTP header without the Content-Length field |
| let resp = ch_evalexpr(ch, #{method: 'hdr-without-len', params: {}}, |
| \ #{timeout: 200}) |
| call assert_equal({}, resp) |
| " send a ping to make sure communication still works |
| call assert_equal('alive', ch_evalexpr(ch, #{method: 'ping'}).result) |
| |
| " Test for processing a HTTP header with wrong length |
| let resp = ch_evalexpr(ch, #{method: 'hdr-with-wrong-len', params: {}}, |
| \ #{timeout: 200}) |
| call assert_equal({}, resp) |
| " send a ping to make sure communication still works |
| call assert_equal('alive', ch_evalexpr(ch, #{method: 'ping'}).result) |
| |
| " Test for processing a HTTP header with negative length |
| let resp = ch_evalexpr(ch, #{method: 'hdr-with-negative-len', params: {}}, |
| \ #{timeout: 200}) |
| call assert_equal({}, resp) |
| " send a ping to make sure communication still works |
| call assert_equal('alive', ch_evalexpr(ch, #{method: 'ping'}).result) |
| |
| " Test for an empty header |
| let resp = ch_evalexpr(ch, #{method: 'empty-header', params: {}}, |
| \ #{timeout: 200}) |
| call assert_equal({}, resp) |
| " send a ping to make sure communication still works |
| call assert_equal('alive', ch_evalexpr(ch, #{method: 'ping'}).result) |
| |
| " Test for an empty payload |
| let resp = ch_evalexpr(ch, #{method: 'empty-payload', params: {}}, |
| \ #{timeout: 200}) |
| call assert_equal({}, resp) |
| " send a ping to make sure communication still works |
| call assert_equal('alive', ch_evalexpr(ch, #{method: 'ping'}).result) |
| |
| " Test for a large payload |
| let content = repeat('abcdef', 11000) |
| let resp = ch_evalexpr(ch, #{method: 'large-payload', |
| \ params: #{text: content}}) |
| call assert_equal(#{jsonrpc: '2.0', id: 26, result: |
| \ #{method: 'large-payload', jsonrpc: '2.0', id: 26, |
| \ params: #{text: content}}}, resp) |
| " send a ping to make sure communication still works |
| call assert_equal('alive', ch_evalexpr(ch, #{method: 'ping'}).result) |
| |
| " Test for invoking an unsupported method |
| let resp = ch_evalexpr(ch, #{method: 'xyz', params: {}}, #{timeout: 200}) |
| call assert_equal({}, resp) |
| |
| " Test for sending a message without a callback function. Notification |
| " message should be dropped but RPC response should not be dropped. |
| call ch_setoptions(ch, #{callback: ''}) |
| let g:lspNotif = [] |
| call ch_sendexpr(ch, #{method: 'echo', params: #{s: 'no-callback'}}) |
| " Send a ping to wait for all the notification messages to arrive |
| call assert_equal('alive', ch_evalexpr(ch, #{method: 'ping'}).result) |
| call assert_equal([], g:lspNotif) |
| " Restore the callback function |
| call ch_setoptions(ch, #{callback: 'LspCb'}) |
| |
| " " Test for sending a raw message |
| " let g:lspNotif = [] |
| " let s = "Content-Length: 62\r\n" |
| " let s ..= "Content-Type: application/vim-jsonrpc; charset=utf-8\r\n" |
| " let s ..= "\r\n" |
| " let s ..= '{"method":"echo","jsonrpc":"2.0","params":{"m":"raw-message"}}' |
| " call ch_sendraw(ch, s) |
| " call ch_evalexpr(ch, #{method: 'ping'}) |
| " call assert_equal([{'jsonrpc': '2.0', |
| " \ 'result': {'method': 'echo', 'jsonrpc': '2.0', |
| " \ 'params': {'m': 'raw-message'}}}], g:lspNotif) |
| |
| " Invalid arguments to ch_evalexpr() and ch_sendexpr() |
| call assert_fails('call ch_sendexpr(ch, #{method: "cookie", id: "cookie"})', |
| \ 'E475:') |
| call assert_fails('call ch_evalexpr(ch, #{method: "ping", id: [{}]})', 'E475:') |
| call assert_fails('call ch_evalexpr(ch, [1, 2, 3])', 'E1206:') |
| call assert_fails('call ch_sendexpr(ch, "abc")', 'E1206:') |
| call assert_fails('call ch_evalexpr(ch, #{method: "ping"}, #{callback: "LspOtCb"})', 'E917:') |
| " call ch_logfile('', 'w') |
| endfunc |
| |
| func Test_channel_lsp_mode() |
| call RunServer('test_channel_lsp.py', 'LspTests', []) |
| endfunc |
| |
| " vim: shiftwidth=2 sts=2 expandtab |