Adding upstream version 2:9.0.1378.upstream/2%9.0.1378upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 544 insertions, 0 deletions

diff --git a/src/testdir/test_timers.vim b/src/testdir/test_timers.vim
new file mode 100644
index 0000000..fe80bb9
--- /dev/null
+++ b/src/testdir/test_timers.vim
@@ -0,0 +1,544 @@
+" Test for timers
+
+source check.vim
+CheckFeature timers
+
+source screendump.vim
+source shared.vim
+source term_util.vim
+
+func MyHandler(timer)
+  let g:val += 1
+endfunc
+
+func MyHandlerWithLists(lists, timer)
+  let x = string(a:lists)
+endfunc
+
+func Test_timer_oneshot()
+  let g:test_is_flaky = 1
+  let g:val = 0
+  let timer = timer_start(50, 'MyHandler')
+  let slept = WaitFor('g:val == 1')
+  call assert_equal(1, g:val)
+  if has('mac')
+    " Mac on Travis can be very slow.
+    let limit = 180
+  else
+    let limit = 100
+  endif
+  if has('reltime')
+    call assert_inrange(49, limit, slept)
+  else
+    call assert_inrange(20, limit, slept)
+  endif
+endfunc
+
+func Test_timer_repeat_three()
+  let g:test_is_flaky = 1
+  let g:val = 0
+  let timer = timer_start(50, 'MyHandler', {'repeat': 3})
+  let slept = WaitFor('g:val == 3')
+  call assert_equal(3, g:val)
+  if has('reltime')
+    if has('mac')
+      " Mac on Travis can be slow.
+      call assert_inrange(149, 400, slept)
+    else
+      call assert_inrange(149, 250, slept)
+    endif
+  else
+    call assert_inrange(80, 200, slept)
+  endif
+endfunc
+
+func Test_timer_repeat_many()
+  let g:test_is_flaky = 1
+  let g:val = 0
+  let timer = timer_start(50, 'MyHandler', {'repeat': -1})
+  sleep 200m
+  call timer_stop(timer)
+  " Mac on Travis can be slow.
+  if has('mac')
+    call assert_inrange(1, 5, g:val)
+  else
+    call assert_inrange(2, 5, g:val)
+  endif
+endfunc
+
+func Test_timer_with_partial_callback()
+  let g:test_is_flaky = 1
+  let g:val = 0
+  let meow = {'one': 1}
+  function meow.bite(...)
+    let g:val += self.one
+  endfunction
+
+  call timer_start(50, meow.bite)
+  let slept = WaitFor('g:val == 1')
+  call assert_equal(1, g:val)
+  if has('reltime')
+    " Mac on Travis can be slow.
+    if has('mac')
+      call assert_inrange(49, 180, slept)
+    else
+      call assert_inrange(49, 130, slept)
+    endif
+  else
+    call assert_inrange(20, 100, slept)
+  endif
+endfunc
+
+func Test_timer_retain_partial()
+  call timer_start(50, function('MyHandlerWithLists', [['a']]))
+  call test_garbagecollect_now()
+  sleep 100m
+endfunc
+
+func Test_timer_info()
+  let id = timer_start(1000, 'MyHandler')
+  let info = id->timer_info()
+  call assert_equal(id, info[0]['id'])
+  call assert_equal(1000, info[0]['time'])
+  call assert_true(info[0]['remaining'] > 500)
+  call assert_true(info[0]['remaining'] <= 1000)
+  call assert_equal(1, info[0]['repeat'])
+  call assert_equal("function('MyHandler')", string(info[0]['callback']))
+
+  let found = 0
+  for info in timer_info()
+    if info['id'] == id
+      let found += 1
+    endif
+  endfor
+  call assert_equal(1, found)
+
+  call timer_stop(id)
+  call assert_equal([], timer_info(id))
+
+  call assert_fails('call timer_info("abc")', 'E1210:')
+
+  " check repeat count inside the callback
+  let g:timer_repeat = []
+  let tid = timer_start(10, {tid -> execute("call add(g:timer_repeat, timer_info(tid)[0].repeat)")}, #{repeat: 3})
+  call WaitForAssert({-> assert_equal([2, 1, 0], g:timer_repeat)})
+  unlet g:timer_repeat
+endfunc
+
+func Test_timer_stopall()
+  let id1 = timer_start(1000, 'MyHandler')
+  let id2 = timer_start(2000, 'MyHandler')
+  let info = timer_info()
+  " count one for the TestTimeout() timer
+  call assert_equal(3, len(info))
+
+  call timer_stopall()
+  let info = timer_info()
+  call assert_equal(0, len(info))
+endfunc
+
+def Test_timer_stopall_with_popup()
+  # Create a popup that times out after ten seconds.
+  # Another timer will fire in half a second and close it early after stopping
+  # all timers.
+  var pop = popup_create('Popup', {time: 10000})
+  var tmr = timer_start(500, (_) => {
+    timer_stopall()
+    popup_clear()
+  })
+  sleep 1
+  assert_equal([], timer_info(tmr))
+  assert_equal([], popup_list())
+enddef
+
+func Test_timer_paused()
+  let g:test_is_flaky = 1
+  let g:val = 0
+
+  let id = timer_start(50, 'MyHandler')
+  let info = timer_info(id)
+  call assert_equal(0, info[0]['paused'])
+
+  eval id->timer_pause(1)
+  let info = timer_info(id)
+  call assert_equal(1, info[0]['paused'])
+  sleep 100m
+  call assert_equal(0, g:val)
+
+  call timer_pause(id, 0)
+  let info = timer_info(id)
+  call assert_equal(0, info[0]['paused'])
+
+  let slept = WaitFor('g:val == 1')
+  call assert_equal(1, g:val)
+  if has('reltime')
+    if has('mac')
+      " The travis Mac machines appear to be very busy.
+      call assert_inrange(0, 90, slept)
+    else
+      call assert_inrange(0, 30, slept)
+    endif
+  else
+    call assert_inrange(0, 10, slept)
+  endif
+
+  call assert_fails('call timer_pause("abc", 1)', 'E39:')
+endfunc
+
+func StopMyself(timer)
+  let g:called += 1
+  if g:called == 2
+    call timer_stop(a:timer)
+  endif
+endfunc
+
+func Test_timer_delete_myself()
+  let g:called = 0
+  let t = timer_start(10, 'StopMyself', {'repeat': -1})
+  call WaitForAssert({-> assert_equal(2, g:called)})
+  call assert_equal(2, g:called)
+  call assert_equal([], timer_info(t))
+endfunc
+
+func StopTimer1(timer)
+  let g:timer2 = 10->timer_start('StopTimer2')
+  " avoid maxfuncdepth error
+  call timer_pause(g:timer1, 1)
+  sleep 20m
+endfunc
+
+func StopTimer2(timer)
+  call timer_stop(g:timer1)
+endfunc
+
+func Test_timer_stop_in_callback()
+  let g:test_is_flaky = 1
+  call assert_equal(1, len(timer_info()))
+  let g:timer1 = timer_start(10, 'StopTimer1')
+  let slept = 0
+  for i in range(10)
+    if len(timer_info()) == 1
+      break
+    endif
+    sleep 10m
+    let slept += 10
+  endfor
+  if slept == 100
+    call assert_equal(1, len(timer_info()))
+  else
+    " This should take only 30 msec, but on Mac it's often longer
+    call assert_inrange(0, 50, slept)
+  endif
+endfunc
+
+func StopTimerAll(timer)
+  call timer_stopall()
+endfunc
+
+func Test_timer_stop_all_in_callback()
+  let g:test_is_flaky = 1
+  " One timer is for TestTimeout()
+  call assert_equal(1, len(timer_info()))
+  call timer_start(10, 'StopTimerAll')
+  call assert_equal(2, len(timer_info()))
+  let slept = 0
+  for i in range(10)
+    if len(timer_info()) == 0
+      break
+    endif
+    sleep 10m
+    let slept += 10
+  endfor
+  if slept == 100
+    call assert_equal(0, len(timer_info()))
+  else
+    call assert_inrange(0, 30, slept)
+  endif
+endfunc
+
+func FeedkeysCb(timer)
+  call feedkeys("hello\<CR>", 'nt')
+endfunc
+
+func InputCb(timer)
+  call timer_start(10, 'FeedkeysCb')
+  let g:val = input('?')
+  call Resume()
+endfunc
+
+func Test_timer_input_in_timer()
+  let g:val = ''
+  call timer_start(10, 'InputCb')
+  call Standby(1000)
+  call assert_equal('hello', g:val)
+endfunc
+
+func FuncWithError(timer)
+  let g:call_count += 1
+  if g:call_count == 4
+    return
+  endif
+  doesnotexist
+endfunc
+
+func Test_timer_errors()
+  let g:call_count = 0
+  let timer = timer_start(10, 'FuncWithError', {'repeat': -1})
+  " Timer will be stopped after failing 3 out of 3 times.
+  call WaitForAssert({-> assert_equal(3, g:call_count)})
+  sleep 50m
+  call assert_equal(3, g:call_count)
+
+  call assert_fails('call timer_start(100, "MyHandler", "abc")', 'E1206:')
+  call assert_fails('call timer_start(100, [])', 'E921:')
+  call assert_fails('call timer_stop("abc")', 'E1210:')
+endfunc
+
+func FuncWithCaughtError(timer)
+  let g:call_count += 1
+  try
+    doesnotexist
+  catch
+    " nop
+  endtry
+endfunc
+
+func Test_timer_catch_error()
+  let g:call_count = 0
+  let timer = timer_start(10, 'FuncWithCaughtError', {'repeat': 4})
+  " Timer will not be stopped.
+  call WaitForAssert({-> assert_equal(4, g:call_count)})
+  sleep 50m
+  call assert_equal(4, g:call_count)
+endfunc
+
+func FeedAndPeek(timer)
+  call test_feedinput('a')
+  call getchar(1)
+endfunc
+
+func Interrupt(timer)
+  eval "\<C-C>"->test_feedinput()
+endfunc
+
+func Test_timer_peek_and_get_char()
+  if !has('unix') && !has('gui_running')
+    throw 'Skipped: cannot feed low-level input'
+  endif
+
+  call timer_start(0, 'FeedAndPeek')
+  let intr = timer_start(100, 'Interrupt')
+  let c = getchar()
+  call assert_equal(char2nr('a'), c)
+  eval intr->timer_stop()
+endfunc
+
+func Test_timer_getchar_zero()
+  if has('win32') && !has('gui_running')
+    throw 'Skipped: cannot feed low-level input'
+  endif
+  CheckFunction reltimefloat
+
+  " Measure the elapsed time to avoid a hang when it fails.
+  let start = reltime()
+  let id = timer_start(20, {-> feedkeys('x', 'L')})
+  let c = 0
+  while c == 0 && reltimefloat(reltime(start)) < 0.2
+    let c = getchar(0)
+    sleep 10m
+  endwhile
+  call assert_equal('x', nr2char(c))
+  call timer_stop(id)
+endfunc
+
+func Test_timer_ex_mode()
+  " Function with an empty line.
+  func Foo(...)
+
+  endfunc
+  let timer = timer_start(40, function('g:Foo'), {'repeat':-1})
+  " This used to throw error E749.
+  exe "normal Qsleep 100m\rvi\r"
+  call timer_stop(timer)
+endfunc
+
+func Test_timer_restore_count()
+  CheckRunVimInTerminal
+  " Check that v:count is saved and restored, not changed by a timer.
+  call writefile([
+        \ 'nnoremap <expr><silent> L v:count ? v:count . "l" : "l"',
+        \ 'func Doit(id)',
+        \ '  normal 3j',
+        \ 'endfunc',
+        \ 'call timer_start(100, "Doit")',
+	\ ], 'Xtrcscript', 'D')
+  call writefile([
+        \ '1-1234',
+        \ '2-1234',
+        \ '3-1234',
+	\ ], 'Xtrctext', 'D')
+  let buf = RunVimInTerminal('-S Xtrcscript Xtrctext', {})
+
+  " Wait for the timer to move the cursor to the third line.
+  call WaitForAssert({-> assert_equal(3, term_getcursor(buf)[0])})
+  call assert_equal(1, term_getcursor(buf)[1])
+  " Now check that v:count has not been set to 3
+  call term_sendkeys(buf, 'L')
+  call WaitForAssert({-> assert_equal(2, term_getcursor(buf)[1])})
+
+  call StopVimInTerminal(buf)
+endfunc
+
+" Test that the garbage collector isn't triggered if a timer callback invokes
+" vgetc().
+func Test_nocatch_timer_garbage_collect()
+  " FIXME: why does this fail only on MacOS M1?
+  try
+    CheckNotMacM1
+  catch /Skipped/
+    let g:skipped_reason = v:exception
+    return
+  endtry
+
+  " 'uptimetime. must be bigger than the timer timeout
+  set ut=200
+  call test_garbagecollect_soon()
+  call test_override('no_wait_return', 0)
+  func CauseAnError(id)
+    " This will show an error and wait for Enter.
+    let a = {'foo', 'bar'}
+  endfunc
+  func FeedChar(id)
+    call feedkeys(":\<CR>", 't')
+  endfunc
+  call timer_start(300, 'FeedChar')
+  call timer_start(100, 'CauseAnError')
+  let x = getchar()   " wait for error in timer
+  let x = getchar(0)  " read any remaining chars
+  let x = getchar(0)
+
+  set ut&
+  call test_override('no_wait_return', 1)
+  delfunc CauseAnError
+  delfunc FeedChar
+endfunc
+
+func Test_timer_error_in_timer_callback()
+  if !has('terminal') || (has('win32') && has('gui_running'))
+    throw 'Skipped: cannot run Vim in a terminal window'
+  endif
+
+  let lines =<< trim [CODE]
+  func Func(timer)
+    " fail to create list
+    let x = [
+  endfunc
+  set updatetime=50
+  call timer_start(1, 'Func')
+  [CODE]
+  call writefile(lines, 'Xtest.vim', 'D')
+
+  let buf = term_start(GetVimCommandCleanTerm() .. ' -S Xtest.vim', {'term_rows': 8})
+  let job = term_getjob(buf)
+  call WaitForAssert({-> assert_notequal('', term_getline(buf, 8))})
+
+  " GC must not run during timer callback, which can make Vim crash.
+  call TermWait(buf, 50)
+  call term_sendkeys(buf, "\<CR>")
+  call TermWait(buf, 50)
+  call assert_equal('run', job_status(job))
+
+  call term_sendkeys(buf, ":qall!\<CR>")
+  call WaitFor({-> job_status(job) ==# 'dead'})
+  if has('unix')
+    call assert_equal('', job_info(job).termsig)
+  endif
+
+  exe buf .. 'bwipe!'
+endfunc
+
+" Test for garbage collection when a timer is still running
+func Test_timer_garbage_collect()
+  let timer = timer_start(1000, function('MyHandler'), {'repeat' : 10})
+  call test_garbagecollect_now()
+  let l = timer_info(timer)
+  call assert_equal(function('MyHandler'), l[0].callback)
+  call timer_stop(timer)
+endfunc
+
+func Test_timer_invalid_callback()
+  call assert_fails('call timer_start(0, "0")', 'E921:')
+endfunc
+
+func Test_timer_changing_function_list()
+  CheckRunVimInTerminal
+
+  " Create a large number of functions.  Should get the "more" prompt.
+  " The typing "G" triggers the timer, which changes the function table.
+  let lines =<< trim END
+    for func in map(range(1,99), "'Func' .. v:val")
+      exe "func " .. func .. "()"
+      endfunc
+    endfor
+    au CmdlineLeave : call timer_start(0, {-> 0})
+  END
+  call writefile(lines, 'XTest_timerchange', 'D')
+  let buf = RunVimInTerminal('-S XTest_timerchange', #{rows: 10})
+  call term_sendkeys(buf, ":fu\<CR>")
+  call WaitForAssert({-> assert_match('-- More --', term_getline(buf, 10))})
+  call term_sendkeys(buf, "G")
+  call WaitForAssert({-> assert_match('E454:', term_getline(buf, 9))})
+  call term_sendkeys(buf, "\<Esc>")
+
+  call StopVimInTerminal(buf)
+endfunc
+
+func Test_timer_outputting_message()
+  CheckRunVimInTerminal
+
+  let lines =<< trim END
+    vim9script
+    setline(1, 'some text')
+    set showcmd ut=2000 cmdheight=1
+    timer_start(0, (_) => {
+            echon repeat('x', &columns - 11)
+        })
+  END
+  call writefile(lines, 'XTest_timermessage', 'D')
+  let buf = RunVimInTerminal('-S XTest_timermessage', #{rows: 6})
+  call term_sendkeys(buf, "l")
+  call term_wait(buf)
+  " should not get a hit-enter prompt
+  call WaitForAssert({-> assert_match('xxxxxxxxxxx', term_getline(buf, 6))})
+
+  call StopVimInTerminal(buf)
+endfunc
+
+func Test_timer_using_win_execute_undo_sync()
+  " FIXME: why does this fail only on MacOS M1?
+  CheckNotMacM1
+
+  let bufnr1 = bufnr()
+  new
+  let g:bufnr2 = bufnr()
+  let g:winid = win_getid()
+  exe "buffer " .. bufnr1
+  wincmd w
+  call setline(1, ['test'])
+  autocmd InsertEnter * call timer_start(100, { -> win_execute(g:winid, 'buffer ' .. g:bufnr2) })
+  call timer_start(200, { -> feedkeys("\<CR>bbbb\<Esc>") })
+  call feedkeys("Oaaaa", 'x!t')
+  " will hang here until the second timer fires
+  call assert_equal(['aaaa', 'bbbb', 'test'], getline(1, '$'))
+  undo
+  call assert_equal(['test'], getline(1, '$'))
+
+  bwipe!
+  bwipe!
+  unlet g:winid
+  unlet g:bufnr2
+  au! InsertEnter
+endfunc
+
+
+" vim: shiftwidth=2 sts=2 expandtab