Merge pull request #14661 from tjdevries/tjdevries/lua_autocmd_v2

lua: autocmds take 2: electric autoroo

7 files changed, 1031 insertions, 4 deletions

diff --git a/test/functional/api/autocmd_spec.lua b/test/functional/api/autocmd_spec.lua
new file mode 100644
index 0000000000..2b48ffa6f0
--- /dev/null
+++ b/test/functional/api/autocmd_spec.lua
@@ -0,0 +1,798 @@
+local helpers = require('test.functional.helpers')(after_each)
+
+local clear = helpers.clear
+local command = helpers.command
+local eq = helpers.eq
+local neq = helpers.neq
+local exec_lua = helpers.exec_lua
+local matches = helpers.matches
+local meths = helpers.meths
+local source = helpers.source
+
+before_each(clear)
+
+describe('autocmd api', function()
+  describe('nvim_create_autocmd', function()
+    it('does not allow "command" and "callback" in the same autocmd', function()
+      local ok, _ = pcall(meths.create_autocmd, {
+        event = "BufReadPost",
+        pattern = "*.py,*.pyi",
+        command = "echo 'Should Have Errored",
+        callback = "not allowed",
+      })
+
+      eq(false, ok)
+    end)
+
+    it('doesnt leak when you use ++once', function()
+      eq(1, exec_lua([[
+        local count = 0
+
+        vim.api.nvim_create_autocmd {
+          event = "FileType",
+          pattern = "*",
+          callback = function() count = count + 1 end,
+          once = true
+        }
+
+        vim.cmd "set filetype=txt"
+        vim.cmd "set filetype=python"
+
+        return count
+      ]], {}))
+    end)
+
+    it('allows passing buffer by key', function()
+      meths.set_var('called', 0)
+
+      meths.create_autocmd {
+        event = "Filetype",
+        command = "let g:called = g:called + 1",
+        buffer = 0,
+      }
+
+      meths.command "set filetype=txt"
+      eq(1, meths.get_var('called'))
+
+      -- switch to a new buffer
+      meths.command "new"
+      meths.command "set filetype=python"
+
+      eq(1, meths.get_var('called'))
+    end)
+
+    it('does not allow passing buffer and patterns', function()
+      local ok = pcall(meths.create_autocmd, {
+        event = "Filetype",
+        command = "let g:called = g:called + 1",
+        buffer = 0,
+        pattern = "*.py",
+      })
+
+      eq(false, ok)
+    end)
+
+    it('does not allow passing invalid buffers', function()
+      local ok, msg = pcall(meths.create_autocmd, {
+        event = "Filetype",
+        command = "let g:called = g:called + 1",
+        buffer = -1,
+      })
+
+      eq(false, ok)
+      matches('Invalid buffer id', msg)
+    end)
+
+    it('errors on non-functions for cb', function()
+      eq(false, pcall(exec_lua, [[
+        vim.api.nvim_create_autocmd {
+          event = "BufReadPost",
+          pattern = "*.py,*.pyi",
+          callback = 5,
+        }
+      ]]))
+    end)
+
+    it('allow passing pattern and <buffer> in same pattern', function()
+      local ok = pcall(meths.create_autocmd, {
+        event = "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 {
+        event = "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" })
+    end)
+
+    it('should handle multiple values as array', function()
+      meths.create_autocmd {
+        event = "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" })
+    end)
+
+    describe('desc', function()
+      it('can add description to one autocmd', function()
+        meths.create_autocmd {
+          event = "BufReadPost",
+          pattern = "*.py",
+          command = "echo 'Should Not Have Errored'",
+          desc = "Can show description",
+        }
+
+        eq("Can show description", meths.get_autocmds { event = "BufReadPost" }[1].desc)
+      end)
+
+      it('can add description to multiple autocmd', function()
+        meths.create_autocmd {
+          event = "BufReadPost",
+          pattern = {"*.py", "*.pyi"},
+          command = "echo 'Should Not Have Errored'",
+          desc = "Can show description",
+        }
+
+        local aus = meths.get_autocmds { event = "BufReadPost" }
+        eq(2, #aus)
+        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 {
+          event = "BufReadPost",
+          pattern = "*.py",
+          command = "echo 'Should Not Have Errored'",
+          desc = "Can show description",
+        }
+
+        local aus = meths.get_autocmds { event = "BufReadPost" }
+        eq(1, #aus, aus)
+      end)
+    end)
+  end)
+
+  describe('nvim_get_autocmds', function()
+    describe('events', function()
+      it('should return one autocmd when there is only one for an event', function()
+        command [[au! InsertEnter]]
+        command [[au InsertEnter * :echo "1"]]
+
+        local aus = meths.get_autocmds { event = "InsertEnter" }
+        eq(1, #aus)
+      end)
+
+      it('should return two autocmds when there are two for an event', function()
+        command [[au! InsertEnter]]
+        command [[au InsertEnter * :echo "1"]]
+        command [[au InsertEnter * :echo "2"]]
+
+        local aus = meths.get_autocmds { event = "InsertEnter" }
+        eq(2, #aus)
+      end)
+
+      it('should return the same thing if you use string or list', function()
+        command [[au! InsertEnter]]
+        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" } }
+        eq(string_aus, array_aus)
+      end)
+
+      it('should return two autocmds when there are two for an event', function()
+        command [[au! InsertEnter]]
+        command [[au! InsertLeave]]
+        command [[au InsertEnter * :echo "1"]]
+        command [[au InsertEnter * :echo "2"]]
+
+        local aus = meths.get_autocmds { event = { "InsertEnter", "InsertLeave" } }
+        eq(2, #aus)
+      end)
+
+      it('should return different IDs for different autocmds', function()
+        command [[au! InsertEnter]]
+        command [[au! InsertLeave]]
+        command [[au InsertEnter * :echo "1"]]
+        source [[
+          call nvim_create_autocmd(#{
+            \ event: "InsertLeave",
+            \ command: ":echo 2",
+            \ })
+        ]]
+
+        local aus = meths.get_autocmds { event = { "InsertEnter", "InsertLeave" } }
+        local first = aus[1]
+        eq(first.id, nil)
+
+        -- TODO: Maybe don't have this number, just assert it's not nil
+        local second = aus[2]
+        neq(second.id, nil)
+
+        meths.del_autocmd(second.id)
+        local new_aus = meths.get_autocmds { event = { "InsertEnter", "InsertLeave" } }
+        eq(1, #new_aus)
+        eq(first, new_aus[1])
+      end)
+    end)
+
+    describe('groups', function()
+      before_each(function()
+        command [[au! InsertEnter]]
+
+        command [[au InsertEnter * :echo "No Group"]]
+
+        command [[augroup GroupOne]]
+        command [[  au InsertEnter * :echo "GroupOne:1"]]
+        command [[augroup END]]
+
+        command [[augroup GroupTwo]]
+        command [[  au InsertEnter * :echo "GroupTwo:2"]]
+        command [[  au InsertEnter * :echo "GroupTwo:3"]]
+        command [[augroup END]]
+      end)
+
+      it('should return all groups if no group is specified', function()
+        local aus = meths.get_autocmds { event = "InsertEnter" }
+        if #aus ~= 4 then
+          eq({}, aus)
+        end
+
+        eq(4, #aus)
+      end)
+
+      it('should return only the group specified', function()
+        local aus = meths.get_autocmds {
+          event = "InsertEnter",
+          group = "GroupOne",
+        }
+
+        eq(1, #aus)
+        eq([[:echo "GroupOne:1"]], aus[1].command)
+      end)
+
+      it('should return only the group specified, multiple values', function()
+        local aus = meths.get_autocmds {
+          event = "InsertEnter",
+          group = "GroupTwo",
+        }
+
+        eq(2, #aus)
+        eq([[:echo "GroupTwo:2"]], aus[1].command)
+        eq([[:echo "GroupTwo:3"]], aus[2].command)
+      end)
+    end)
+
+    describe('groups: 2', function()
+      it('raises error for undefined augroup', function()
+        local success, code = unpack(meths.exec_lua([[
+          return {pcall(function()
+            vim.api.nvim_create_autocmd {
+              event = "FileType",
+              pattern = "*",
+              group = "NotDefined",
+              command = "echo 'hello'",
+            }
+          end)}
+        ]], {}))
+
+        eq(false, success)
+        matches('invalid augroup: NotDefined', code)
+      end)
+    end)
+
+    describe('patterns', function()
+      before_each(function()
+        command [[au! InsertEnter]]
+
+        command [[au InsertEnter *        :echo "No Group"]]
+        command [[au InsertEnter *.one    :echo "GroupOne:1"]]
+        command [[au InsertEnter *.two    :echo "GroupTwo:2"]]
+        command [[au InsertEnter *.two    :echo "GroupTwo:3"]]
+        command [[au InsertEnter <buffer> :echo "Buffer"]]
+      end)
+
+      it('should should return for literal match', function()
+        local aus = meths.get_autocmds {
+          event = "InsertEnter",
+          pattern = "*"
+        }
+
+        eq(1, #aus)
+        eq([[:echo "No Group"]], aus[1].command)
+      end)
+
+      it('should return for multiple matches', function()
+        -- vim.api.nvim_get_autocmds
+        local aus = meths.get_autocmds {
+          event = "InsertEnter",
+          pattern = { "*.one", "*.two" },
+        }
+
+        eq(3, #aus)
+        eq([[:echo "GroupOne:1"]], aus[1].command)
+        eq([[:echo "GroupTwo:2"]], aus[2].command)
+        eq([[:echo "GroupTwo:3"]], aus[3].command)
+      end)
+
+      it('should work for buffer autocmds', function()
+        local normalized_aus = meths.get_autocmds {
+          event = "InsertEnter",
+          pattern = "<buffer=1>",
+        }
+
+        local raw_aus = meths.get_autocmds {
+          event = "InsertEnter",
+          pattern = "<buffer>",
+        }
+
+        local zero_aus = meths.get_autocmds {
+          event = "InsertEnter",
+          pattern = "<buffer=0>",
+        }
+
+        eq(normalized_aus, raw_aus)
+        eq(normalized_aus, zero_aus)
+        eq([[:echo "Buffer"]], normalized_aus[1].command)
+      end)
+    end)
+  end)
+
+  describe('nvim_do_autocmd', function()
+    it("can trigger builtin autocmds", function()
+      meths.set_var("autocmd_executed", false)
+
+      meths.create_autocmd {
+        event = "BufReadPost",
+        pattern = "*",
+        command = "let g:autocmd_executed = v:true",
+      }
+
+      eq(false, meths.get_var("autocmd_executed"))
+      meths.do_autocmd { event = "BufReadPost" }
+      eq(true, 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"))
+
+      meths.create_autocmd {
+        event = "BufLeave",
+        pattern = "*",
+        command = 'let g:buffer_executed = +expand("<abuf>")',
+      }
+
+      -- Doesn't execute for other non-matching events
+      meths.do_autocmd { event = "CursorHold", buffer = 1 }
+      eq(-1, meths.get_var("buffer_executed"))
+
+      meths.do_autocmd { event = "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"))
+
+      meths.create_autocmd {
+        event = "BufEnter",
+        pattern = "*.py",
+        command = 'let g:filename_executed = expand("<afile>")',
+      }
+
+      -- Doesn't execute for other non-matching events
+      meths.do_autocmd { event = "CursorHold", buffer = 1 }
+      eq('none', meths.get_var("filename_executed"))
+
+      meths.command('edit __init__.py')
+      eq('__init__.py', meths.get_var("filename_executed"))
+    end)
+
+    it('cannot pass buf and fname', function()
+      local ok = pcall(meths.do_autocmd, { 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"))
+
+      meths.command('edit other_file.txt')
+      meths.command('edit __init__.py')
+      eq('none', meths.get_var("filename_executed"))
+
+      meths.create_autocmd {
+        event = "CursorHoldI",
+        pattern = "__init__.py",
+        command = 'let g:filename_executed = expand("<afile>")',
+      }
+
+      -- Doesn't execute for other non-matching events
+      meths.do_autocmd { event = "CursorHoldI", buffer = 1 }
+      eq('none', meths.get_var("filename_executed"))
+
+      meths.do_autocmd { event = "CursorHoldI", buffer = tonumber(meths.get_current_buf()) }
+      eq('__init__.py', meths.get_var("filename_executed"))
+
+      -- Reset filename
+      meths.set_var("filename_executed", 'none')
+
+      meths.do_autocmd { event = "CursorHoldI", pattern = '__init__.py' }
+      eq('__init__.py', meths.get_var("filename_executed"))
+    end)
+
+    it("works with user autocmds", function()
+      meths.set_var("matched", 'none')
+
+      meths.create_autocmd {
+        event = "User",
+        pattern = "TestCommand",
+        command = 'let g:matched = "matched"'
+      }
+
+      meths.do_autocmd { event = "User", pattern = "OtherCommand" }
+      eq('none', meths.get_var('matched'))
+      meths.do_autocmd { event = "User", pattern = "TestCommand" }
+      eq('matched', meths.get_var('matched'))
+    end)
+  end)
+
+  describe('nvim_create_augroup', function()
+    before_each(function()
+      clear()
+
+      meths.set_var('executed', 0)
+    end)
+
+    local make_counting_autocmd = function(opts)
+      opts = opts or {}
+
+      local resulting = {
+        event = "FileType",
+        pattern = "*",
+        command = "let g:executed = g:executed + 1",
+      }
+
+      resulting.group = opts.group
+      resulting.once = opts.once
+
+      meths.create_autocmd(resulting)
+    end
+
+    local set_ft = function(ft)
+      ft = ft or "txt"
+      source(string.format("set filetype=%s", ft))
+    end
+
+    local get_executed_count = function()
+      return meths.get_var('executed')
+    end
+
+    it('can be added in a group', function()
+      local augroup = "TestGroup"
+      meths.create_augroup({ name = augroup, clear = true })
+      make_counting_autocmd { group = augroup }
+
+      set_ft("txt")
+      set_ft("python")
+
+      eq(get_executed_count(), 2)
+    end)
+
+    it('works getting called multiple times', function()
+      make_counting_autocmd()
+      set_ft()
+      set_ft()
+      set_ft()
+
+      eq(get_executed_count(), 3)
+    end)
+
+    it('handles ++once', function()
+      make_counting_autocmd {once = true}
+      set_ft('txt')
+      set_ft('help')
+      set_ft('txt')
+      set_ft('help')
+
+      eq(get_executed_count(), 1)
+    end)
+
+    it('errors on unexpected keys', function()
+      local success, code = pcall(meths.create_autocmd, {
+        event = "FileType",
+        pattern = "*",
+        not_a_valid_key = "NotDefined",
+      })
+
+      eq(false, success)
+      matches('not_a_valid_key', code)
+    end)
+
+    it('can execute simple callback', function()
+      exec_lua([[
+        vim.g.executed = false
+
+        vim.api.nvim_create_autocmd {
+          event = "FileType",
+          pattern = "*",
+          callback = function() vim.g.executed = true end,
+        }
+      ]], {})
+
+
+      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([[
+        local count = 0
+        local counter = function()
+          count = count + 1
+        end
+
+        vim.api.nvim_create_autocmd {
+          event = "FileType",
+          pattern = "*",
+          callback = counter,
+        }
+
+        vim.api.nvim_create_autocmd {
+          event = "FileType",
+          pattern = "*",
+          callback = counter,
+        }
+
+        vim.cmd "set filetype=txt"
+        vim.cmd "set filetype=txt"
+
+        return count
+      ]], {}))
+    end)
+
+    it('properly releases functions with ++once', function()
+      exec_lua([[
+        WeakTable = setmetatable({}, { __mode = "k" })
+
+        OnceCount = 0
+
+        MyVal = {}
+        WeakTable[MyVal] = true
+
+        vim.api.nvim_create_autocmd {
+          event = "FileType",
+          pattern = "*",
+          callback = function()
+            OnceCount = OnceCount + 1
+            MyVal = {}
+          end,
+          once = true
+        }
+      ]])
+
+      command [[set filetype=txt]]
+      eq(1, exec_lua([[return OnceCount]], {}))
+
+      exec_lua([[collectgarbage()]], {})
+
+      command [[set filetype=txt]]
+      eq(1, exec_lua([[return OnceCount]], {}))
+
+      eq(0, exec_lua([[
+        local count = 0
+        for _ in pairs(WeakTable) do
+          count = count + 1
+        end
+
+        return count
+      ]]), "Should have no keys remaining")
+    end)
+
+    it('groups can be cleared', function()
+      local augroup = "TestGroup"
+      meths.create_augroup({ name = augroup, clear = true })
+      meths.create_autocmd({
+        group = augroup,
+        event = "FileType",
+        command = "let g:executed = g:executed + 1"
+      })
+
+      set_ft("txt")
+      set_ft("txt")
+      eq(2, get_executed_count(), "should only count twice")
+
+      meths.create_augroup({ name = augroup, clear = true })
+      eq({}, meths.get_autocmds { group = augroup })
+
+      set_ft("txt")
+      set_ft("txt")
+      eq(2, get_executed_count(), "No additional counts")
+    end)
+
+    it('groups work with once', function()
+      local augroup = "TestGroup"
+
+      meths.create_augroup({ name = augroup, clear = true })
+      make_counting_autocmd { group = augroup, once = true }
+
+      set_ft("txt")
+      set_ft("python")
+
+      eq(get_executed_count(), 1)
+    end)
+
+    it('autocmds can be registered multiple times.', function()
+      local augroup = "TestGroup"
+
+      meths.create_augroup({ name = 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")
+
+      eq(get_executed_count(), 3 * 2)
+    end)
+
+    it('can be deleted', function()
+      local augroup = "WillBeDeleted"
+
+      meths.create_augroup({ name = augroup, clear = true })
+      meths.create_autocmd {
+        event = {"Filetype"},
+        pattern = "*",
+        command = "echo 'does not matter'",
+      }
+
+      -- Clears the augroup from before, which erases the autocmd
+      meths.create_augroup({ name = augroup, clear = true })
+
+      local result = #meths.get_autocmds { group = augroup }
+
+      eq(0, result)
+    end)
+
+    it('can be used for buffer local autocmds', function()
+      local augroup = "WillBeDeleted"
+
+      meths.set_var("value_set", false)
+
+      meths.create_augroup({ name = augroup, clear = true })
+      meths.create_autocmd {
+        event = "Filetype",
+        pattern = "<buffer>",
+        command = "let g:value_set = v:true",
+      }
+
+      command "new"
+      command "set filetype=python"
+
+      eq(false, meths.get_var("value_set"))
+    end)
+
+    it('can accept vimscript functions', function()
+      source [[
+        let g:vimscript_executed = 0
+
+        function! MyVimscriptFunction() abort
+          let g:vimscript_executed = g:vimscript_executed + 1
+        endfunction
+
+        call nvim_create_autocmd(#{
+          \ event: "Filetype",
+          \ pattern: ["python", "javascript"],
+          \ callback: "MyVimscriptFunction",
+          \ })
+
+        set filetype=txt
+        set filetype=python
+        set filetype=txt
+        set filetype=javascript
+        set filetype=txt
+      ]]
+
+      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')
+
+       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' })
+    end)
+
+    it('legacy: remove augroups that have no autocmds', function()
+       command('augroup TEMP_AB')
+       command('augroup END')
+
+       command('augroup! TEMP_AB')
+
+       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')
+
+       -- 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')
+
+       -- Should now have two autocmds :'(
+       aus = meths.get_autocmds { event = 'BufReadPost' }
+       eq(2, #aus, aus)
+
+       command('augroup! TEMP_ABC')
+
+       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')
+
+       local augroup_id = meths.create_augroup { name = "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' })
+    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')
+
+       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' })
+    end)
+  end)
+end)
diff --git a/test/functional/autocmd/autocmd_oldtest_spec.lua b/test/functional/autocmd/autocmd_oldtest_spec.lua
new file mode 100644
index 0000000000..ad3687d7b0
--- /dev/null
+++ b/test/functional/autocmd/autocmd_oldtest_spec.lua
@@ -0,0 +1,86 @@
+local helpers = require('test.functional.helpers')(after_each)
+
+local clear = helpers.clear
+local eq = helpers.eq
+local meths = helpers.meths
+local funcs = helpers.funcs
+
+local exec = function(str)
+  meths.exec(str, false)
+end
+
+describe('oldtests', function()
+  before_each(clear)
+
+  local exec_lines = function(str)
+    return funcs.split(funcs.execute(str), "\n")
+  end
+
+  local add_an_autocmd = function()
+    exec [[
+      augroup vimBarTest
+        au BufReadCmd * echo 'hello'
+      augroup END
+    ]]
+
+    eq(3, #exec_lines('au vimBarTest'))
+    eq(1, #meths.get_autocmds({ group = 'vimBarTest' }))
+  end
+
+  it('should recognize a bar before the {event}', function()
+    -- Good spacing
+    add_an_autocmd()
+    exec [[ augroup vimBarTest | au! | augroup END ]]
+    eq(1, #exec_lines('au vimBarTest'))
+    eq({}, meths.get_autocmds({ group = 'vimBarTest' }))
+
+    -- Sad spacing
+    add_an_autocmd()
+    exec [[ augroup vimBarTest| au!| augroup END ]]
+    eq(1, #exec_lines('au vimBarTest'))
+
+
+    -- test that a bar is recognized after the {event}
+    add_an_autocmd()
+    exec [[ augroup vimBarTest| au!BufReadCmd| augroup END ]]
+    eq(1, #exec_lines('au vimBarTest'))
+
+    add_an_autocmd()
+    exec [[ au! vimBarTest|echo 'hello' ]]
+    eq(1, #exec_lines('au vimBarTest'))
+  end)
+
+  it('should fire on unload buf', function()
+    funcs.writefile({'Test file Xxx1'}, 'Xxx1')
+    funcs.writefile({'Test file Xxx2'}, 'Xxx2')
+
+    local content = [[
+      func UnloadAllBufs()
+        let i = 1
+        while i <= bufnr('$')
+          if i != bufnr('%') && bufloaded(i)
+            exe  i . 'bunload'
+          endif
+          let i += 1
+        endwhile
+      endfunc
+      au BufUnload * call UnloadAllBufs()
+      au VimLeave * call writefile(['Test Finished'], 'Xout')
+      set nohidden
+      edit Xxx1
+      split Xxx2
+      q
+    ]]
+
+    funcs.writefile(funcs.split(content, "\n"), 'Xtest')
+
+    funcs.delete('Xout')
+    funcs.system(meths.get_vvar('progpath') .. ' -u NORC -i NONE -N -S Xtest')
+    eq(1, funcs.filereadable('Xout'))
+
+    funcs.delete('Xxx1')
+    funcs.delete('Xxx2')
+    funcs.delete('Xtest')
+    funcs.delete('Xout')
+  end)
+end)
diff --git a/test/functional/autocmd/autocmd_spec.lua b/test/functional/autocmd/autocmd_spec.lua
index 13d0103ce5..f37f04b32f 100644
--- a/test/functional/autocmd/autocmd_spec.lua
+++ b/test/functional/autocmd/autocmd_spec.lua
@@ -5,6 +5,7 @@ local assert_visible = helpers.assert_visible
 local assert_alive = helpers.assert_alive
 local dedent = helpers.dedent
 local eq = helpers.eq
+local neq = helpers.neq
 local eval = helpers.eval
 local feed = helpers.feed
 local clear = helpers.clear
@@ -418,4 +419,106 @@ describe('autocmd', function()
       :doautocmd SessionLoadPost      |
     ]]}
   end)
+
+  describe('old_tests', function()
+    it('vimscript: WinNew ++once', function()
+      source [[
+        " Without ++once WinNew triggers twice
+        let g:did_split = 0
+        augroup Testing
+          au!
+          au WinNew * let g:did_split += 1
+        augroup END
+        split
+        split
+        call assert_equal(2, g:did_split)
+        call assert_true(exists('#WinNew'))
+        close
+        close
+
+        " With ++once WinNew triggers once
+        let g:did_split = 0
+        augroup Testing
+          au!
+          au WinNew * ++once let g:did_split += 1
+        augroup END
+        split
+        split
+        call assert_equal(1, g:did_split)
+        call assert_false(exists('#WinNew'))
+        close
+        close
+
+        call assert_fails('au WinNew * ++once ++once echo bad', 'E983:')
+      ]]
+
+      meths.set_var('did_split', 0)
+
+      source [[
+        augroup Testing
+          au!
+          au WinNew * let g:did_split += 1
+        augroup END
+
+        split
+        split
+      ]]
+
+      eq(2, meths.get_var('did_split'))
+      eq(1, funcs.exists('#WinNew'))
+
+      -- Now with once
+      meths.set_var('did_split', 0)
+
+      source [[
+        augroup Testing
+          au!
+          au WinNew * ++once let g:did_split += 1
+        augroup END
+
+        split
+        split
+      ]]
+
+      eq(1, meths.get_var('did_split'))
+      eq(0, funcs.exists('#WinNew'))
+
+      -- call assert_fails('au WinNew * ++once ++once echo bad', 'E983:')
+      local ok, msg = pcall(source, [[
+        au WinNew * ++once ++once echo bad
+      ]])
+
+      eq(false, ok)
+      eq(true, not not string.find(msg, 'E983:'))
+    end)
+
+    it('should have autocmds in filetypedetect group', function()
+      source [[filetype on]]
+      neq({}, meths.get_autocmds { group = "filetypedetect" })
+    end)
+
+    it('should not access freed mem', function()
+      source [[
+        au BufEnter,BufLeave,WinEnter,WinLeave 0 vs xxx
+        arg 0
+        argadd
+        all
+        all
+        au!
+        bwipe xxx
+      ]]
+    end)
+
+    it('should allow comma-separated patterns', function()
+      source [[
+        augroup TestingPatterns
+          au!
+          autocmd BufReadCmd *.shada,*.shada.tmp.[a-z] echo 'hello'
+          autocmd BufReadCmd *.shada,*.shada.tmp.[a-z] echo 'hello'
+        augroup END
+      ]]
+
+      eq(4, #meths.get_autocmds { event = "BufReadCmd", group = "TestingPatterns" })
+    end)
+  end)
 end)
diff --git a/test/functional/autocmd/cursormoved_spec.lua b/test/functional/autocmd/cursormoved_spec.lua
index 9641d4b096..85d8628d7e 100644
--- a/test/functional/autocmd/cursormoved_spec.lua
+++ b/test/functional/autocmd/cursormoved_spec.lua
@@ -35,6 +35,7 @@ describe('CursorMoved', function()
   it("is not triggered by cursor movement prior to first CursorMoved instantiation", function()
     source([[
     let g:cursormoved = 0
+    autocmd! CursorMoved
     autocmd CursorMoved * let g:cursormoved += 1
     ]])
     eq(0, eval('g:cursormoved'))
diff --git a/test/functional/autocmd/show_spec.lua b/test/functional/autocmd/show_spec.lua
new file mode 100644
index 0000000000..59757a7d61
--- /dev/null
+++ b/test/functional/autocmd/show_spec.lua
@@ -0,0 +1,35 @@
+local helpers = require('test.functional.helpers')(after_each)
+
+local clear = helpers.clear
+local command = helpers.command
+local dedent = helpers.dedent
+local eq = helpers.eq
+local funcs = helpers.funcs
+
+describe(":autocmd", function()
+  before_each(clear)
+
+  it("should not segfault when you just do autocmd", function()
+    command ":autocmd"
+  end)
+
+  it("should filter based on ++once", function()
+    command "autocmd! BufEnter"
+    command "autocmd BufEnter * :echo 'Hello'"
+    command [[augroup TestingOne]]
+    command [[  autocmd BufEnter * :echo "Line 1"]]
+    command [[  autocmd BufEnter * :echo "Line 2"]]
+    command [[augroup END]]
+
+    eq(dedent([[
+
+       --- Autocommands ---
+       BufEnter
+           *         :echo 'Hello'
+       TestingOne  BufEnter
+           *         :echo "Line 1"
+                     :echo "Line 2"]]),
+       funcs.execute('autocmd BufEnter'))
+
+  end)
+end)
diff --git a/test/functional/autocmd/termxx_spec.lua b/test/functional/autocmd/termxx_spec.lua
index 1e8f981437..bc7a6d6c36 100644
--- a/test/functional/autocmd/termxx_spec.lua
+++ b/test/functional/autocmd/termxx_spec.lua
@@ -32,7 +32,7 @@ describe('autocmd TermClose', function()
     retry(nil, nil, function() eq(23, eval('g:test_termclose')) end)
   end)
 
-  it('kills job trapping SIGTERM', function()
+  pending('kills job trapping SIGTERM', function()
     if iswin() then return end
     nvim('set_option', 'shell', 'sh')
     nvim('set_option', 'shellcmdflag', '-c')
@@ -52,7 +52,7 @@ describe('autocmd TermClose', function()
     ok(duration <= 4000)  -- Epsilon for slow CI
   end)
 
-  it('kills PTY job trapping SIGHUP and SIGTERM', function()
+  pending('kills PTY job trapping SIGHUP and SIGTERM', function()
     if iswin() then return end
     nvim('set_option', 'shell', 'sh')
     nvim('set_option', 'shellcmdflag', '-c')
diff --git a/test/functional/plugin/shada_spec.lua b/test/functional/plugin/shada_spec.lua
index a4d78682ad..6f22f865e6 100644
--- a/test/functional/plugin/shada_spec.lua
+++ b/test/functional/plugin/shada_spec.lua
@@ -1,7 +1,7 @@
 local helpers = require('test.functional.helpers')(after_each)
 local clear = helpers.clear
-local eq, nvim_eval, nvim_command, nvim, exc_exec, funcs, nvim_feed, curbuf =
-  helpers.eq, helpers.eval, helpers.command, helpers.nvim, helpers.exc_exec,
+local eq, meths, nvim_eval, nvim_command, nvim, exc_exec, funcs, nvim_feed, curbuf =
+  helpers.eq, helpers.meths, helpers.eval, helpers.command, helpers.nvim, helpers.exc_exec,
   helpers.funcs, helpers.feed, helpers.curbuf
 local neq = helpers.neq
 local read_file = helpers.read_file
@@ -2162,6 +2162,10 @@ describe('plugin/shada.vim', function()
     wshada('\004\000\009\147\000\196\002ab\196\001a')
     wshada_tmp('\004\000\009\147\000\196\002ab\196\001b')
 
+
+    local bufread_commands = meths.get_autocmds({ group = "ShaDaCommands", event = "BufReadCmd" })
+    eq(2, #bufread_commands--[[, vim.inspect(bufread_commands) ]])
+
     -- Need to set nohidden so that the buffer containing 'fname' is not unloaded
     -- after loading 'fname_tmp', otherwise the '++opt not supported' test below
     -- won't work since the BufReadCmd autocmd won't be triggered.