refactor: format test/*

1 files changed, 558 insertions, 404 deletions

diff --git a/test/functional/api/autocmd_spec.lua b/test/functional/api/autocmd_spec.lua
index fd46a1dcfa..1590ca2eda 100644
--- a/test/functional/api/autocmd_spec.lua
+++ b/test/functional/api/autocmd_spec.lua
@@ -15,43 +15,74 @@ before_each(clear)
 describe('autocmd api', function()
   describe('nvim_create_autocmd', function()
     it('validation', function()
-      eq("Cannot use both 'callback' and 'command'", pcall_err(meths.create_autocmd, 'BufReadPost', {
-        pattern = '*.py,*.pyi',
-        command = "echo 'Should Have Errored",
-        callback = 'NotAllowed',
-      }))
-      eq("Cannot use both 'pattern' and 'buffer' for the same autocmd", pcall_err(meths.create_autocmd, 'FileType', {
-        command = 'let g:called = g:called + 1',
-        buffer = 0,
-        pattern = '*.py',
-      }))
-      eq("Required: 'event'", pcall_err(meths.create_autocmd, {}, {
-        command = 'ls',
-      }))
-      eq("Required: 'command' or 'callback'", pcall_err(meths.create_autocmd, 'FileType', {
-      }))
-      eq("Invalid 'desc': expected String, got Integer", pcall_err(meths.create_autocmd, 'FileType', {
-        command = 'ls',
-        desc = 42,
-      }))
-      eq("Invalid 'callback': expected Lua function or Vim function name, got Integer", pcall_err(meths.create_autocmd, 'FileType', {
-        callback = 0,
-      }))
-      eq("Invalid 'event' item: expected String, got Array", pcall_err(meths.create_autocmd,
-        {'FileType', {}}, {}))
-      eq("Invalid 'group': 0", pcall_err(meths.create_autocmd, 'FileType', {
-        group = 0,
-        command = 'ls',
-      }))
+      eq(
+        "Cannot use both 'callback' and 'command'",
+        pcall_err(meths.create_autocmd, 'BufReadPost', {
+          pattern = '*.py,*.pyi',
+          command = "echo 'Should Have Errored",
+          callback = 'NotAllowed',
+        })
+      )
+      eq(
+        "Cannot use both 'pattern' and 'buffer' for the same autocmd",
+        pcall_err(meths.create_autocmd, 'FileType', {
+          command = 'let g:called = g:called + 1',
+          buffer = 0,
+          pattern = '*.py',
+        })
+      )
+      eq(
+        "Required: 'event'",
+        pcall_err(meths.create_autocmd, {}, {
+          command = 'ls',
+        })
+      )
+      eq("Required: 'command' or 'callback'", pcall_err(meths.create_autocmd, 'FileType', {}))
+      eq(
+        "Invalid 'desc': expected String, got Integer",
+        pcall_err(meths.create_autocmd, 'FileType', {
+          command = 'ls',
+          desc = 42,
+        })
+      )
+      eq(
+        "Invalid 'callback': expected Lua function or Vim function name, got Integer",
+        pcall_err(meths.create_autocmd, 'FileType', {
+          callback = 0,
+        })
+      )
+      eq(
+        "Invalid 'event' item: expected String, got Array",
+        pcall_err(meths.create_autocmd, { 'FileType', {} }, {})
+      )
+      eq(
+        "Invalid 'group': 0",
+        pcall_err(meths.create_autocmd, 'FileType', {
+          group = 0,
+          command = 'ls',
+        })
+      )
 
       eq("Invalid 'event': 'foo'", pcall_err(meths.create_autocmd, 'foo', { command = '' }))
-      eq("Invalid 'event': 'VimEnter '", pcall_err(meths.create_autocmd, 'VimEnter ', { command = '' }))
-      eq("Invalid 'event': 'VimEnter foo'", pcall_err(meths.create_autocmd, 'VimEnter foo', { command = '' }))
-      eq("Invalid 'event': 'BufAdd,BufDelete'", pcall_err(meths.create_autocmd, 'BufAdd,BufDelete', { command = '' }))
+      eq(
+        "Invalid 'event': 'VimEnter '",
+        pcall_err(meths.create_autocmd, 'VimEnter ', { command = '' })
+      )
+      eq(
+        "Invalid 'event': 'VimEnter foo'",
+        pcall_err(meths.create_autocmd, 'VimEnter foo', { command = '' })
+      )
+      eq(
+        "Invalid 'event': 'BufAdd,BufDelete'",
+        pcall_err(meths.create_autocmd, 'BufAdd,BufDelete', { command = '' })
+      )
     end)
 
     it('doesnt leak when you use ++once', function()
-      eq(1, exec_lua([[
+      eq(
+        1,
+        exec_lua(
+          [[
         local count = 0
 
         vim.api.nvim_create_autocmd("FileType", {
@@ -64,30 +95,33 @@ describe('autocmd api', function()
         vim.cmd "set filetype=python"
 
         return count
-      ]], {}))
+      ]],
+          {}
+        )
+      )
     end)
 
     it('allows passing buffer by key', function()
       meths.set_var('called', 0)
 
-      meths.create_autocmd("FileType", {
-        command = "let g:called = g:called + 1",
+      meths.create_autocmd('FileType', {
+        command = 'let g:called = g:called + 1',
         buffer = 0,
       })
 
-      meths.command "set filetype=txt"
+      meths.command 'set filetype=txt'
       eq(1, meths.get_var('called'))
 
       -- switch to a new buffer
-      meths.command "new"
-      meths.command "set filetype=python"
+      meths.command 'new'
+      meths.command 'set filetype=python'
 
       eq(1, meths.get_var('called'))
     end)
 
     it('does not allow passing invalid buffers', function()
       local ok, msg = pcall(meths.create_autocmd, 'FileType', {
-        command = "let g:called = g:called + 1",
+        command = 'let g:called = g:called + 1',
         buffer = -1,
       })
 
@@ -96,55 +130,61 @@ describe('autocmd api', function()
     end)
 
     it('errors on non-functions for cb', function()
-      eq(false, pcall(exec_lua, [[
+      eq(
+        false,
+        pcall(
+          exec_lua,
+          [[
         vim.api.nvim_create_autocmd("BufReadPost", {
           pattern = "*.py,*.pyi",
           callback = 5,
         })
-      ]]))
+      ]]
+        )
+      )
     end)
 
     it('allow passing pattern and <buffer> in same pattern', function()
-      local ok = pcall(meths.create_autocmd, "BufReadPost", {
-        pattern = "*.py,<buffer>",
-        command = "echo 'Should Not Error'"
+      local ok = pcall(meths.create_autocmd, 'BufReadPost', {
+        pattern = '*.py,<buffer>',
+        command = "echo 'Should Not Error'",
       })
 
       eq(true, ok)
     end)
 
     it('should handle multiple values as comma separated list', function()
-      meths.create_autocmd("BufReadPost", {
-        pattern = "*.py,*.pyi",
-        command = "echo 'Should Not Have Errored'"
+      meths.create_autocmd('BufReadPost', {
+        pattern = '*.py,*.pyi',
+        command = "echo 'Should Not Have Errored'",
       })
 
       -- We should have one autocmd for *.py and one for *.pyi
-      eq(2, #meths.get_autocmds { event = "BufReadPost" })
+      eq(2, #meths.get_autocmds { event = 'BufReadPost' })
     end)
 
     it('should handle multiple values as array', function()
-      meths.create_autocmd("BufReadPost", {
-        pattern = { "*.py", "*.pyi", },
-        command = "echo 'Should Not Have Errored'"
+      meths.create_autocmd('BufReadPost', {
+        pattern = { '*.py', '*.pyi' },
+        command = "echo 'Should Not Have Errored'",
       })
 
       -- We should have one autocmd for *.py and one for *.pyi
-      eq(2, #meths.get_autocmds { event = "BufReadPost" })
+      eq(2, #meths.get_autocmds { event = 'BufReadPost' })
     end)
 
     describe('desc', function()
       it('can add description to one autocmd', function()
-        local cmd =  "echo 'Should Not Have Errored'"
-        local desc =  "Can show description"
-        meths.create_autocmd("BufReadPost", {
-          pattern = "*.py",
+        local cmd = "echo 'Should Not Have Errored'"
+        local desc = 'Can show description'
+        meths.create_autocmd('BufReadPost', {
+          pattern = '*.py',
           command = cmd,
           desc = desc,
         })
 
-        eq(desc, meths.get_autocmds { event = "BufReadPost" }[1].desc)
-        eq(cmd, meths.get_autocmds { event = "BufReadPost" }[1].command)
+        eq(desc, meths.get_autocmds { event = 'BufReadPost' }[1].desc)
+        eq(cmd, meths.get_autocmds { event = 'BufReadPost' }[1].command)
       end)
 
       it('can add description to one autocmd that uses a callback', function()
@@ -182,34 +222,34 @@ describe('autocmd api', function()
       end)
 
       it('can add description to multiple autocmd', function()
-        meths.create_autocmd("BufReadPost", {
-          pattern = {"*.py", "*.pyi"},
+        meths.create_autocmd('BufReadPost', {
+          pattern = { '*.py', '*.pyi' },
           command = "echo 'Should Not Have Errored'",
-          desc = "Can show description",
+          desc = 'Can show description',
         })
 
-        local aus = meths.get_autocmds { event = "BufReadPost" }
+        local aus = meths.get_autocmds { event = 'BufReadPost' }
         eq(2, #aus)
-        eq("Can show description", aus[1].desc)
-        eq("Can show description", aus[2].desc)
+        eq('Can show description', aus[1].desc)
+        eq('Can show description', aus[2].desc)
       end)
     end)
 
     pending('script and verbose settings', function()
       it('marks API client', function()
-        meths.create_autocmd("BufReadPost", {
-          pattern = "*.py",
+        meths.create_autocmd('BufReadPost', {
+          pattern = '*.py',
           command = "echo 'Should Not Have Errored'",
-          desc = "Can show description",
+          desc = 'Can show description',
         })
 
-        local aus = meths.get_autocmds { event = "BufReadPost" }
+        local aus = meths.get_autocmds { event = 'BufReadPost' }
         eq(1, #aus, aus)
       end)
     end)
 
     it('removes an autocommand if the callback returns true', function()
-      meths.set_var("some_condition", false)
+      meths.set_var('some_condition', false)
 
       exec_lua [[
       vim.api.nvim_create_autocmd("User", {
@@ -221,19 +261,19 @@ describe('autocmd api', function()
       })
       ]]
 
-      meths.exec_autocmds("User", {pattern = "Test"})
+      meths.exec_autocmds('User', { pattern = 'Test' })
 
       local aus = meths.get_autocmds({ event = 'User', pattern = 'Test' })
       local first = aus[1]
       eq(true, first.id > 0)
 
-      meths.set_var("some_condition", true)
-      meths.exec_autocmds("User", {pattern = "Test"})
-      eq({}, meths.get_autocmds({event = "User", pattern = "Test"}))
+      meths.set_var('some_condition', true)
+      meths.exec_autocmds('User', { pattern = 'Test' })
+      eq({}, meths.get_autocmds({ event = 'User', pattern = 'Test' }))
     end)
 
     it('receives an args table', function()
-      local group_id = meths.create_augroup("TestGroup", {})
+      local group_id = meths.create_augroup('TestGroup', {})
       -- Having an existing autocmd calling expand("<afile>") shouldn't change args #18964
       meths.create_autocmd('User', {
         group = 'TestGroup',
@@ -251,15 +291,15 @@ describe('autocmd api', function()
         })
       ]]
 
-      meths.exec_autocmds("User", {pattern = "Test pattern"})
+      meths.exec_autocmds('User', { pattern = 'Test pattern' })
       eq({
         id = autocmd_id,
         group = group_id,
-        event = "User",
-        match = "Test pattern",
-        file = "Test pattern",
+        event = 'User',
+        match = 'Test pattern',
+        file = 'Test pattern',
         buf = 1,
-      }, meths.get_var("autocmd_args"))
+      }, meths.get_var('autocmd_args'))
 
       -- Test without a group
       autocmd_id = exec_lua [[
@@ -271,20 +311,23 @@ describe('autocmd api', function()
         })
       ]]
 
-      meths.exec_autocmds("User", {pattern = "some_pat"})
+      meths.exec_autocmds('User', { pattern = 'some_pat' })
       eq({
         id = autocmd_id,
         group = nil,
-        event = "User",
-        match = "some_pat",
-        file = "some_pat",
+        event = 'User',
+        match = 'some_pat',
+        file = 'some_pat',
         buf = 1,
-      }, meths.get_var("autocmd_args"))
+      }, meths.get_var('autocmd_args'))
     end)
 
     it('can receive arbitrary data', function()
       local function test(data)
-        eq(data, exec_lua([[
+        eq(
+          data,
+          exec_lua(
+            [[
           local input = ...
           local output
           vim.api.nvim_create_autocmd("User", {
@@ -300,40 +343,64 @@ describe('autocmd api', function()
           })
 
           return output
-        ]], data))
+        ]],
+            data
+          )
+        )
       end
 
-      test("Hello")
+      test('Hello')
       test(42)
       test(true)
-      test({ "list" })
-      test({ foo = "bar" })
+      test({ 'list' })
+      test({ foo = 'bar' })
     end)
   end)
 
   describe('nvim_get_autocmds', function()
     it('validation', function()
-      eq("Invalid 'group': 9997999", pcall_err(meths.get_autocmds, {
-        group = 9997999,
-      }))
-      eq("Invalid 'group': 'bogus'", pcall_err(meths.get_autocmds, {
-        group = 'bogus',
-      }))
-      eq("Invalid 'group': 0", pcall_err(meths.get_autocmds, {
-        group = 0,
-      }))
-      eq("Invalid 'group': expected String or Integer, got Array", pcall_err(meths.get_autocmds, {
-        group = {},
-      }))
-      eq("Invalid 'buffer': expected Integer or Array, got Boolean", pcall_err(meths.get_autocmds, {
-        buffer = true,
-      }))
-      eq("Invalid 'event': expected String or Array", pcall_err(meths.get_autocmds, {
-        event = true,
-      }))
-      eq("Invalid 'pattern': expected String or Array, got Boolean", pcall_err(meths.get_autocmds, {
-        pattern = true,
-      }))
+      eq(
+        "Invalid 'group': 9997999",
+        pcall_err(meths.get_autocmds, {
+          group = 9997999,
+        })
+      )
+      eq(
+        "Invalid 'group': 'bogus'",
+        pcall_err(meths.get_autocmds, {
+          group = 'bogus',
+        })
+      )
+      eq(
+        "Invalid 'group': 0",
+        pcall_err(meths.get_autocmds, {
+          group = 0,
+        })
+      )
+      eq(
+        "Invalid 'group': expected String or Integer, got Array",
+        pcall_err(meths.get_autocmds, {
+          group = {},
+        })
+      )
+      eq(
+        "Invalid 'buffer': expected Integer or Array, got Boolean",
+        pcall_err(meths.get_autocmds, {
+          buffer = true,
+        })
+      )
+      eq(
+        "Invalid 'event': expected String or Array",
+        pcall_err(meths.get_autocmds, {
+          event = true,
+        })
+      )
+      eq(
+        "Invalid 'pattern': expected String or Array, got Boolean",
+        pcall_err(meths.get_autocmds, {
+          pattern = true,
+        })
+      )
     end)
 
     describe('events', function()
@@ -341,7 +408,7 @@ describe('autocmd api', function()
         command [[au! InsertEnter]]
         command [[au InsertEnter * :echo "1"]]
 
-        local aus = meths.get_autocmds { event = "InsertEnter" }
+        local aus = meths.get_autocmds { event = 'InsertEnter' }
         eq(1, #aus)
       end)
 
@@ -350,7 +417,7 @@ describe('autocmd api', function()
         command [[au InsertEnter * :echo "1"]]
         command [[au InsertEnter * :echo "2"]]
 
-        local aus = meths.get_autocmds { event = "InsertEnter" }
+        local aus = meths.get_autocmds { event = 'InsertEnter' }
         eq(2, #aus)
       end)
 
@@ -359,8 +426,8 @@ describe('autocmd api', function()
         command [[au InsertEnter * :echo "1"]]
         command [[au InsertEnter * :echo "2"]]
 
-        local string_aus = meths.get_autocmds { event = "InsertEnter" }
-        local array_aus = meths.get_autocmds { event = { "InsertEnter" } }
+        local string_aus = meths.get_autocmds { event = 'InsertEnter' }
+        local array_aus = meths.get_autocmds { event = { 'InsertEnter' } }
         eq(string_aus, array_aus)
       end)
 
@@ -370,7 +437,7 @@ describe('autocmd api', function()
         command [[au InsertEnter * :echo "1"]]
         command [[au InsertEnter * :echo "2"]]
 
-        local aus = meths.get_autocmds { event = { "InsertEnter", "InsertLeave" } }
+        local aus = meths.get_autocmds { event = { 'InsertEnter', 'InsertLeave' } }
         eq(2, #aus)
       end)
 
@@ -384,7 +451,7 @@ describe('autocmd api', function()
             \ })
         ]]
 
-        local aus = meths.get_autocmds { event = { "InsertEnter", "InsertLeave" } }
+        local aus = meths.get_autocmds { event = { 'InsertEnter', 'InsertLeave' } }
         local first = aus[1]
         eq(first.id, nil)
 
@@ -393,7 +460,7 @@ describe('autocmd api', function()
         neq(second.id, nil)
 
         meths.del_autocmd(second.id)
-        local new_aus = meths.get_autocmds { event = { "InsertEnter", "InsertLeave" } }
+        local new_aus = meths.get_autocmds { event = { 'InsertEnter', 'InsertLeave' } }
         eq(1, #new_aus)
         eq(first, new_aus[1])
       end)
@@ -402,8 +469,16 @@ describe('autocmd api', function()
         command [[au! InsertEnter]]
         command [[au InsertEnter * :echo "1"]]
 
-        local aus = meths.get_autocmds { event = "InsertEnter" }
-        eq({ { buflocal = false, command = ':echo "1"', event = "InsertEnter", once = false, pattern = "*" } }, aus)
+        local aus = meths.get_autocmds { event = 'InsertEnter' }
+        eq({
+          {
+            buflocal = false,
+            command = ':echo "1"',
+            event = 'InsertEnter',
+            once = false,
+            pattern = '*',
+          },
+        }, aus)
       end)
 
       it('works with buffer numbers', function()
@@ -412,77 +487,96 @@ describe('autocmd api', function()
         command [[au InsertEnter <buffer=1> :echo "1"]]
         command [[au InsertEnter <buffer=2> :echo "2"]]
 
-        local aus = meths.get_autocmds { event = "InsertEnter", buffer = 0 }
-        eq({{
-          buffer = 2,
-          buflocal = true,
-          command = ':echo "2"',
-          event = 'InsertEnter',
-          once = false,
-          pattern = '<buffer=2>',
-        }}, aus)
-
-        aus = meths.get_autocmds { event = "InsertEnter", buffer = 1 }
-        eq({{
-          buffer = 1,
-          buflocal = true,
-          command = ':echo "1"',
-          event = "InsertEnter",
-          once = false,
-          pattern = "<buffer=1>",
-        }}, aus)
-
-        aus = meths.get_autocmds { event = "InsertEnter", buffer = { 1, 2 } }
-        eq({{
-          buffer = 1,
-          buflocal = true,
-          command = ':echo "1"',
-          event = "InsertEnter",
-          once = false,
-          pattern = "<buffer=1>",
-        }, {
-          buffer = 2,
-          buflocal = true,
-          command = ':echo "2"',
-          event = "InsertEnter",
-          once = false,
-          pattern = "<buffer=2>",
-        }}, aus)
-
-        eq("Invalid 'buffer': expected Integer or Array, got String", pcall_err(meths.get_autocmds, { event = "InsertEnter", buffer = "foo" }))
-        eq("Invalid 'buffer': expected Integer, got String", pcall_err(meths.get_autocmds, { event = "InsertEnter", buffer = { "foo", 42 } }))
-        eq("Invalid buffer id: 42", pcall_err(meths.get_autocmds, { event = "InsertEnter", buffer = { 42 } }))
+        local aus = meths.get_autocmds { event = 'InsertEnter', buffer = 0 }
+        eq({
+          {
+            buffer = 2,
+            buflocal = true,
+            command = ':echo "2"',
+            event = 'InsertEnter',
+            once = false,
+            pattern = '<buffer=2>',
+          },
+        }, aus)
+
+        aus = meths.get_autocmds { event = 'InsertEnter', buffer = 1 }
+        eq({
+          {
+            buffer = 1,
+            buflocal = true,
+            command = ':echo "1"',
+            event = 'InsertEnter',
+            once = false,
+            pattern = '<buffer=1>',
+          },
+        }, aus)
+
+        aus = meths.get_autocmds { event = 'InsertEnter', buffer = { 1, 2 } }
+        eq({
+          {
+            buffer = 1,
+            buflocal = true,
+            command = ':echo "1"',
+            event = 'InsertEnter',
+            once = false,
+            pattern = '<buffer=1>',
+          },
+          {
+            buffer = 2,
+            buflocal = true,
+            command = ':echo "2"',
+            event = 'InsertEnter',
+            once = false,
+            pattern = '<buffer=2>',
+          },
+        }, aus)
+
+        eq(
+          "Invalid 'buffer': expected Integer or Array, got String",
+          pcall_err(meths.get_autocmds, { event = 'InsertEnter', buffer = 'foo' })
+        )
+        eq(
+          "Invalid 'buffer': expected Integer, got String",
+          pcall_err(meths.get_autocmds, { event = 'InsertEnter', buffer = { 'foo', 42 } })
+        )
+        eq(
+          'Invalid buffer id: 42',
+          pcall_err(meths.get_autocmds, { event = 'InsertEnter', buffer = { 42 } })
+        )
 
         local bufs = {}
         for _ = 1, 257 do
           table.insert(bufs, meths.create_buf(true, false))
         end
 
-        eq("Too many buffers (maximum of 256)", pcall_err(meths.get_autocmds, { event = "InsertEnter", buffer = bufs }))
+        eq(
+          'Too many buffers (maximum of 256)',
+          pcall_err(meths.get_autocmds, { event = 'InsertEnter', buffer = bufs })
+        )
       end)
 
       it('returns autocmds when group is specified by id', function()
-        local auid = meths.create_augroup("nvim_test_augroup", { clear = true })
-        meths.create_autocmd("FileType", { group = auid, command = 'echo "1"' })
-        meths.create_autocmd("FileType", { group = auid, command = 'echo "2"' })
+        local auid = meths.create_augroup('nvim_test_augroup', { clear = true })
+        meths.create_autocmd('FileType', { group = auid, command = 'echo "1"' })
+        meths.create_autocmd('FileType', { group = auid, command = 'echo "2"' })
 
         local aus = meths.get_autocmds { group = auid }
         eq(2, #aus)
 
-        local aus2 = meths.get_autocmds { group = auid, event = "InsertEnter" }
+        local aus2 = meths.get_autocmds { group = auid, event = 'InsertEnter' }
         eq(0, #aus2)
       end)
 
       it('returns autocmds when group is specified by name', function()
-        local auname = "nvim_test_augroup"
+        local auname = 'nvim_test_augroup'
         meths.create_augroup(auname, { clear = true })
-        meths.create_autocmd("FileType", { group = auname, command = 'echo "1"' })
-        meths.create_autocmd("FileType", { group = auname, command = 'echo "2"' })
+        meths.create_autocmd('FileType', { group = auname, command = 'echo "1"' })
+        meths.create_autocmd('FileType', { group = auname, command = 'echo "2"' })
 
         local aus = meths.get_autocmds { group = auname }
         eq(2, #aus)
 
-        local aus2 = meths.get_autocmds { group = auname, event = "InsertEnter" }
+        local aus2 = meths.get_autocmds { group = auname, event = 'InsertEnter' }
         eq(0, #aus2)
       end)
 
@@ -510,7 +604,7 @@ describe('autocmd api', function()
         -- 1 for the first buffer
         -- 2 for First.md
         -- 3-7 for the 5 we make in the autocmd
-        eq({1, 2, 3, 4, 5, 6, 7}, bufs)
+        eq({ 1, 2, 3, 4, 5, 6, 7 }, bufs)
       end)
 
       it('can retrieve a callback from an autocmd', function()
@@ -534,12 +628,14 @@ describe('autocmd api', function()
           }
         ]])
 
-        eq("function", result.cb.type)
+        eq('function', result.cb.type)
         eq(true, result.cb.can_retrieve)
       end)
 
-      it('will return an empty string as the command for an autocmd that uses a callback', function()
-        local result = exec_lua([[
+      it(
+        'will return an empty string as the command for an autocmd that uses a callback',
+        function()
+          local result = exec_lua([[
           local callback = function() print 'I Am A Callback' end
           vim.api.nvim_create_autocmd("BufWritePost", {
             pattern = "*.py",
@@ -553,8 +649,9 @@ describe('autocmd api', function()
           }
         ]])
 
-        eq({ command = "", cbtype = 'function' }, result)
-      end)
+          eq({ command = '', cbtype = 'function' }, result)
+        end
+      )
     end)
 
     describe('groups', function()
@@ -574,7 +671,7 @@ describe('autocmd api', function()
       end)
 
       it('returns all groups if no group is specified', function()
-        local aus = meths.get_autocmds { event = "InsertEnter" }
+        local aus = meths.get_autocmds { event = 'InsertEnter' }
         if #aus ~= 4 then
           eq({}, aus)
         end
@@ -584,32 +681,33 @@ describe('autocmd api', function()
 
       it('returns only the group specified', function()
         local aus = meths.get_autocmds {
-          event = "InsertEnter",
-          group = "GroupOne",
+          event = 'InsertEnter',
+          group = 'GroupOne',
         }
 
         eq(1, #aus)
         eq([[:echo "GroupOne:1"]], aus[1].command)
-        eq("GroupOne", aus[1].group_name)
+        eq('GroupOne', aus[1].group_name)
       end)
 
       it('returns only the group specified, multiple values', function()
         local aus = meths.get_autocmds {
-          event = "InsertEnter",
-          group = "GroupTwo",
+          event = 'InsertEnter',
+          group = 'GroupTwo',
         }
 
         eq(2, #aus)
         eq([[:echo "GroupTwo:2"]], aus[1].command)
-        eq("GroupTwo", aus[1].group_name)
+        eq('GroupTwo', aus[1].group_name)
         eq([[:echo "GroupTwo:3"]], aus[2].command)
-        eq("GroupTwo", aus[2].group_name)
+        eq('GroupTwo', aus[2].group_name)
       end)
     end)
 
     describe('groups: 2', function()
       it('raises error for undefined augroup name', function()
-        local success, code = unpack(meths.exec_lua([[
+        local success, code = unpack(meths.exec_lua(
+          [[
           return {pcall(function()
             vim.api.nvim_create_autocmd("FileType", {
               pattern = "*",
@@ -617,14 +715,17 @@ describe('autocmd api', function()
               command = "echo 'hello'",
             })
           end)}
-        ]], {}))
+        ]],
+          {}
+        ))
 
         eq(false, success)
         matches("Invalid 'group': 'NotDefined'", code)
       end)
 
       it('raises error for undefined augroup id', function()
-        local success, code = unpack(meths.exec_lua([[
+        local success, code = unpack(meths.exec_lua(
+          [[
           return {pcall(function()
             -- Make sure the augroup is deleted
             vim.api.nvim_del_augroup_by_id(1)
@@ -635,14 +736,17 @@ describe('autocmd api', function()
               command = "echo 'hello'",
             })
           end)}
-        ]], {}))
+        ]],
+          {}
+        ))
 
         eq(false, success)
         matches("Invalid 'group': 1", code)
       end)
 
       it('raises error for invalid group type', function()
-        local success, code = unpack(meths.exec_lua([[
+        local success, code = unpack(meths.exec_lua(
+          [[
           return {pcall(function()
             vim.api.nvim_create_autocmd("FileType", {
               pattern = "*",
@@ -650,21 +754,26 @@ describe('autocmd api', function()
               command = "echo 'hello'",
             })
           end)}
-        ]], {}))
+        ]],
+          {}
+        ))
 
         eq(false, success)
         matches("Invalid 'group': expected String or Integer, got Boolean", code)
       end)
 
       it('raises error for invalid pattern array', function()
-        local success, code = unpack(meths.exec_lua([[
+        local success, code = unpack(meths.exec_lua(
+          [[
           return {pcall(function()
             vim.api.nvim_create_autocmd("FileType", {
               pattern = {{}},
               command = "echo 'hello'",
             })
           end)}
-        ]], {}))
+        ]],
+          {}
+        ))
 
         eq(false, success)
         matches("Invalid 'pattern' item: expected String, got Array", code)
@@ -684,8 +793,8 @@ describe('autocmd api', function()
 
       it('returns for literal match', function()
         local aus = meths.get_autocmds {
-          event = "InsertEnter",
-          pattern = "*"
+          event = 'InsertEnter',
+          pattern = '*',
         }
 
         eq(1, #aus)
@@ -695,8 +804,8 @@ describe('autocmd api', function()
       it('returns for multiple matches', function()
         -- vim.api.nvim_get_autocmds
         local aus = meths.get_autocmds {
-          event = "InsertEnter",
-          pattern = { "*.one", "*.two" },
+          event = 'InsertEnter',
+          pattern = { '*.one', '*.two' },
         }
 
         eq(3, #aus)
@@ -707,18 +816,18 @@ describe('autocmd api', function()
 
       it('should work for buffer autocmds', function()
         local normalized_aus = meths.get_autocmds {
-          event = "InsertEnter",
-          pattern = "<buffer=1>",
+          event = 'InsertEnter',
+          pattern = '<buffer=1>',
         }
 
         local raw_aus = meths.get_autocmds {
-          event = "InsertEnter",
-          pattern = "<buffer>",
+          event = 'InsertEnter',
+          pattern = '<buffer>',
         }
 
         local zero_aus = meths.get_autocmds {
-          event = "InsertEnter",
-          pattern = "<buffer=0>",
+          event = 'InsertEnter',
+          pattern = '<buffer=0>',
         }
 
         eq(normalized_aus, raw_aus)
@@ -730,165 +839,186 @@ describe('autocmd api', function()
 
   describe('nvim_exec_autocmds', function()
     it('validation', function()
-      eq("Invalid 'group': 9997999", pcall_err(meths.exec_autocmds, 'FileType', {
-        group = 9997999,
-      }))
-      eq("Invalid 'group': 'bogus'", pcall_err(meths.exec_autocmds, 'FileType', {
-        group = 'bogus',
-      }))
-      eq("Invalid 'group': expected String or Integer, got Array", pcall_err(meths.exec_autocmds, 'FileType', {
-        group = {},
-      }))
-      eq("Invalid 'group': 0", pcall_err(meths.exec_autocmds, 'FileType', {
-        group = 0,
-      }))
-      eq("Invalid 'buffer': expected Buffer, got Array", pcall_err(meths.exec_autocmds, 'FileType', {
-        buffer = {},
-      }))
-      eq("Invalid 'event' item: expected String, got Array", pcall_err(meths.exec_autocmds,
-        {'FileType', {}}, {}))
+      eq(
+        "Invalid 'group': 9997999",
+        pcall_err(meths.exec_autocmds, 'FileType', {
+          group = 9997999,
+        })
+      )
+      eq(
+        "Invalid 'group': 'bogus'",
+        pcall_err(meths.exec_autocmds, 'FileType', {
+          group = 'bogus',
+        })
+      )
+      eq(
+        "Invalid 'group': expected String or Integer, got Array",
+        pcall_err(meths.exec_autocmds, 'FileType', {
+          group = {},
+        })
+      )
+      eq(
+        "Invalid 'group': 0",
+        pcall_err(meths.exec_autocmds, 'FileType', {
+          group = 0,
+        })
+      )
+      eq(
+        "Invalid 'buffer': expected Buffer, got Array",
+        pcall_err(meths.exec_autocmds, 'FileType', {
+          buffer = {},
+        })
+      )
+      eq(
+        "Invalid 'event' item: expected String, got Array",
+        pcall_err(meths.exec_autocmds, { 'FileType', {} }, {})
+      )
     end)
 
-    it("can trigger builtin autocmds", function()
-      meths.set_var("autocmd_executed", false)
+    it('can trigger builtin autocmds', function()
+      meths.set_var('autocmd_executed', false)
 
-      meths.create_autocmd("BufReadPost", {
-        pattern = "*",
-        command = "let g:autocmd_executed = v:true",
+      meths.create_autocmd('BufReadPost', {
+        pattern = '*',
+        command = 'let g:autocmd_executed = v:true',
       })
 
-      eq(false, meths.get_var("autocmd_executed"))
-      meths.exec_autocmds("BufReadPost", {})
-      eq(true, meths.get_var("autocmd_executed"))
+      eq(false, meths.get_var('autocmd_executed'))
+      meths.exec_autocmds('BufReadPost', {})
+      eq(true, meths.get_var('autocmd_executed'))
     end)
 
-    it("can trigger multiple patterns", function()
-      meths.set_var("autocmd_executed", 0)
+    it('can trigger multiple patterns', function()
+      meths.set_var('autocmd_executed', 0)
 
-      meths.create_autocmd("BufReadPost", {
-        pattern = "*",
-        command = "let g:autocmd_executed += 1",
+      meths.create_autocmd('BufReadPost', {
+        pattern = '*',
+        command = 'let g:autocmd_executed += 1',
       })
 
-      meths.exec_autocmds("BufReadPost", { pattern = { "*.lua", "*.vim" } })
-      eq(2, meths.get_var("autocmd_executed"))
+      meths.exec_autocmds('BufReadPost', { pattern = { '*.lua', '*.vim' } })
+      eq(2, meths.get_var('autocmd_executed'))
 
-      meths.create_autocmd("BufReadPre", {
-        pattern = { "bar", "foo" },
-        command = "let g:autocmd_executed += 10",
+      meths.create_autocmd('BufReadPre', {
+        pattern = { 'bar', 'foo' },
+        command = 'let g:autocmd_executed += 10',
       })
 
-      meths.exec_autocmds("BufReadPre", { pattern = { "foo", "bar", "baz", "frederick" }})
-      eq(22, meths.get_var("autocmd_executed"))
+      meths.exec_autocmds('BufReadPre', { pattern = { 'foo', 'bar', 'baz', 'frederick' } })
+      eq(22, meths.get_var('autocmd_executed'))
     end)
 
-    it("can pass the buffer", function()
-      meths.set_var("buffer_executed", -1)
-      eq(-1, meths.get_var("buffer_executed"))
+    it('can pass the buffer', function()
+      meths.set_var('buffer_executed', -1)
+      eq(-1, meths.get_var('buffer_executed'))
 
-      meths.create_autocmd("BufLeave", {
-        pattern = "*",
+      meths.create_autocmd('BufLeave', {
+        pattern = '*',
         command = 'let g:buffer_executed = +expand("<abuf>")',
       })
 
       -- Doesn't execute for other non-matching events
-      meths.exec_autocmds("CursorHold", { buffer = 1 })
-      eq(-1, meths.get_var("buffer_executed"))
+      meths.exec_autocmds('CursorHold', { buffer = 1 })
+      eq(-1, meths.get_var('buffer_executed'))
 
-      meths.exec_autocmds("BufLeave", { buffer = 1 })
-      eq(1, meths.get_var("buffer_executed"))
+      meths.exec_autocmds('BufLeave', { buffer = 1 })
+      eq(1, meths.get_var('buffer_executed'))
     end)
 
-    it("can pass the filename, pattern match", function()
-      meths.set_var("filename_executed", 'none')
-      eq('none', meths.get_var("filename_executed"))
+    it('can pass the filename, pattern match', function()
+      meths.set_var('filename_executed', 'none')
+      eq('none', meths.get_var('filename_executed'))
 
-      meths.create_autocmd("BufEnter", {
-        pattern = "*.py",
+      meths.create_autocmd('BufEnter', {
+        pattern = '*.py',
         command = 'let g:filename_executed = expand("<afile>")',
       })
 
       -- Doesn't execute for other non-matching events
-      meths.exec_autocmds("CursorHold", { buffer = 1 })
-      eq('none', meths.get_var("filename_executed"))
+      meths.exec_autocmds('CursorHold', { buffer = 1 })
+      eq('none', meths.get_var('filename_executed'))
 
       meths.command('edit __init__.py')
-      eq('__init__.py', meths.get_var("filename_executed"))
+      eq('__init__.py', meths.get_var('filename_executed'))
     end)
 
     it('cannot pass buf and fname', function()
-      local ok = pcall(meths.exec_autocmds, "BufReadPre", { pattern = "literally_cannot_error.rs", buffer = 1 })
+      local ok = pcall(
+        meths.exec_autocmds,
+        'BufReadPre',
+        { pattern = 'literally_cannot_error.rs', buffer = 1 }
+      )
       eq(false, ok)
     end)
 
-    it("can pass the filename, exact match", function()
-      meths.set_var("filename_executed", 'none')
-      eq('none', meths.get_var("filename_executed"))
+    it('can pass the filename, exact match', function()
+      meths.set_var('filename_executed', 'none')
+      eq('none', meths.get_var('filename_executed'))
 
       meths.command('edit other_file.txt')
       meths.command('edit __init__.py')
-      eq('none', meths.get_var("filename_executed"))
+      eq('none', meths.get_var('filename_executed'))
 
-      meths.create_autocmd("CursorHoldI", {
-        pattern = "__init__.py",
+      meths.create_autocmd('CursorHoldI', {
+        pattern = '__init__.py',
         command = 'let g:filename_executed = expand("<afile>")',
       })
 
       -- Doesn't execute for other non-matching events
-      meths.exec_autocmds("CursorHoldI", { buffer = 1 })
-      eq('none', meths.get_var("filename_executed"))
+      meths.exec_autocmds('CursorHoldI', { buffer = 1 })
+      eq('none', meths.get_var('filename_executed'))
 
-      meths.exec_autocmds("CursorHoldI", { buffer = meths.get_current_buf() })
-      eq('__init__.py', meths.get_var("filename_executed"))
+      meths.exec_autocmds('CursorHoldI', { buffer = meths.get_current_buf() })
+      eq('__init__.py', meths.get_var('filename_executed'))
 
       -- Reset filename
-      meths.set_var("filename_executed", 'none')
+      meths.set_var('filename_executed', 'none')
 
-      meths.exec_autocmds("CursorHoldI", { pattern = '__init__.py' })
-      eq('__init__.py', meths.get_var("filename_executed"))
+      meths.exec_autocmds('CursorHoldI', { pattern = '__init__.py' })
+      eq('__init__.py', meths.get_var('filename_executed'))
     end)
 
-    it("works with user autocmds", function()
-      meths.set_var("matched", 'none')
+    it('works with user autocmds', function()
+      meths.set_var('matched', 'none')
 
-      meths.create_autocmd("User", {
-        pattern = "TestCommand",
-        command = 'let g:matched = "matched"'
+      meths.create_autocmd('User', {
+        pattern = 'TestCommand',
+        command = 'let g:matched = "matched"',
       })
 
-      meths.exec_autocmds("User", { pattern = "OtherCommand" })
+      meths.exec_autocmds('User', { pattern = 'OtherCommand' })
       eq('none', meths.get_var('matched'))
-      meths.exec_autocmds("User", { pattern = "TestCommand" })
+      meths.exec_autocmds('User', { pattern = 'TestCommand' })
       eq('matched', meths.get_var('matched'))
     end)
 
     it('can pass group by id', function()
-      meths.set_var("group_executed", false)
+      meths.set_var('group_executed', false)
 
-      local auid = meths.create_augroup("nvim_test_augroup", { clear = true })
-      meths.create_autocmd("FileType", {
+      local auid = meths.create_augroup('nvim_test_augroup', { clear = true })
+      meths.create_autocmd('FileType', {
         group = auid,
         command = 'let g:group_executed = v:true',
       })
 
-      eq(false, meths.get_var("group_executed"))
-      meths.exec_autocmds("FileType", { group = auid })
-      eq(true, meths.get_var("group_executed"))
+      eq(false, meths.get_var('group_executed'))
+      meths.exec_autocmds('FileType', { group = auid })
+      eq(true, meths.get_var('group_executed'))
     end)
 
     it('can pass group by name', function()
-      meths.set_var("group_executed", false)
+      meths.set_var('group_executed', false)
 
-      local auname = "nvim_test_augroup"
+      local auname = 'nvim_test_augroup'
       meths.create_augroup(auname, { clear = true })
-      meths.create_autocmd("FileType", {
+      meths.create_autocmd('FileType', {
         group = auname,
         command = 'let g:group_executed = v:true',
       })
 
-      eq(false, meths.get_var("group_executed"))
-      meths.exec_autocmds("FileType", { group = auname })
-      eq(true, meths.get_var("group_executed"))
+      eq(false, meths.get_var('group_executed'))
+      meths.exec_autocmds('FileType', { group = auname })
+      eq(true, meths.get_var('group_executed'))
     end)
   end)
 
@@ -903,19 +1033,19 @@ describe('autocmd api', function()
       opts = opts or {}
 
       local resulting = {
-        pattern = "*",
-        command = "let g:executed = g:executed + 1",
+        pattern = '*',
+        command = 'let g:executed = g:executed + 1',
       }
 
       resulting.group = opts.group
       resulting.once = opts.once
 
-      meths.create_autocmd("FileType", resulting)
+      meths.create_autocmd('FileType', resulting)
     end
 
     local set_ft = function(ft)
-      ft = ft or "txt"
-      source(string.format("set filetype=%s", ft))
+      ft = ft or 'txt'
+      source(string.format('set filetype=%s', ft))
     end
 
     local get_executed_count = function()
@@ -923,12 +1053,12 @@ describe('autocmd api', function()
     end
 
     it('can be added in a group', function()
-      local augroup = "TestGroup"
+      local augroup = 'TestGroup'
       meths.create_augroup(augroup, { clear = true })
       make_counting_autocmd { group = augroup }
 
-      set_ft("txt")
-      set_ft("python")
+      set_ft('txt')
+      set_ft('python')
 
       eq(2, get_executed_count())
     end)
@@ -943,7 +1073,7 @@ describe('autocmd api', function()
     end)
 
     it('handles ++once', function()
-      make_counting_autocmd {once = true}
+      make_counting_autocmd { once = true }
       set_ft('txt')
       set_ft('help')
       set_ft('txt')
@@ -953,9 +1083,9 @@ describe('autocmd api', function()
     end)
 
     it('errors on unexpected keys', function()
-      local success, code = pcall(meths.create_autocmd, "FileType", {
-        pattern = "*",
-        not_a_valid_key = "NotDefined",
+      local success, code = pcall(meths.create_autocmd, 'FileType', {
+        pattern = '*',
+        not_a_valid_key = 'NotDefined',
       })
 
       eq(false, success)
@@ -963,24 +1093,35 @@ describe('autocmd api', function()
     end)
 
     it('can execute simple callback', function()
-      exec_lua([[
+      exec_lua(
+        [[
         vim.g.executed = false
 
         vim.api.nvim_create_autocmd("FileType", {
           pattern = "*",
           callback = function() vim.g.executed = true end,
         })
-      ]], {})
-
-
-      eq(true, exec_lua([[
+      ]],
+        {}
+      )
+
+      eq(
+        true,
+        exec_lua(
+          [[
         vim.cmd "set filetype=txt"
         return vim.g.executed
-      ]], {}))
+      ]],
+          {}
+        )
+      )
     end)
 
     it('calls multiple lua callbacks for the same autocmd execution', function()
-      eq(4, exec_lua([[
+      eq(
+        4,
+        exec_lua(
+          [[
         local count = 0
         local counter = function()
           count = count + 1
@@ -1000,7 +1141,10 @@ describe('autocmd api', function()
         vim.cmd "set filetype=txt"
 
         return count
-      ]], {}))
+      ]],
+          {}
+        )
+      )
     end)
 
     it('properly releases functions with ++once', function()
@@ -1030,82 +1174,86 @@ describe('autocmd api', function()
       command [[set filetype=txt]]
       eq(1, exec_lua([[return OnceCount]], {}))
 
-      eq(0, exec_lua([[
+      eq(
+        0,
+        exec_lua([[
         local count = 0
         for _ in pairs(WeakTable) do
           count = count + 1
         end
 
         return count
-      ]]), "Should have no keys remaining")
+      ]]),
+        'Should have no keys remaining'
+      )
     end)
 
     it('groups can be cleared', function()
-      local augroup = "TestGroup"
+      local augroup = 'TestGroup'
       meths.create_augroup(augroup, { clear = true })
-      meths.create_autocmd("FileType", {
+      meths.create_autocmd('FileType', {
         group = augroup,
-        command = "let g:executed = g:executed + 1"
+        command = 'let g:executed = g:executed + 1',
       })
 
-      set_ft("txt")
-      set_ft("txt")
-      eq(2, get_executed_count(), "should only count twice")
+      set_ft('txt')
+      set_ft('txt')
+      eq(2, get_executed_count(), 'should only count twice')
 
       meths.create_augroup(augroup, { clear = true })
       eq({}, meths.get_autocmds { group = augroup })
 
-      set_ft("txt")
-      set_ft("txt")
-      eq(2, get_executed_count(), "No additional counts")
+      set_ft('txt')
+      set_ft('txt')
+      eq(2, get_executed_count(), 'No additional counts')
     end)
 
     it('can delete non-existent groups with pcall', function()
-      eq(false, exec_lua[[return pcall(vim.api.nvim_del_augroup_by_name, 'noexist')]])
+      eq(false, exec_lua [[return pcall(vim.api.nvim_del_augroup_by_name, 'noexist')]])
       eq('Vim:E367: No such group: "noexist"', pcall_err(meths.del_augroup_by_name, 'noexist'))
 
-      eq(false, exec_lua[[return pcall(vim.api.nvim_del_augroup_by_id, -12342)]])
+      eq(false, exec_lua [[return pcall(vim.api.nvim_del_augroup_by_id, -12342)]])
       eq('Vim:E367: No such group: "--Deleted--"', pcall_err(meths.del_augroup_by_id, -12312))
 
-      eq(false, exec_lua[[return pcall(vim.api.nvim_del_augroup_by_id, 0)]])
+      eq(false, exec_lua [[return pcall(vim.api.nvim_del_augroup_by_id, 0)]])
       eq('Vim:E367: No such group: "[NULL]"', pcall_err(meths.del_augroup_by_id, 0))
 
-      eq(false, exec_lua[[return pcall(vim.api.nvim_del_augroup_by_id, 12342)]])
+      eq(false, exec_lua [[return pcall(vim.api.nvim_del_augroup_by_id, 12342)]])
       eq('Vim:E367: No such group: "[NULL]"', pcall_err(meths.del_augroup_by_id, 12312))
     end)
 
     it('groups work with once', function()
-      local augroup = "TestGroup"
+      local augroup = 'TestGroup'
 
       meths.create_augroup(augroup, { clear = true })
       make_counting_autocmd { group = augroup, once = true }
 
-      set_ft("txt")
-      set_ft("python")
+      set_ft('txt')
+      set_ft('python')
 
       eq(1, get_executed_count())
     end)
 
     it('autocmds can be registered multiple times.', function()
-      local augroup = "TestGroup"
+      local augroup = 'TestGroup'
 
       meths.create_augroup(augroup, { clear = true })
       make_counting_autocmd { group = augroup, once = false }
       make_counting_autocmd { group = augroup, once = false }
       make_counting_autocmd { group = augroup, once = false }
 
-      set_ft("txt")
-      set_ft("python")
+      set_ft('txt')
+      set_ft('python')
 
       eq(3 * 2, get_executed_count())
     end)
 
     it('can be deleted', function()
-      local augroup = "WillBeDeleted"
+      local augroup = 'WillBeDeleted'
 
       meths.create_augroup(augroup, { clear = true })
-      meths.create_autocmd({"FileType"}, {
-        pattern = "*",
+      meths.create_autocmd({ 'FileType' }, {
+        pattern = '*',
         command = "echo 'does not matter'",
       })
 
@@ -1118,20 +1266,20 @@ describe('autocmd api', function()
     end)
 
     it('can be used for buffer local autocmds', function()
-      local augroup = "WillBeDeleted"
+      local augroup = 'WillBeDeleted'
 
-      meths.set_var("value_set", false)
+      meths.set_var('value_set', false)
 
       meths.create_augroup(augroup, { clear = true })
-      meths.create_autocmd("FileType", {
-        pattern = "<buffer>",
-        command = "let g:value_set = v:true",
+      meths.create_autocmd('FileType', {
+        pattern = '<buffer>',
+        command = 'let g:value_set = v:true',
       })
 
-      command "new"
-      command "set filetype=python"
+      command 'new'
+      command 'set filetype=python'
 
-      eq(false, meths.get_var("value_set"))
+      eq(false, meths.get_var('value_set'))
     end)
 
     it('can accept vimscript functions', function()
@@ -1154,107 +1302,113 @@ describe('autocmd api', function()
         set filetype=txt
       ]]
 
-      eq(2, meths.get_var("vimscript_executed"))
+      eq(2, meths.get_var('vimscript_executed'))
     end)
   end)
 
   describe('augroup!', function()
     it('legacy: should clear and not return any autocmds for delete groups', function()
-       command('augroup TEMP_A')
-       command('    autocmd! BufReadPost *.py :echo "Hello"')
-       command('augroup END')
+      command('augroup TEMP_A')
+      command('    autocmd! BufReadPost *.py :echo "Hello"')
+      command('augroup END')
 
-       command('augroup! TEMP_A')
+      command('augroup! TEMP_A')
 
-       eq(false, pcall(meths.get_autocmds, { group = 'TEMP_A' }))
+      eq(false, pcall(meths.get_autocmds, { group = 'TEMP_A' }))
 
-       -- For some reason, augroup! doesn't clear the autocmds themselves, which is just wild
-       -- but we managed to keep this behavior.
-       eq(1, #meths.get_autocmds { event = 'BufReadPost' })
+      -- For some reason, augroup! doesn't clear the autocmds themselves, which is just wild
+      -- but we managed to keep this behavior.
+      eq(1, #meths.get_autocmds { event = 'BufReadPost' })
     end)
 
     it('legacy: remove augroups that have no autocmds', function()
-       command('augroup TEMP_AB')
-       command('augroup END')
+      command('augroup TEMP_AB')
+      command('augroup END')
 
-       command('augroup! TEMP_AB')
+      command('augroup! TEMP_AB')
 
-       eq(false, pcall(meths.get_autocmds, { group = 'TEMP_AB' }))
-       eq(0, #meths.get_autocmds { event = 'BufReadPost' })
+      eq(false, pcall(meths.get_autocmds, { group = 'TEMP_AB' }))
+      eq(0, #meths.get_autocmds { event = 'BufReadPost' })
     end)
 
     it('legacy: multiple remove and add augroup', function()
-       command('augroup TEMP_ABC')
-       command('    au!')
-       command('    autocmd BufReadPost *.py echo "Hello"')
-       command('augroup END')
+      command('augroup TEMP_ABC')
+      command('    au!')
+      command('    autocmd BufReadPost *.py echo "Hello"')
+      command('augroup END')
 
-       command('augroup! TEMP_ABC')
+      command('augroup! TEMP_ABC')
 
-       -- Should still have one autocmd :'(
-       local aus = meths.get_autocmds { event = 'BufReadPost' }
-       eq(1, #aus, aus)
+      -- Should still have one autocmd :'(
+      local aus = meths.get_autocmds { event = 'BufReadPost' }
+      eq(1, #aus, aus)
 
-       command('augroup TEMP_ABC')
-       command('    au!')
-       command('    autocmd BufReadPost *.py echo "Hello"')
-       command('augroup END')
+      command('augroup TEMP_ABC')
+      command('    au!')
+      command('    autocmd BufReadPost *.py echo "Hello"')
+      command('augroup END')
 
-       -- Should now have two autocmds :'(
-       aus = meths.get_autocmds { event = 'BufReadPost' }
-       eq(2, #aus, aus)
+      -- Should now have two autocmds :'(
+      aus = meths.get_autocmds { event = 'BufReadPost' }
+      eq(2, #aus, aus)
 
-       command('augroup! TEMP_ABC')
+      command('augroup! TEMP_ABC')
 
-       eq(false, pcall(meths.get_autocmds, { group = 'TEMP_ABC' }))
-       eq(2, #meths.get_autocmds { event = 'BufReadPost' })
+      eq(false, pcall(meths.get_autocmds, { group = 'TEMP_ABC' }))
+      eq(2, #meths.get_autocmds { event = 'BufReadPost' })
     end)
 
     it('api: should clear and not return any autocmds for delete groups by id', function()
-       command('augroup TEMP_ABCD')
-       command('autocmd! BufReadPost *.py :echo "Hello"')
-       command('augroup END')
+      command('augroup TEMP_ABCD')
+      command('autocmd! BufReadPost *.py :echo "Hello"')
+      command('augroup END')
 
-       local augroup_id = meths.create_augroup("TEMP_ABCD", { clear = false })
-       meths.del_augroup_by_id(augroup_id)
+      local augroup_id = meths.create_augroup('TEMP_ABCD', { clear = false })
+      meths.del_augroup_by_id(augroup_id)
 
-       -- For good reason, we kill all the autocmds from del_augroup,
-       -- so now this works as expected
-       eq(false, pcall(meths.get_autocmds, { group = 'TEMP_ABCD' }))
-       eq(0, #meths.get_autocmds { event = 'BufReadPost' })
+      -- For good reason, we kill all the autocmds from del_augroup,
+      -- so now this works as expected
+      eq(false, pcall(meths.get_autocmds, { group = 'TEMP_ABCD' }))
+      eq(0, #meths.get_autocmds { event = 'BufReadPost' })
     end)
 
     it('api: should clear and not return any autocmds for delete groups by name', function()
-       command('augroup TEMP_ABCDE')
-       command('autocmd! BufReadPost *.py :echo "Hello"')
-       command('augroup END')
+      command('augroup TEMP_ABCDE')
+      command('autocmd! BufReadPost *.py :echo "Hello"')
+      command('augroup END')
 
-       meths.del_augroup_by_name("TEMP_ABCDE")
+      meths.del_augroup_by_name('TEMP_ABCDE')
 
-       -- For good reason, we kill all the autocmds from del_augroup,
-       -- so now this works as expected
-       eq(false, pcall(meths.get_autocmds, { group = 'TEMP_ABCDE' }))
-       eq(0, #meths.get_autocmds { event = 'BufReadPost' })
+      -- For good reason, we kill all the autocmds from del_augroup,
+      -- so now this works as expected
+      eq(false, pcall(meths.get_autocmds, { group = 'TEMP_ABCDE' }))
+      eq(0, #meths.get_autocmds { event = 'BufReadPost' })
     end)
   end)
 
   describe('nvim_clear_autocmds', function()
     it('validation', function()
-      eq("Cannot use both 'pattern' and 'buffer'", pcall_err(meths.clear_autocmds, {
-        pattern = '*',
-        buffer = 42,
-      }))
-      eq("Invalid 'event' item: expected String, got Array", pcall_err(meths.clear_autocmds, {
-        event = {'FileType', {}}
-      }))
-      eq("Invalid 'group': 0", pcall_err(meths.clear_autocmds, {group = 0}))
+      eq(
+        "Cannot use both 'pattern' and 'buffer'",
+        pcall_err(meths.clear_autocmds, {
+          pattern = '*',
+          buffer = 42,
+        })
+      )
+      eq(
+        "Invalid 'event' item: expected String, got Array",
+        pcall_err(meths.clear_autocmds, {
+          event = { 'FileType', {} },
+        })
+      )
+      eq("Invalid 'group': 0", pcall_err(meths.clear_autocmds, { group = 0 }))
     end)
 
     it('should clear based on event + pattern', function()
       command('autocmd InsertEnter *.py  :echo "Python can be cool sometimes"')
       command('autocmd InsertEnter *.txt :echo "Text Files Are Cool"')
 
-      local search = { event = "InsertEnter", pattern = "*.txt" }
+      local search = { event = 'InsertEnter', pattern = '*.txt' }
       local before_delete = meths.get_autocmds(search)
       eq(1, #before_delete)
 
@@ -1273,7 +1427,7 @@ describe('autocmd api', function()
       command('autocmd InsertEnter *.py  :echo "Python can be cool sometimes"')
       command('autocmd InsertEnter *.txt :echo "Text Files Are Cool"')
 
-      local search = { event = "InsertEnter"}
+      local search = { event = 'InsertEnter' }
       local before_delete = meths.get_autocmds(search)
       eq(2, #before_delete)
 
@@ -1288,17 +1442,17 @@ describe('autocmd api', function()
       command('autocmd InsertEnter *.TestPat2 :echo "Enter 2"')
       command('autocmd InsertLeave *.TestPat2 :echo "Leave 2"')
 
-      local search = { pattern = "*.TestPat1"}
+      local search = { pattern = '*.TestPat1' }
       local before_delete = meths.get_autocmds(search)
       eq(2, #before_delete)
-      local before_delete_events = meths.get_autocmds { event = { "InsertEnter", "InsertLeave" } }
+      local before_delete_events = meths.get_autocmds { event = { 'InsertEnter', 'InsertLeave' } }
       eq(4, #before_delete_events)
 
       meths.clear_autocmds(search)
       local after_delete = meths.get_autocmds(search)
       eq(0, #after_delete)
 
-      local after_delete_events = meths.get_autocmds { event = { "InsertEnter", "InsertLeave" } }
+      local after_delete_events = meths.get_autocmds { event = { 'InsertEnter', 'InsertLeave' } }
       eq(2, #after_delete_events)
     end)
 
@@ -1307,14 +1461,14 @@ describe('autocmd api', function()
       command('autocmd InsertEnter <buffer> :echo "Enter Buffer"')
       command('autocmd InsertEnter *.TestPat1 :echo "Enter Pattern"')
 
-      local search = { event = "InsertEnter" }
+      local search = { event = 'InsertEnter' }
       local before_delete = meths.get_autocmds(search)
       eq(2, #before_delete)
 
       meths.clear_autocmds { buffer = 0 }
       local after_delete = meths.get_autocmds(search)
       eq(1, #after_delete)
-      eq("*.TestPat1", after_delete[1].pattern)
+      eq('*.TestPat1', after_delete[1].pattern)
     end)
 
     it('should allow clearing by buffer and group', function()
@@ -1324,7 +1478,7 @@ describe('autocmd api', function()
       command('  autocmd InsertEnter *.TestPat1 :echo "Enter Pattern"')
       command('augroup END')
 
-      local search = { event = "InsertEnter", group = "TestNvimClearAutocmds" }
+      local search = { event = 'InsertEnter', group = 'TestNvimClearAutocmds' }
       local before_delete = meths.get_autocmds(search)
       eq(2, #before_delete)