refactor: format test/*

1 files changed, 44 insertions, 41 deletions

diff --git a/test/functional/vimscript/timer_spec.lua b/test/functional/vimscript/timer_spec.lua
index 93d88f6338..0293d30380 100644
--- a/test/functional/vimscript/timer_spec.lua
+++ b/test/functional/vimscript/timer_spec.lua
@@ -22,20 +22,20 @@ describe('timers', function()
   it('works one-shot', function()
     eq(0, eval("[timer_start(10, 'MyHandler'), g:val][1]"))
     run(nil, nil, nil, load_adjust(100))
-    eq(1,eval("g:val"))
+    eq(1, eval('g:val'))
   end)
 
   it('works one-shot when repeat=0', function()
     eq(0, eval("[timer_start(10, 'MyHandler', {'repeat': 0}), g:val][1]"))
     run(nil, nil, nil, load_adjust(100))
-    eq(1, eval("g:val"))
+    eq(1, eval('g:val'))
   end)
 
   it('works with repeat two', function()
     eq(0, eval("[timer_start(10, 'MyHandler', {'repeat': 2}), g:val][1]"))
     run(nil, nil, nil, load_adjust(20))
     retry(nil, load_adjust(300), function()
-      eq(2, eval("g:val"))
+      eq(2, eval('g:val'))
     end)
   end)
 
@@ -52,12 +52,12 @@ describe('timers', function()
       endfunc
     ]])
     eval("timer_start(10, 'MyHandler', {'repeat': -1})")
-    nvim_async("command", "sleep 10")
-    eq(-1, eval("g:val"))  -- timer did nothing yet.
-    nvim_async("command", "let g:val = 0")
+    nvim_async('command', 'sleep 10')
+    eq(-1, eval('g:val')) -- timer did nothing yet.
+    nvim_async('command', 'let g:val = 0')
     run(nil, nil, nil, load_adjust(20))
     retry(nil, nil, function()
-      eq(2, eval("g:val"))
+      eq(2, eval('g:val'))
     end)
   end)
 
@@ -65,52 +65,53 @@ describe('timers', function()
     -- timer_start does still not invoke the callback immediately
     eq(0, eval("[timer_start(0, 'MyHandler', {'repeat': 1000}), g:val][1]"))
     retry(nil, nil, function()
-      eq(1000, eval("g:val"))
+      eq(1000, eval('g:val'))
     end)
   end)
 
   it('can be started during sleep', function()
-    nvim_async("command", "sleep 10")
+    nvim_async('command', 'sleep 10')
     -- this also tests that remote requests works during sleep
     eq(0, eval("[timer_start(10, 'MyHandler', {'repeat': 2}), g:val][1]"))
     run(nil, nil, nil, load_adjust(20))
-    retry(nil, load_adjust(300), function() eq(2,eval("g:val")) end)
+    retry(nil, load_adjust(300), function()
+      eq(2, eval('g:val'))
+    end)
   end)
 
   it('are paused when event processing is disabled', function()
     command("call timer_start(5, 'MyHandler', {'repeat': -1})")
     run(nil, nil, nil, load_adjust(10))
-    local count = eval("g:val")
+    local count = eval('g:val')
     -- shows two line error message and thus invokes the return prompt.
     -- if we start to allow event processing here, we need to change this test.
     feed(':throw "fatal error"<CR>')
     run(nil, nil, nil, load_adjust(30))
-    feed("<cr>")
-    local diff = eval("g:val") - count
-    assert(0 <= diff and diff <= 4,
-           'expected (0 <= diff <= 4), got: '..tostring(diff))
+    feed('<cr>')
+    local diff = eval('g:val') - count
+    assert(0 <= diff and diff <= 4, 'expected (0 <= diff <= 4), got: ' .. tostring(diff))
   end)
 
   it('are triggered in blocking getchar() call', function()
     command("call timer_start(5, 'MyHandler', {'repeat': -1})")
-    nvim_async("command", "let g:val = 0 | let g:c = getchar()")
+    nvim_async('command', 'let g:val = 0 | let g:c = getchar()')
     retry(nil, nil, function()
-      local val = eval("g:val")
+      local val = eval('g:val')
       ok(val >= 2, '>= 2', tostring(val))
-      eq(0, eval("getchar(1)"))
+      eq(0, eval('getchar(1)'))
     end)
-    feed("c")
-    eq(99, eval("g:c"))
+    feed('c')
+    eq(99, eval('g:c'))
   end)
 
   it('can invoke redraw in blocking getchar() call', function()
     local screen = Screen.new(40, 6)
     screen:attach()
     screen:set_default_attr_ids({
-        [1] = {bold=true, foreground=Screen.colors.Blue},
+      [1] = { bold = true, foreground = Screen.colors.Blue },
     })
 
-    curbufmeths.set_lines(0, -1, true, {"ITEM 1", "ITEM 2"})
+    curbufmeths.set_lines(0, -1, true, { 'ITEM 1', 'ITEM 2' })
     source([[
       let g:cont = 0
       func! AddItem(timer)
@@ -127,8 +128,8 @@ describe('timers', function()
         redraw
       endfunc
     ]])
-    nvim_async("command", "let g:c2 = getchar()")
-    nvim_async("command", "call timer_start("..load_adjust(100)..", 'AddItem', {'repeat': -1})")
+    nvim_async('command', 'let g:c2 = getchar()')
+    nvim_async('command', 'call timer_start(' .. load_adjust(100) .. ", 'AddItem', {'repeat': -1})")
 
     screen:expect([[
       ^ITEM 1                                  |
@@ -136,7 +137,7 @@ describe('timers', function()
       {1:~                                       }|*3
                                               |
     ]])
-    nvim_async("command", "let g:cont = 1")
+    nvim_async('command', 'let g:cont = 1')
 
     screen:expect([[
       ^ITEM 1                                  |
@@ -146,15 +147,18 @@ describe('timers', function()
                                               |
     ]])
 
-    feed("3")
-    eq(51, eval("g:c2"))
-    screen:expect{grid=[[
+    feed('3')
+    eq(51, eval('g:c2'))
+    screen:expect {
+      grid = [[
       ^ITEM 1                                  |
       ITEM 2                                  |
       ITEM 3                                  |
       {1:~                                       }|*2
                                               |
-    ]], unchanged=true}
+    ]],
+      unchanged = true,
+    }
   end)
 
   it('can be stopped', function()
@@ -162,9 +166,9 @@ describe('timers', function()
     eq(0, t_init_val[2])
     run(nil, nil, nil, load_adjust(30))
     funcs.timer_stop(t_init_val[1])
-    local count = eval("g:val")
+    local count = eval('g:val')
     run(nil, load_adjust(300), nil, load_adjust(30))
-    local count2 = eval("g:val")
+    local count2 = eval('g:val')
     -- when count is eval:ed after timer_stop this should be non-racy
     eq(count, count2)
   end)
@@ -180,10 +184,10 @@ describe('timers', function()
         endif
       endfunc
     ]])
-    eq(0, eval("g:val"))
+    eq(0, eval('g:val'))
     command("call timer_start(10, 'MyHandler', {'repeat': -1})")
     retry(nil, nil, function()
-      eq(3, eval("g:val"))
+      eq(3, eval('g:val'))
     end)
   end)
 
@@ -197,8 +201,8 @@ describe('timers', function()
     command("call timer_start(2, 'MyHandler',  {'repeat': 3})")
     command("call timer_start(4, 'MyHandler2', {'repeat': 2})")
     retry(nil, nil, function()
-      eq(3, eval("g:val"))
-      eq(2, eval("g:val2"))
+      eq(3, eval('g:val'))
+      eq(2, eval('g:val2'))
     end)
   end)
 
@@ -214,15 +218,14 @@ describe('timers', function()
     command("call timer_start(5, 'MyHandler', {'repeat': 1})")
     run(nil, nil, nil, load_adjust(20))
     retry(nil, load_adjust(150), function()
-      eq(1, eval("g:val"))
+      eq(1, eval('g:val'))
     end)
   end)
 
-
   it("doesn't mess up the cmdline", function()
     local screen = Screen.new(40, 6)
     screen:attach()
-    screen:set_default_attr_ids( {[0] = {bold=true, foreground=255}} )
+    screen:set_default_attr_ids({ [0] = { bold = true, foreground = 255 } })
     source([[
       let g:val = 0
       func! MyHandler(timer)
@@ -237,7 +240,7 @@ describe('timers', function()
       endfunc
     ]])
     command("call timer_start(100,  'MyHandler', {'repeat': -1})")
-    feed(":good")
+    feed(':good')
     screen:expect([[
                                               |
       {0:~                                       }|*4
@@ -255,7 +258,7 @@ describe('timers', function()
         call execute('echo ''execute() should be disallowed''', '')
       endfunction
     ]]
-    eq("Vim(call):E48: Not allowed in sandbox", exc_exec("sandbox call timer_start(0, 'Scary')"))
+    eq('Vim(call):E48: Not allowed in sandbox', exc_exec("sandbox call timer_start(0, 'Scary')"))
   end)
 
   it('can be triggered after an empty string <expr> mapping #17257', function()
@@ -263,6 +266,6 @@ describe('timers', function()
     screen:attach()
     command([=[imap <expr> <F2> [timer_start(0, { _ -> execute("throw 'x'", "") }), ''][-1]]=])
     feed('i<F2>')
-    screen:expect({any='E605: Exception not caught: x'})
+    screen:expect({ any = 'E605: Exception not caught: x' })
   end)
 end)