patch 9.0.1570: some tests are slowv9.0.1570

Problem:    Some tests are slow.
Solution:   Make a few test cases faster.

5 files changed, 645 insertions, 640 deletions

diff --git a/src/testdir/test_cmdline.vim b/src/testdir/test_cmdline.vim
index 9bb21bcfa9..79740b5bb0 100644
--- a/src/testdir/test_cmdline.vim
+++ b/src/testdir/test_cmdline.vim
@@ -791,10 +791,10 @@ func Test_shellcmd_completion()
 endfunc
 
 func Test_expand_star_star()
-  call mkdir('a/b', 'pR')
-  call writefile(['asdfasdf'], 'a/b/fileXname')
-  call feedkeys(":find **/fileXname\<Tab>\<CR>", 'xt')
-  call assert_equal('find a/b/fileXname', @:)
+  call mkdir('a/b/c', 'pR')
+  call writefile(['asdfasdf'], 'a/b/c/fileXname')
+  call feedkeys(":find a/**/fileXname\<Tab>\<CR>", 'xt')
+  call assert_equal('find a/b/c/fileXname', @:)
   bwipe!
 endfunc
 
diff --git a/src/testdir/test_codestyle.vim b/src/testdir/test_codestyle.vim
index 3553063494..509e1351cb 100644
--- a/src/testdir/test_codestyle.vim
+++ b/src/testdir/test_codestyle.vim
@@ -2,6 +2,7 @@
 
 def Test_source_files()
   for fname in glob('../*.[ch]', 0, 1)
+    bwipe!
     exe 'edit ' .. fname
 
     cursor(1, 1)
@@ -26,11 +27,11 @@ def Test_source_files()
     lnum = search(')\s*{', '', 0, 0, skip)
     assert_equal(0, lnum, fname .. ': curly after closing paren')
 
-    cursor(1, 1)
     # Examples in comments use double quotes.
     skip = "getline('.') =~ '\"'"
-    # Avoid examples that contain: "} else
-    lnum = search('[^"]}\s*else', '', 0, 0, skip)
+
+    cursor(1, 1)
+    lnum = search('}\s*else', '', 0, 0, skip)
     assert_equal(0, lnum, fname .. ': curly before "else"')
 
     cursor(1, 1)
diff --git a/src/testdir/test_debugger.vim b/src/testdir/test_debugger.vim
index 2b405d9209..4261bb375a 100644
--- a/src/testdir/test_debugger.vim
+++ b/src/testdir/test_debugger.vim
@@ -20,39 +20,39 @@ command! -nargs=0 -bar CheckCWD call CheckCWD()
 " "options" argument can contain:
 " 'msec' - time to wait for a match
 " 'match' - "pattern" to use "lines" as pattern instead of text
-func CheckDbgOutput(buf, lines, options = {})
-  " Verify the expected output
-  let lnum = 20 - len(a:lines)
-  let msec = get(a:options, 'msec', 1000)
-  for l in a:lines
-    if get(a:options, 'match', 'equal') ==# 'pattern'
-      call WaitForAssert({-> assert_match(l, term_getline(a:buf, lnum))}, msec)
+def s:CheckDbgOutput(buf: number, lines: list<string>, options = {})
+  # Verify the expected output
+  var lnum = 20 - len(lines)
+  var msec = get(options, 'msec', 1000)
+  for l in lines
+    if get(options, 'match', 'equal') ==# 'pattern'
+      g:WaitForAssert(() => assert_match(l, term_getline(buf, lnum)), msec)
     else
-      call WaitForAssert({-> assert_equal(l, term_getline(a:buf, lnum))}, msec)
+      g:WaitForAssert(() => assert_equal(l, term_getline(buf, lnum)), msec)
     endif
-    let lnum += 1
+    lnum += 1
   endfor
-endfunc
+enddef
 
 " Run a Vim debugger command
 " If the expected output argument is supplied, then check for it.
-func RunDbgCmd(buf, cmd, ...)
-  call term_sendkeys(a:buf, a:cmd . "\r")
-  call TermWait(a:buf)
-
-  if a:0 != 0
-    let options = #{match: 'equal'}
-    if a:0 > 1
-      call extend(options, a:2)
+def s:RunDbgCmd(buf: number, cmd: string, ...extra: list<any>)
+  term_sendkeys(buf, cmd .. "\r")
+  g:TermWait(buf)
+
+  if len(extra) > 0
+    var options = {match: 'equal'}
+    if len(extra) > 1
+      extend(options, extra[1])
     endif
-    call CheckDbgOutput(a:buf, a:1, options)
+    s:CheckDbgOutput(buf, extra[0], options)
   endif
-endfunc
+enddef
 
 " Debugger tests
-func Test_Debugger()
-  " Create a Vim script with some functions
-  let lines =<< trim END
+def Test_Debugger()
+  # Create a Vim script with some functions
+  var lines =<< trim END
 	func Foo()
 	  let var1 = 1
 	  let var2 = Bar(var1) + 9
@@ -81,257 +81,257 @@ func Test_Debugger()
           endfor
         enddef
   END
-  call writefile(lines, 'XtestDebug.vim', 'D')
+  writefile(lines, 'XtestDebug.vim', 'D')
 
