" Functions shared by several tests.

" Get the name of the Python executable.
" Also keeps it in s:python.
func PythonProg()
 " This test requires the Python command to run the test server.
 " This most likely only works on Unix and Windows.
 if has('unix')
 " We also need the job feature or the pkill command to make sure the server
 " can be stopped.
 if !(executable('python') && (has('job') || executable('pkill')))
 return ''
 endif
 let s:python = 'python'
 elseif has('win32')
 " Use Python Launcher for Windows (py.exe) if available.
 if executable('py.exe')
 let s:python = 'py.exe'
 elseif executable('python.exe')
 let s:python = 'python.exe'
 else
 return ''
 endif
 else
 return ''
 endif
 return s:python
endfunc

" Run "cmd". Returns the job if using a job.
func RunCommand(cmd)
 let job = 0
 if has('job')
 let job = job_start(a:cmd, {"stoponexit": "hup"})
 call job_setoptions(job, {"stoponexit": "kill"})
 elseif has('win32')
 exe 'silent !start cmd /c start "test_channel" ' . a:cmd
 else
 exe 'silent !' . a:cmd . '&'
 endif
 return job
endfunc

" Read the port number from the Xportnr file.
func GetPort()
 let l = []
 for i in range(200)
 try
 let l = readfile("Xportnr")
 catch
 endtry
 if len(l) >= 1
 break
 endif
 sleep 10m
 endfor
 call delete("Xportnr")

 if len(l) == 0
 " Can't make the connection, give up.
 return 0
 endif
 return l[0]
endfunc

" Run a Python server for "cmd" and call "testfunc".
" Always kills the server before returning.
func RunServer(cmd, testfunc, args)
 " The Python program writes the port number in Xportnr.
 call delete("Xportnr")

 if len(a:args) == 1
 let arg = ' ' . a:args[0]
 else
 let arg = ''
 endif
 let pycmd = s:python . " " . a:cmd . arg

 try
 let g:currentJob = RunCommand(pycmd)

 " Wait for up to 2 seconds for the port number to be there.
 let port = GetPort()
 if port == 0
 call assert_false(1, "Can't start " . a:cmd)
 return
 endif

 call call(function(a:testfunc), [port])
 catch
 call assert_false(1, 'Caught exception: "' . v:exception . '" in ' . v:throwpoint)
 finally
 call s:kill_server(a:cmd)
 endtry
endfunc

func s:kill_server(cmd)
 if has('job')
 if exists('g:currentJob')
 call job_stop(g:currentJob)
 unlet g:currentJob
 endif
 elseif has('win32')
 let cmd = substitute(a:cmd, ".py", '', '')
 call system('taskkill /IM ' . s:python . ' /T /F /FI "WINDOWTITLE eq ' . cmd . '"')
 else
 call system("pkill -f " . a:cmd)
 endif
endfunc

" Wait for up to a second for "expr" to become true.
" Return time slept in milliseconds. With the +reltime feature this can be
" more than the actual waiting time. Without +reltime it can also be less.
func WaitFor(expr)
 " using reltime() is more accurate, but not always available
 if has('reltime')
 let start = reltime()
 else
 let slept = 0
 endif
 for i in range(100)
 try
 if eval(a:expr)
	if has('reltime')
	 return float2nr(reltimefloat(reltime(start)) * 1000)
	endif
	return slept
 endif
 catch
 endtry
 if !has('reltime')
 let slept += 10
 endif
 sleep 10m
 endfor
 return 1000
endfunc

" Wait for up to a given milliseconds.
" With the +timers feature this waits for key-input by getchar(), Resume()
" feeds key-input and resumes process. Return time waited in milliseconds.
" Without +timers it uses simply :sleep.
func Standby(msec)
 if has('timers')
 let start = reltime()
 let g:_standby_timer = timer_start(a:msec, function('s:feedkeys'))
 call getchar()
 return float2nr(reltimefloat(reltime(start)) * 1000)
 else
 execute 'sleep ' a:msec . 'm'
 return a:msec
 endif
endfunc

func Resume()
 if exists('g:_standby_timer')
 call timer_stop(g:_standby_timer)
 call s:feedkeys(0)
 unlet g:_standby_timer
 endif
endfunc

func s:feedkeys(timer)
 call feedkeys('x', 'nt')
endfunc

" Run Vim, using the "vimcmd" file and "-u NORC".
" "before" is a list of Vim commands to be executed before loading plugins.
" "after" is a list of Vim commands to be executed after loading plugins.
" Plugins are not loaded, unless 'loadplugins' is set in "before".
" Return 1 if Vim could be executed.
func RunVim(before, after, arguments)
 return RunVimPiped(a:before, a:after, a:arguments, '')
endfunc

func RunVimPiped(before, after, arguments, pipecmd)
 if !filereadable('vimcmd')
 return 0
 endif
 let args = ''
 if len(a:before) > 0
 call writefile(a:before, 'Xbefore.vim')
 let args .= ' --cmd "so Xbefore.vim"'
 endif
 if len(a:after) > 0
 call writefile(a:after, 'Xafter.vim')
 let args .= ' -S Xafter.vim'
 endif

 let cmd = readfile('vimcmd')[0]
 let cmd = substitute(cmd, '-u \f\+', '-u NONE', '')
 if cmd !~ '-u NONE'
 let cmd = cmd . ' -u NONE'
 endif

 " With pipecmd we can't set VIMRUNTIME.
 if a:pipecmd != ''
 let cmd = substitute(cmd, 'VIMRUNTIME=.*VIMRUNTIME;', '', '')
 endif

 exe "silent !" . a:pipecmd . cmd . args . ' ' . a:arguments

 if len(a:before) > 0
 call delete('Xbefore.vim')
 endif
 if len(a:after) > 0
 call delete('Xafter.vim')
 endif
 return 1
endfunc