-  " Start Vim in a terminal
-  let buf = RunVimInTerminal('-S XtestDebug.vim', {})
-
-  " Start the Vim debugger
-  call RunDbgCmd(buf, ':debug echo Foo()', ['cmd: echo Foo()'])
-
-  " Create a few stack frames by stepping through functions
-  call RunDbgCmd(buf, 'step', ['line 1: let var1 = 1'])
-  call RunDbgCmd(buf, 'step', ['line 2: let var2 = Bar(var1) + 9'])
-  call RunDbgCmd(buf, 'step', ['line 1: let var1 = 2 + a:var'])
-  call RunDbgCmd(buf, 'step', ['line 2: let var2 = Bazz(var1) + 4'])
-  call RunDbgCmd(buf, 'step', ['line 1: try'])
-  call RunDbgCmd(buf, 'step', ['line 2: let var1 = 3 + a:var'])
-  call RunDbgCmd(buf, 'step', ['line 3: let var3 = "another var"'])
-
-  " check backtrace
-  call RunDbgCmd(buf, 'backtrace', [
-	      \ '  2 function Foo[2]',
-	      \ '  1 Bar[2]',
-	      \ '->0 Bazz',
-	      \ 'line 3: let var3 = "another var"'])
-
-  " Check variables in different stack frames
-  call RunDbgCmd(buf, 'echo var1', ['6'])
-
-  call RunDbgCmd(buf, 'up')
-  call RunDbgCmd(buf, 'back', [
-	      \ '  2 function Foo[2]',
-	      \ '->1 Bar[2]',
-	      \ '  0 Bazz',
-	      \ 'line 3: let var3 = "another var"'])
-  call RunDbgCmd(buf, 'echo var1', ['3'])
-
-  call RunDbgCmd(buf, 'u')
-  call RunDbgCmd(buf, 'bt', [
-	      \ '->2 function Foo[2]',
-	      \ '  1 Bar[2]',
-	      \ '  0 Bazz',
-	      \ 'line 3: let var3 = "another var"'])
-  call RunDbgCmd(buf, 'echo var1', ['1'])
-
-  " Undefined variables
-  call RunDbgCmd(buf, 'step')
-  call RunDbgCmd(buf, 'frame 2')
-  call RunDbgCmd(buf, 'echo var3', [
-	\ 'Error detected while processing function Foo[2]..Bar[2]..Bazz:',
-	\ 'line    4:',
-	\ 'E121: Undefined variable: var3'])
-
-  " var3 is defined in this level with some other value
-  call RunDbgCmd(buf, 'fr 0')
-  call RunDbgCmd(buf, 'echo var3', ['another var'])
-
-  call RunDbgCmd(buf, 'step')
-  call RunDbgCmd(buf, '')
-  call RunDbgCmd(buf, '')
-  call RunDbgCmd(buf, '')
-  call RunDbgCmd(buf, '')
-  call RunDbgCmd(buf, 'step', [
-	      \ 'function Foo[2]..Bar',
-	      \ 'line 3: End of function'])
-  call RunDbgCmd(buf, 'up')
-
-  " Undefined var2
-  call RunDbgCmd(buf, 'echo var2', [
-	      \ 'Error detected while processing function Foo[2]..Bar:',
-	      \ 'line    3:',
-	      \ 'E121: Undefined variable: var2'])
-
-  " Var2 is defined with 10
-  call RunDbgCmd(buf, 'down')
-  call RunDbgCmd(buf, 'echo var2', ['10'])
-
-  " Backtrace movements
-  call RunDbgCmd(buf, 'b', [
-	      \ '  1 function Foo[2]',
-	      \ '->0 Bar',
-	      \ 'line 3: End of function'])
-
-  " next command cannot go down, we are on bottom
-  call RunDbgCmd(buf, 'down', ['frame is zero'])
-  call RunDbgCmd(buf, 'up')
-
-  " next command cannot go up, we are on top
-  call RunDbgCmd(buf, 'up', ['frame at highest level: 1'])
-  call RunDbgCmd(buf, 'where', [
-	      \ '->1 function Foo[2]',
-	      \ '  0 Bar',
-	      \ 'line 3: End of function'])
-
-  " fil is not frame or finish, it is file
-  call RunDbgCmd(buf, 'fil', ['"[No Name]" --No lines in buffer--'])
-
-  " relative backtrace movement
-  call RunDbgCmd(buf, 'fr -1')
-  call RunDbgCmd(buf, 'frame', [
-	      \ '  1 function Foo[2]',
-	      \ '->0 Bar',
-	      \ 'line 3: End of function'])
-
-  call RunDbgCmd(buf, 'fr +1')
-  call RunDbgCmd(buf, 'fram', [
-	      \ '->1 function Foo[2]',
-	      \ '  0 Bar',
-	      \ 'line 3: End of function'])
-
-  " go beyond limits does not crash
-  call RunDbgCmd(buf, 'fr 100', ['frame at highest level: 1'])
-  call RunDbgCmd(buf, 'fra', [
-	      \ '->1 function Foo[2]',
-	      \ '  0 Bar',
-	      \ 'line 3: End of function'])
-
-  call RunDbgCmd(buf, 'frame -40', ['frame is zero'])
-  call RunDbgCmd(buf, 'fram', [
-	      \ '  1 function Foo[2]',
-	      \ '->0 Bar',
-	      \ 'line 3: End of function'])
-
-  " final result 19
-  call RunDbgCmd(buf, 'cont', ['19'])
-
-  " breakpoints tests
-
-  " Start a debug session, so that reading the last line from the terminal
-  " works properly.
-  call RunDbgCmd(buf, ':debug echo Foo()', ['cmd: echo Foo()'])
-
-  " No breakpoints
-  call RunDbgCmd(buf, 'breakl', ['No breakpoints defined'])
-
-  " Place some breakpoints
-  call RunDbgCmd(buf, 'breaka func Bar')
-  call RunDbgCmd(buf, 'breaklis', ['  1  func Bar  line 1'])
-  call RunDbgCmd(buf, 'breakadd func 3 Bazz')
-  call RunDbgCmd(buf, 'breaklist', ['  1  func Bar  line 1',
-	      \ '  2  func Bazz  line 3'])
-
-  " Check whether the breakpoints are hit
-  call RunDbgCmd(buf, 'cont', [
-	      \ 'Breakpoint in "Bar" line 1',
-	      \ 'function Foo[2]..Bar',
-	      \ 'line 1: let var1 = 2 + a:var'])
-  call RunDbgCmd(buf, 'cont', [
-	      \ 'Breakpoint in "Bazz" line 3',
-	      \ 'function Foo[2]..Bar[2]..Bazz',
-	      \ 'line 3: let var3 = "another var"'])
-
-  " Delete the breakpoints
-  call RunDbgCmd(buf, 'breakd 1')
-  call RunDbgCmd(buf, 'breakli', ['  2  func Bazz  line 3'])
-  call RunDbgCmd(buf, 'breakdel func 3 Bazz')
-  call RunDbgCmd(buf, 'breakl', ['No breakpoints defined'])
-
-  call RunDbgCmd(buf, 'cont')
-
-  " Make sure the breakpoints are removed
-  call RunDbgCmd(buf, ':echo Foo()', ['19'])
-
-  " Delete a non-existing breakpoint
-  call RunDbgCmd(buf, ':breakdel 2', ['E161: Breakpoint not found: 2'])
-
-  " Expression breakpoint
-  call RunDbgCmd(buf, ':breakadd func 2 Bazz')
-  call RunDbgCmd(buf, ':echo Bazz(1)', [
-	      \ 'Entering Debug mode.  Type "cont" to continue.',
-	      \ 'function Bazz',
-	      \ 'line 2: let var1 = 3 + a:var'])
-  call RunDbgCmd(buf, 'step')
-  call RunDbgCmd(buf, 'step')
-  call RunDbgCmd(buf, 'breaka expr var3')
-  call RunDbgCmd(buf, 'breakl', ['  3  func Bazz  line 2',
+  # Start Vim in a terminal
+  var buf = g:RunVimInTerminal('-S XtestDebug.vim', {})
+
+  # Start the Vim debugger
+  s:RunDbgCmd(buf, ':debug echo Foo()', ['cmd: echo Foo()'])
+
+  # Create a few stack frames by stepping through functions
+  s:RunDbgCmd(buf, 'step', ['line 1: let var1 = 1'])
+  s:RunDbgCmd(buf, 'step', ['line 2: let var2 = Bar(var1) + 9'])
+  s:RunDbgCmd(buf, 'step', ['line 1: let var1 = 2 + a:var'])
+  s:RunDbgCmd(buf, 'step', ['line 2: let var2 = Bazz(var1) + 4'])
+  s:RunDbgCmd(buf, 'step', ['line 1: try'])
+  s:RunDbgCmd(buf, 'step', ['line 2: let var1 = 3 + a:var'])
+  s:RunDbgCmd(buf, 'step', ['line 3: let var3 = "another var"'])
+
+  # check backtrace
+  s:RunDbgCmd(buf, 'backtrace', [
+	      '  2 function Foo[2]',
+	      '  1 Bar[2]',
+	      '->0 Bazz',
+	      'line 3: let var3 = "another var"'])
+
+  # Check variables in different stack frames
+  s:RunDbgCmd(buf, 'echo var1', ['6'])
+
+  s:RunDbgCmd(buf, 'up')
+  s:RunDbgCmd(buf, 'back', [
+	      '  2 function Foo[2]',
+	      '->1 Bar[2]',
+	      '  0 Bazz',
+	      'line 3: let var3 = "another var"'])
+  s:RunDbgCmd(buf, 'echo var1', ['3'])
+
+  s:RunDbgCmd(buf, 'u')
+  s:RunDbgCmd(buf, 'bt', [
+	      '->2 function Foo[2]',
+	      '  1 Bar[2]',
+	      '  0 Bazz',
+	      'line 3: let var3 = "another var"'])
+  s:RunDbgCmd(buf, 'echo var1', ['1'])
+
+  # Undefined variables
+  s:RunDbgCmd(buf, 'step')
+  s:RunDbgCmd(buf, 'frame 2')
+  s:RunDbgCmd(buf, 'echo var3', [
+	'Error detected while processing function Foo[2]..Bar[2]..Bazz:',
+	'line    4:',
+	'E121: Undefined variable: var3'])
+
+  # var3 is defined in this level with some other value
+  s:RunDbgCmd(buf, 'fr 0')
+  s:RunDbgCmd(buf, 'echo var3', ['another var'])
+
+  s:RunDbgCmd(buf, 'step')
+  s:RunDbgCmd(buf, '')
+  s:RunDbgCmd(buf, '')
+  s:RunDbgCmd(buf, '')
+  s:RunDbgCmd(buf, '')
+  s:RunDbgCmd(buf, 'step', [
+	      'function Foo[2]..Bar',
+	      'line 3: End of function'])
+  s:RunDbgCmd(buf, 'up')
+
+  # Undefined var2
+  s:RunDbgCmd(buf, 'echo var2', [
+	      'Error detected while processing function Foo[2]..Bar:',
+	      'line    3:',
+	      'E121: Undefined variable: var2'])
+
+  # Var2 is defined with 10
+  s:RunDbgCmd(buf, 'down')
+  s:RunDbgCmd(buf, 'echo var2', ['10'])
+
+  # Backtrace movements
+  s:RunDbgCmd(buf, 'b', [
+	      '  1 function Foo[2]',
+	      '->0 Bar',
+	      'line 3: End of function'])
+
+  # next command cannot go down, we are on bottom
+  s:RunDbgCmd(buf, 'down', ['frame is zero'])
+  s:RunDbgCmd(buf, 'up')
+
+  # next command cannot go up, we are on top
+  s:RunDbgCmd(buf, 'up', ['frame at highest level: 1'])
+  s:RunDbgCmd(buf, 'where', [
+	      '->1 function Foo[2]',
+	      '  0 Bar',
+	      'line 3: End of function'])
+
+  # fil is not frame or finish, it is file
+  s:RunDbgCmd(buf, 'fil', ['"[No Name]" --No lines in buffer--'])
+
+  # relative backtrace movement
+  s:RunDbgCmd(buf, 'fr -1')
+  s:RunDbgCmd(buf, 'frame', [
+	      '  1 function Foo[2]',
+	      '->0 Bar',
+	      'line 3: End of function'])
+
+  s:RunDbgCmd(buf, 'fr +1')
+  s:RunDbgCmd(buf, 'fram', [
+	      '->1 function Foo[2]',
+	      '  0 Bar',
+	      'line 3: End of function'])
+
+  # go beyond limits does not crash
+  s:RunDbgCmd(buf, 'fr 100', ['frame at highest level: 1'])
+  s:RunDbgCmd(buf, 'fra', [
+	      '->1 function Foo[2]',
+	      '  0 Bar',
+	      'line 3: End of function'])
+
+  s:RunDbgCmd(buf, 'frame -40', ['frame is zero'])
+  s:RunDbgCmd(buf, 'fram', [
+	      '  1 function Foo[2]',
+	      '->0 Bar',
+	      'line 3: End of function'])
+
+  # final result 19
+  s:RunDbgCmd(buf, 'cont', ['19'])
+
+  # breakpoints tests
+
+  # Start a debug session, so that reading the last line from the terminal
+  # works properly.
+  s:RunDbgCmd(buf, ':debug echo Foo()', ['cmd: echo Foo()'])
+
+  # No breakpoints
+  s:RunDbgCmd(buf, 'breakl', ['No breakpoints defined'])
+
+  # Place some breakpoints
+  s:RunDbgCmd(buf, 'breaka func Bar')
+  s:RunDbgCmd(buf, 'breaklis', ['  1  func Bar  line 1'])
+  s:RunDbgCmd(buf, 'breakadd func 3 Bazz')
+  s:RunDbgCmd(buf, 'breaklist', ['  1  func Bar  line 1',
+	      '  2  func Bazz  line 3'])
+
+  # Check whether the breakpoints are hit
+  s:RunDbgCmd(buf, 'cont', [
+	      'Breakpoint in "Bar" line 1',
+	      'function Foo[2]..Bar',
+	      'line 1: let var1 = 2 + a:var'])
+  s:RunDbgCmd(buf, 'cont', [
+	      'Breakpoint in "Bazz" line 3',
+	      'function Foo[2]..Bar[2]..Bazz',
+	      'line 3: let var3 = "another var"'])
+
+  # Delete the breakpoints
+  s:RunDbgCmd(buf, 'breakd 1')
+  s:RunDbgCmd(buf, 'breakli', ['  2  func Bazz  line 3'])
+  s:RunDbgCmd(buf, 'breakdel func 3 Bazz')
+  s:RunDbgCmd(buf, 'breakl', ['No breakpoints defined'])
+
+  s:RunDbgCmd(buf, 'cont')
+
+  # Make sure the breakpoints are removed
+  s:RunDbgCmd(buf, ':echo Foo()', ['19'])
+
+  # Delete a non-existing breakpoint
+  s:RunDbgCmd(buf, ':breakdel 2', ['E161: Breakpoint not found: 2'])
+
+  # Expression breakpoint
+  s:RunDbgCmd(buf, ':breakadd func 2 Bazz')
+  s:RunDbgCmd(buf, ':echo Bazz(1)', [
+	      'Entering Debug mode.  Type "cont" to continue.',
+	      'function Bazz',
+	      'line 2: let var1 = 3 + a:var'])
+  s:RunDbgCmd(buf, 'step')
+  s:RunDbgCmd(buf, 'step')
+  s:RunDbgCmd(buf, 'breaka expr var3')
+  s:RunDbgCmd(buf, 'breakl', ['  3  func Bazz  line 2',
 	      \ '  4  expr var3'])
-  call RunDbgCmd(buf, 'cont', ['Breakpoint in "Bazz" line 5',
-	      \ 'Oldval = "''another var''"',
-	      \ 'Newval = "''value2''"',
-	      \ 'function Bazz',
-	      \ 'line 5: catch'])
-
-  call RunDbgCmd(buf, 'breakdel *')
-  call RunDbgCmd(buf, 'breakl', ['No breakpoints defined'])
-
-  " Check for error cases
-  call RunDbgCmd(buf, 'breakadd abcd', [
-	      \ 'Error detected while processing function Bazz:',
-	      \ 'line    5:',
-	      \ 'E475: Invalid argument: abcd'])
-  call RunDbgCmd(buf, 'breakadd func', ['E475: Invalid argument: func'])
-  call RunDbgCmd(buf, 'breakadd func 2', ['E475: Invalid argument: func 2'])
-  call RunDbgCmd(buf, 'breaka func a()', ['E475: Invalid argument: func a()'])
-  call RunDbgCmd(buf, 'breakd abcd', ['E475: Invalid argument: abcd'])
-  call RunDbgCmd(buf, 'breakd func', ['E475: Invalid argument: func'])
-  call RunDbgCmd(buf, 'breakd func a()', ['E475: Invalid argument: func a()'])
-  call RunDbgCmd(buf, 'breakd func a', ['E161: Breakpoint not found: func a'])
-  call RunDbgCmd(buf, 'breakd expr', ['E475: Invalid argument: expr'])
-  call RunDbgCmd(buf, 'breakd expr x', ['E161: Breakpoint not found: expr x'])
-
-  " finish the current function
-  call RunDbgCmd(buf, 'finish', [
-	      \ 'function Bazz',
-	      \ 'line 8: End of function'])
-  call RunDbgCmd(buf, 'cont')
-
-  " Test for :next
-  call RunDbgCmd(buf, ':debug echo Bar(1)')
-  call RunDbgCmd(buf, 'step')
-  call RunDbgCmd(buf, 'next')
-  call RunDbgCmd(buf, '', [
-	      \ 'function Bar',
-	      \ 'line 3: return var2'])
-  call RunDbgCmd(buf, 'c')
-
-  " Test for :interrupt
-  call RunDbgCmd(buf, ':debug echo Bazz(1)')
-  call RunDbgCmd(buf, 'step')
-  call RunDbgCmd(buf, 'step')
-  call RunDbgCmd(buf, 'interrupt', [
-	      \ 'Exception thrown: Vim:Interrupt',
-	      \ 'function Bazz',
-	      \ 'line 5: catch'])
-  call RunDbgCmd(buf, 'c')
-
-  " Test showing local variable in :def function
-  call RunDbgCmd(buf, ':breakadd func 2 Vim9Func')
-  call RunDbgCmd(buf, ':call Vim9Func()', ['line 2:             for _ in [1, 2]'])
-  call RunDbgCmd(buf, 'next', ['line 2: for _ in [1, 2]'])
-  call RunDbgCmd(buf, 'echo cmd', ['confirm'])
-  call RunDbgCmd(buf, 'breakdel *')
-  call RunDbgCmd(buf, 'cont')
-
-  " Test for :quit
-  call RunDbgCmd(buf, ':debug echo Foo()')
-  call RunDbgCmd(buf, 'breakdel *')
-  call RunDbgCmd(buf, 'breakadd func 3 Foo')
-  call RunDbgCmd(buf, 'breakadd func 3 Bazz')
-  call RunDbgCmd(buf, 'cont', [
-	      \ 'Breakpoint in "Bazz" line 3',
-	      \ 'function Foo[2]..Bar[2]..Bazz',
-	      \ 'line 3: let var3 = "another var"'])
-  call RunDbgCmd(buf, 'quit', [
-	      \ 'Breakpoint in "Foo" line 3',
-	      \ 'function Foo',
-	      \ 'line 3: return var2'])
-  call RunDbgCmd(buf, 'breakdel *')
-  call RunDbgCmd(buf, 'quit')
-  call RunDbgCmd(buf, 'enew! | only!')
-
-  call StopVimInTerminal(buf)
-endfunc
+  s:RunDbgCmd(buf, 'cont', ['Breakpoint in "Bazz" line 5',
+	      'Oldval = "''another var''"',
+	      'Newval = "''value2''"',
+	      'function Bazz',
+	      'line 5: catch'])
+
+  s:RunDbgCmd(buf, 'breakdel *')
+  s:RunDbgCmd(buf, 'breakl', ['No breakpoints defined'])
+
+  # Check for error cases
+  s:RunDbgCmd(buf, 'breakadd abcd', [
+	      'Error detected while processing function Bazz:',
+	      'line    5:',
+	      'E475: Invalid argument: abcd'])
+  s:RunDbgCmd(buf, 'breakadd func', ['E475: Invalid argument: func'])
+  s:RunDbgCmd(buf, 'breakadd func 2', ['E475: Invalid argument: func 2'])
+  s:RunDbgCmd(buf, 'breaka func a()', ['E475: Invalid argument: func a()'])
+  s:RunDbgCmd(buf, 'breakd abcd', ['E475: Invalid argument: abcd'])
+  s:RunDbgCmd(buf, 'breakd func', ['E475: Invalid argument: func'])
+  s:RunDbgCmd(buf, 'breakd func a()', ['E475: Invalid argument: func a()'])
+  s:RunDbgCmd(buf, 'breakd func a', ['E161: Breakpoint not found: func a'])
+  s:RunDbgCmd(buf, 'breakd expr', ['E475: Invalid argument: expr'])
+  s:RunDbgCmd(buf, 'breakd expr x', ['E161: Breakpoint not found: expr x'])
+
+  # finish the current function
+  s:RunDbgCmd(buf, 'finish', [
+	      'function Bazz',
+	      'line 8: End of function'])
+  s:RunDbgCmd(buf, 'cont')
+
+  # Test for :next
+  s:RunDbgCmd(buf, ':debug echo Bar(1)')
+  s:RunDbgCmd(buf, 'step')
+  s:RunDbgCmd(buf, 'next')
+  s:RunDbgCmd(buf, '', [
+	      'function Bar',
+	      'line 3: return var2'])
+  s:RunDbgCmd(buf, 'c')
+
+  # Test for :interrupt
+  s:RunDbgCmd(buf, ':debug echo Bazz(1)')
+  s:RunDbgCmd(buf, 'step')
+  s:RunDbgCmd(buf, 'step')
+  s:RunDbgCmd(buf, 'interrupt', [
+	      'Exception thrown: Vim:Interrupt',
+	      'function Bazz',
+	      'line 5: catch'])
+  s:RunDbgCmd(buf, 'c')
+
+  # Test showing local variable in :def function
+  s:RunDbgCmd(buf, ':breakadd func 2 Vim9Func')
+  s:RunDbgCmd(buf, ':call Vim9Func()', ['line 2:             for _ in [1, 2]'])
+  s:RunDbgCmd(buf, 'next', ['line 2: for _ in [1, 2]'])
+  s:RunDbgCmd(buf, 'echo cmd', ['confirm'])
+  s:RunDbgCmd(buf, 'breakdel *')
+  s:RunDbgCmd(buf, 'cont')
+
+  # Test for :quit
+  s:RunDbgCmd(buf, ':debug echo Foo()')
+  s:RunDbgCmd(buf, 'breakdel *')
+  s:RunDbgCmd(buf, 'breakadd func 3 Foo')
+  s:RunDbgCmd(buf, 'breakadd func 3 Bazz')
+  s:RunDbgCmd(buf, 'cont', [
+	      'Breakpoint in "Bazz" line 3',
+	      'function Foo[2]..Bar[2]..Bazz',
+	      'line 3: let var3 = "another var"'])
+  s:RunDbgCmd(buf, 'quit', [
+	      'Breakpoint in "Foo" line 3',
+	      'function Foo',
+	      'line 3: return var2'])
+  s:RunDbgCmd(buf, 'breakdel *')
+  s:RunDbgCmd(buf, 'quit')
+  s:RunDbgCmd(buf, 'enew! | only!')
+
+  g:StopVimInTerminal(buf)
+enddef
 
 func Test_Debugger_breakadd()
   " Tests for :breakadd file and :breakadd here
@@ -347,11 +347,11 @@ func Test_Debugger_breakadd()
 
   " Start Vim in a terminal
   let buf = RunVimInTerminal('XdebugBreakadd.vim', {})
-  call RunDbgCmd(buf, ':breakadd file 2 XdebugBreakadd.vim')
-  call RunDbgCmd(buf, ':4 | breakadd here')
-  call RunDbgCmd(buf, ':source XdebugBreakadd.vim', ['line 2: let var2 = 20'])
-  call RunDbgCmd(buf, 'cont', ['line 4: let var4 = 40'])
-  call RunDbgCmd(buf, 'cont')
+  call s:RunDbgCmd(buf, ':breakadd file 2 XdebugBreakadd.vim')
+  call s:RunDbgCmd(buf, ':4 | breakadd here')
+  call s:RunDbgCmd(buf, ':source XdebugBreakadd.vim', ['line 2: let var2 = 20'])
+  call s:RunDbgCmd(buf, 'cont', ['line 4: let var4 = 40'])
+  call s:RunDbgCmd(buf, 'cont')
 
   call StopVimInTerminal(buf)
 
@@ -372,24 +372,24 @@ func Test_Debugger_breakadd_expr()
 
   " Start Vim in a terminal
   let buf = RunVimInTerminal('XdebugBreakExpr.vim', {})
-  call RunDbgCmd(buf, ':let g:Xtest_var = 10')
-  call RunDbgCmd(buf, ':breakadd expr g:Xtest_var')
-  call RunDbgCmd(buf, ':source %')
+  call s:RunDbgCmd(buf, ':let g:Xtest_var = 10')
+  call s:RunDbgCmd(buf, ':breakadd expr g:Xtest_var')
+  call s:RunDbgCmd(buf, ':source %')
   let expected =<< trim eval END
     Oldval = "10"
     Newval = "11"
     {fnamemodify('XdebugBreakExpr.vim', ':p')}
     line 1: let g:Xtest_var += 1
   END
-  call RunDbgCmd(buf, ':source %', expected)
-  call RunDbgCmd(buf, 'cont')
+  call s:RunDbgCmd(buf, ':source %', expected)
+  call s:RunDbgCmd(buf, 'cont')
   let expected =<< trim eval END
     Oldval = "11"
     Newval = "12"
     {fnamemodify('XdebugBreakExpr.vim', ':p')}
     line 1: let g:Xtest_var += 1
   END
-  call RunDbgCmd(buf, ':source %', expected)
+  call s:RunDbgCmd(buf, ':source %', expected)
 
   call StopVimInTerminal(buf)
 endfunc
@@ -411,9 +411,9 @@ def Test_Debugger_breakadd_vim9_expr()
   call g:TermWait(buf, g:RunningWithValgrind() ? 1000 : 50)
 
   # Despite the failure the functions are defined
-  g:RunDbgCmd(buf, ':function g:EarlyFunc',
+  s:RunDbgCmd(buf, ':function g:EarlyFunc',
      ['function EarlyFunc()', 'endfunction'], {match: 'pattern'})
-  g:RunDbgCmd(buf, ':function g:LaterFunc',
+  s:RunDbgCmd(buf, ':function g:LaterFunc',
      ['function LaterFunc()', 'endfunction'], {match: 'pattern'})
 
   call g:StopVimInTerminal(buf)
@@ -435,7 +435,7 @@ def Test_Debugger_break_at_return()
   var buf = g:RunVimInTerminal('-S XdebugBreakRet.vim', {wait_for_ruler: 0})
   call g:TermWait(buf, g:RunningWithValgrind() ? 1000 : 50)
 
-  g:RunDbgCmd(buf, ':call GetNum()',
+  s:RunDbgCmd(buf, ':call GetNum()',
      ['line 1: return 1  + 2  + 3'], {match: 'pattern'})
 
   call g:StopVimInTerminal(buf)
@@ -474,19 +474,19 @@ func Test_Backtrace_Through_Source()
 
   let buf = RunVimInTerminal('-S Xtest1.vim', {})
 
-  call RunDbgCmd(buf,
+  call s:RunDbgCmd(buf,
                 \ ':debug call GlobalFunction()',
                 \ ['cmd: call GlobalFunction()'])
-  call RunDbgCmd(buf, 'step', ['line 1: call CallAFunction()'])
+  call s:RunDbgCmd(buf, 'step', ['line 1: call CallAFunction()'])
 
-  call RunDbgCmd(buf, 'backtrace', ['>backtrace',
+  call s:RunDbgCmd(buf, 'backtrace', ['>backtrace',
                                     \ '->0 function GlobalFunction',
                                     \ 'line 1: call CallAFunction()'])
 
-  call RunDbgCmd(buf, 'step', ['line 1: call SourceAnotherFile()'])
-  call RunDbgCmd(buf, 'step', ['line 1: source Xtest2.vim'])
+  call s:RunDbgCmd(buf, 'step', ['line 1: call SourceAnotherFile()'])
+  call s:RunDbgCmd(buf, 'step', ['line 1: source Xtest2.vim'])
 
-  call RunDbgCmd(buf, 'backtrace', ['>backtrace',
+  call s:RunDbgCmd(buf, 'backtrace', ['>backtrace',
                                     \ '  2 function GlobalFunction[1]',
                                     \ '  1 CallAFunction[1]',
                                     \ '->0 SourceAnotherFile',
@@ -494,8 +494,8 @@ func Test_Backtrace_Through_Source()
 
   " Step into the 'source' command. Note that we print the full trace all the
   " way though the source command.
-  call RunDbgCmd(buf, 'step', ['line 1: func DoAThing()'])
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'step', ['line 1: func DoAThing()'])
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '>backtrace',
         \ '  3 function GlobalFunction[1]',
         \ '  2 CallAFunction[1]',
@@ -503,8 +503,8 @@ func Test_Backtrace_Through_Source()
         \ '->0 script ' .. getcwd() .. '/Xtest2.vim',
         \ 'line 1: func DoAThing()'])
 
-  call RunDbgCmd( buf, 'up' )
-  call RunDbgCmd( buf, 'backtrace', [
+  call s:RunDbgCmd( buf, 'up' )
+  call s:RunDbgCmd( buf, 'backtrace', [
         \ '>backtrace',
         \ '  3 function GlobalFunction[1]',
         \ '  2 CallAFunction[1]',
@@ -512,8 +512,8 @@ func Test_Backtrace_Through_Source()
         \ '  0 script ' .. getcwd() .. '/Xtest2.vim',
         \ 'line 1: func DoAThing()' ] )
 
-  call RunDbgCmd( buf, 'up' )
-  call RunDbgCmd( buf, 'backtrace', [
+  call s:RunDbgCmd( buf, 'up' )
+  call s:RunDbgCmd( buf, 'backtrace', [
         \ '>backtrace',
         \ '  3 function GlobalFunction[1]',
         \ '->2 CallAFunction[1]',
@@ -521,8 +521,8 @@ func Test_Backtrace_Through_Source()
         \ '  0 script ' .. getcwd() .. '/Xtest2.vim',
         \ 'line 1: func DoAThing()' ] )
 
-  call RunDbgCmd( buf, 'up' )
-  call RunDbgCmd( buf, 'backtrace', [
+  call s:RunDbgCmd( buf, 'up' )
+  call s:RunDbgCmd( buf, 'backtrace', [
         \ '>backtrace',
         \ '->3 function GlobalFunction[1]',
         \ '  2 CallAFunction[1]',
@@ -530,8 +530,8 @@ func Test_Backtrace_Through_Source()
         \ '  0 script ' .. getcwd() .. '/Xtest2.vim',
         \ 'line 1: func DoAThing()' ] )
 
-  call RunDbgCmd( buf, 'up', [ 'frame at highest level: 3' ] )
-  call RunDbgCmd( buf, 'backtrace', [
+  call s:RunDbgCmd( buf, 'up', [ 'frame at highest level: 3' ] )
+  call s:RunDbgCmd( buf, 'backtrace', [
         \ '>backtrace',
         \ '->3 function GlobalFunction[1]',
         \ '  2 CallAFunction[1]',
@@ -539,8 +539,8 @@ func Test_Backtrace_Through_Source()
         \ '  0 script ' .. getcwd() .. '/Xtest2.vim',
         \ 'line 1: func DoAThing()' ] )
 
-  call RunDbgCmd( buf, 'down' )
-  call RunDbgCmd( buf, 'backtrace', [
+  call s:RunDbgCmd( buf, 'down' )
+  call s:RunDbgCmd( buf, 'backtrace', [
         \ '>backtrace',
         \ '  3 function GlobalFunction[1]',
         \ '->2 CallAFunction[1]',
@@ -548,8 +548,8 @@ func Test_Backtrace_Through_Source()
         \ '  0 script ' .. getcwd() .. '/Xtest2.vim',
         \ 'line 1: func DoAThing()' ] )
 
-  call RunDbgCmd( buf, 'down' )
-  call RunDbgCmd( buf, 'backtrace', [
+  call s:RunDbgCmd( buf, 'down' )
+  call s:RunDbgCmd( buf, 'backtrace', [
         \ '>backtrace',
         \ '  3 function GlobalFunction[1]',
         \ '  2 CallAFunction[1]',
@@ -557,8 +557,8 @@ func Test_Backtrace_Through_Source()
         \ '  0 script ' .. getcwd() .. '/Xtest2.vim',
         \ 'line 1: func DoAThing()' ] )
 
-  call RunDbgCmd( buf, 'down' )
-  call RunDbgCmd( buf, 'backtrace', [
+  call s:RunDbgCmd( buf, 'down' )
+  call s:RunDbgCmd( buf, 'backtrace', [
         \ '>backtrace',
         \ '  3 function GlobalFunction[1]',
         \ '  2 CallAFunction[1]',
@@ -566,12 +566,12 @@ func Test_Backtrace_Through_Source()
         \ '->0 script ' .. getcwd() .. '/Xtest2.vim',
         \ 'line 1: func DoAThing()' ] )
 
-  call RunDbgCmd( buf, 'down', [ 'frame is zero' ] )
+  call s:RunDbgCmd( buf, 'down', [ 'frame is zero' ] )
 
   " step until we have another meaningful trace
-  call RunDbgCmd(buf, 'step', ['line 5: func File2Function()'])
-  call RunDbgCmd(buf, 'step', ['line 9: call File2Function()'])
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'step', ['line 5: func File2Function()'])
+  call s:RunDbgCmd(buf, 'step', ['line 9: call File2Function()'])
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '>backtrace',
         \ '  3 function GlobalFunction[1]',
         \ '  2 CallAFunction[1]',
@@ -579,9 +579,9 @@ func Test_Backtrace_Through_Source()
         \ '->0 script ' .. getcwd() .. '/Xtest2.vim',
         \ 'line 9: call File2Function()'])
 
-  call RunDbgCmd(buf, 'step', ['line 1: call DoAThing()'])
-  call RunDbgCmd(buf, 'step', ['line 1: echo "DoAThing"'])
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'step', ['line 1: call DoAThing()'])
+  call s:RunDbgCmd(buf, 'step', ['line 1: echo "DoAThing"'])
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '>backtrace',
         \ '  5 function GlobalFunction[1]',
         \ '  4 CallAFunction[1]',
@@ -592,19 +592,19 @@ func Test_Backtrace_Through_Source()
         \ 'line 1: echo "DoAThing"'])
 
   " Now, step (back to Xfile1.vim), and call the function _in_ Xfile2.vim
-  call RunDbgCmd(buf, 'step', ['line 1: End of function'])
-  call RunDbgCmd(buf, 'step', ['line 1: End of function'])
-  call RunDbgCmd(buf, 'step', ['line 10: End of sourced file'])
-  call RunDbgCmd(buf, 'step', ['line 1: End of function'])
-  call RunDbgCmd(buf, 'step', ['line 2: call File2Function()'])
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'step', ['line 1: End of function'])
+  call s:RunDbgCmd(buf, 'step', ['line 1: End of function'])
+  call s:RunDbgCmd(buf, 'step', ['line 10: End of sourced file'])
+  call s:RunDbgCmd(buf, 'step', ['line 1: End of function'])
+  call s:RunDbgCmd(buf, 'step', ['line 2: call File2Function()'])
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '>backtrace',
         \ '  1 function GlobalFunction[1]',
         \ '->0 CallAFunction',
         \ 'line 2: call File2Function()'])
 
-  call RunDbgCmd(buf, 'step', ['line 1: call DoAThing()'])
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'step', ['line 1: call DoAThing()'])
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '>backtrace',
         \ '  2 function GlobalFunction[1]',
         \ '  1 CallAFunction[2]',
@@ -649,29 +649,29 @@ func Test_Backtrace_Autocmd()
 
   let buf = RunVimInTerminal('-S Xtest1.vim', {})
 
-  call RunDbgCmd(buf,
+  call s:RunDbgCmd(buf,
                 \ ':debug doautocmd User TestGlobalFunction',
                 \ ['cmd: doautocmd User TestGlobalFunction'])
-  call RunDbgCmd(buf, 'step', ['cmd: call GlobalFunction() | echo "Done"'])
+  call s:RunDbgCmd(buf, 'step', ['cmd: call GlobalFunction() | echo "Done"'])
 
   " At this point the only thing in the stack is the autocommand
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '>backtrace',
         \ '->0 User Autocommands for "TestGlobalFunction"',
         \ 'cmd: call GlobalFunction() | echo "Done"'])
 
   " And now we're back into the call stack
-  call RunDbgCmd(buf, 'step', ['line 1: call CallAFunction()'])
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'step', ['line 1: call CallAFunction()'])
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '>backtrace',
         \ '  1 User Autocommands for "TestGlobalFunction"',
         \ '->0 function GlobalFunction',
         \ 'line 1: call CallAFunction()'])
 
-  call RunDbgCmd(buf, 'step', ['line 1: call SourceAnotherFile()'])
-  call RunDbgCmd(buf, 'step', ['line 1: source Xtest2.vim'])
+  call s:RunDbgCmd(buf, 'step', ['line 1: call SourceAnotherFile()'])
+  call s:RunDbgCmd(buf, 'step', ['line 1: source Xtest2.vim'])
 
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '>backtrace',
         \ '  3 User Autocommands for "TestGlobalFunction"',
         \ '  2 function GlobalFunction[1]',
@@ -681,8 +681,8 @@ func Test_Backtrace_Autocmd()
 
   " Step into the 'source' command. Note that we print the full trace all the
   " way though the source command.
-  call RunDbgCmd(buf, 'step', ['line 1: func DoAThing()'])
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'step', ['line 1: func DoAThing()'])
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '>backtrace',
         \ '  4 User Autocommands for "TestGlobalFunction"',
         \ '  3 function GlobalFunction[1]',
@@ -691,8 +691,8 @@ func Test_Backtrace_Autocmd()
         \ '->0 script ' .. getcwd() .. '/Xtest2.vim',
         \ 'line 1: func DoAThing()'])
 
-  call RunDbgCmd( buf, 'up' )
-  call RunDbgCmd( buf, 'backtrace', [
+  call s:RunDbgCmd( buf, 'up' )
+  call s:RunDbgCmd( buf, 'backtrace', [
         \ '>backtrace',
         \ '  4 User Autocommands for "TestGlobalFunction"',
         \ '  3 function GlobalFunction[1]',
@@ -701,8 +701,8 @@ func Test_Backtrace_Autocmd()
         \ '  0 script ' .. getcwd() .. '/Xtest2.vim',
         \ 'line 1: func DoAThing()' ] )
 
-  call RunDbgCmd( buf, 'up' )
-  call RunDbgCmd( buf, 'backtrace', [
+  call s:RunDbgCmd( buf, 'up' )
+  call s:RunDbgCmd( buf, 'backtrace', [
         \ '>backtrace',
         \ '  4 User Autocommands for "TestGlobalFunction"',
         \ '  3 function GlobalFunction[1]',
@@ -711,8 +711,8 @@ func Test_Backtrace_Autocmd()
         \ '  0 script ' .. getcwd() .. '/Xtest2.vim',
         \ 'line 1: func DoAThing()' ] )
 
-  call RunDbgCmd( buf, 'up' )
-  call RunDbgCmd( buf, 'backtrace', [
+  call s:RunDbgCmd( buf, 'up' )
+  call s:RunDbgCmd( buf, 'backtrace', [
         \ '>backtrace',
         \ '  4 User Autocommands for "TestGlobalFunction"',
         \ '->3 function GlobalFunction[1]',
@@ -721,8 +721,8 @@ func Test_Backtrace_Autocmd()
         \ '  0 script ' .. getcwd() .. '/Xtest2.vim',
         \ 'line 1: func DoAThing()' ] )
 
-  call RunDbgCmd( buf, 'up' )
-  call RunDbgCmd( buf, 'backtrace', [
+  call s:RunDbgCmd( buf, 'up' )
+  call s:RunDbgCmd( buf, 'backtrace', [
         \ '>backtrace',
         \ '->4 User Autocommands for "TestGlobalFunction"',
         \ '  3 function GlobalFunction[1]',
@@ -731,8 +731,8 @@ func Test_Backtrace_Autocmd()
         \ '  0 script ' .. getcwd() .. '/Xtest2.vim',
         \ 'line 1: func DoAThing()' ] )
 
-  call RunDbgCmd( buf, 'up', [ 'frame at highest level: 4' ] )
-  call RunDbgCmd( buf, 'backtrace', [
+  call s:RunDbgCmd( buf, 'up', [ 'frame at highest level: 4' ] )
+  call s:RunDbgCmd( buf, 'backtrace', [
         \ '>backtrace',
         \ '->4 User Autocommands for "TestGlobalFunction"',
         \ '  3 function GlobalFunction[1]',
@@ -741,8 +741,8 @@ func Test_Backtrace_Autocmd()
         \ '  0 script ' .. getcwd() .. '/Xtest2.vim',
         \ 'line 1: func DoAThing()' ] )
 
-  call RunDbgCmd( buf, 'down' )
-  call RunDbgCmd( buf, 'backtrace', [
+  call s:RunDbgCmd( buf, 'down' )
+  call s:RunDbgCmd( buf, 'backtrace', [