diff --git a/test/old/testdir/test_debugger.vim b/test/old/testdir/test_debugger.vim
index 0754747193..161c2c3c13 100644
--- a/test/old/testdir/test_debugger.vim
+++ b/test/old/testdir/test_debugger.vim
@@ -35,7 +35,7 @@ endfunc
 
 " Run a Vim debugger command
 " If the expected output argument is supplied, then check for it.
-func RunDbgCmd(buf, cmd, ...)
+func s:RunDbgCmd(buf, cmd, ...)
   call term_sendkeys(a:buf, a:cmd . "\r")
   call TermWait(a:buf)
 
@@ -88,248 +88,248 @@ func Test_Debugger()
   let buf = RunVimInTerminal('-S XtestDebug.vim', {})
 
   " Start the Vim debugger
-  call RunDbgCmd(buf, ':debug echo Foo()', ['cmd: echo Foo()'])
+  call s: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"'])
+  call s:RunDbgCmd(buf, 'step', ['line 1: let var1 = 1'])
+  call s:RunDbgCmd(buf, 'step', ['line 2: let var2 = Bar(var1) + 9'])
+  call s:RunDbgCmd(buf, 'step', ['line 1: let var1 = 2 + a:var'])
+  call s:RunDbgCmd(buf, 'step', ['line 2: let var2 = Bazz(var1) + 4'])
+  call s:RunDbgCmd(buf, 'step', ['line 1: try'])
+  call s:RunDbgCmd(buf, 'step', ['line 2: let var1 = 3 + a:var'])
+  call s:RunDbgCmd(buf, 'step', ['line 3: let var3 = "another var"'])
 
   " check backtrace
-  call RunDbgCmd(buf, 'backtrace', [
+  call 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
-  call RunDbgCmd(buf, 'echo var1', ['6'])
+  call s:RunDbgCmd(buf, 'echo var1', ['6'])
 
-  call RunDbgCmd(buf, 'up')
-  call RunDbgCmd(buf, 'back', [
+  call s:RunDbgCmd(buf, 'up')
+  call s: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 s:RunDbgCmd(buf, 'echo var1', ['3'])
 
-  call RunDbgCmd(buf, 'u')
-  call RunDbgCmd(buf, 'bt', [
+  call s:RunDbgCmd(buf, 'u')
+  call s:RunDbgCmd(buf, 'bt', [
 	      \ '->2 function Foo[2]',
 	      \ '  1 Bar[2]',
 	      \ '  0 Bazz',
 	      \ 'line 3: let var3 = "another var"'])
-  call RunDbgCmd(buf, 'echo var1', ['1'])
+  call s:RunDbgCmd(buf, 'echo var1', ['1'])
 
   " Undefined variables
-  call RunDbgCmd(buf, 'step')
-  call RunDbgCmd(buf, 'frame 2')
-  call RunDbgCmd(buf, 'echo var3', [
+  call s:RunDbgCmd(buf, 'step')
+  call s:RunDbgCmd(buf, 'frame 2')
+  call s:RunDbgCmd(buf, 'echo var3', [
 	\ 'Error in 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 s:RunDbgCmd(buf, 'fr 0')
+  call s: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', [
+  call s:RunDbgCmd(buf, 'step')
+  call s:RunDbgCmd(buf, '')
+  call s:RunDbgCmd(buf, '')
+  call s:RunDbgCmd(buf, '')
+  call s:RunDbgCmd(buf, '')
+  call s:RunDbgCmd(buf, 'step', [
 	      \ 'function Foo[2]..Bar',
 	      \ 'line 3: End of function'])
-  call RunDbgCmd(buf, 'up')
+  call s:RunDbgCmd(buf, 'up')
 
   " Undefined var2
-  call RunDbgCmd(buf, 'echo var2', [
+  call s:RunDbgCmd(buf, 'echo var2', [
 	      \ 'Error in 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'])
+  call s:RunDbgCmd(buf, 'down')
+  call s:RunDbgCmd(buf, 'echo var2', ['10'])
 
   " Backtrace movements
-  call RunDbgCmd(buf, 'b', [
+  call s: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')
+  call s:RunDbgCmd(buf, 'down', ['frame is zero'])
+  call s: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', [
+  call s:RunDbgCmd(buf, 'up', ['frame at highest level: 1'])
+  call s: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--'])
+  call s:RunDbgCmd(buf, 'fil', ['"[No Name]" --No lines in buffer--'])
 
   " relative backtrace movement
-  call RunDbgCmd(buf, 'fr -1')
-  call RunDbgCmd(buf, 'frame', [
+  call s:RunDbgCmd(buf, 'fr -1')
+  call s:RunDbgCmd(buf, 'frame', [
 	      \ '  1 function Foo[2]',
 	      \ '->0 Bar',
 	      \ 'line 3: End of function'])
 
-  call RunDbgCmd(buf, 'fr +1')
-  call RunDbgCmd(buf, 'fram', [
+  call s:RunDbgCmd(buf, 'fr +1')
+  call s: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', [
+  call s:RunDbgCmd(buf, 'fr 100', ['frame at highest level: 1'])
+  call s: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', [
+  call s:RunDbgCmd(buf, 'frame -40', ['frame is zero'])
+  call s:RunDbgCmd(buf, 'fram', [
 	      \ '  1 function Foo[2]',
 	      \ '->0 Bar',
 	      \ 'line 3: End of function'])
 
   " final result 19
-  call RunDbgCmd(buf, 'cont', ['19'])
+  call s: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()'])
+  call s:RunDbgCmd(buf, ':debug echo Foo()', ['cmd: echo Foo()'])
 
   " No breakpoints
-  call RunDbgCmd(buf, 'breakl', ['No breakpoints defined'])
+  call s: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',
+  call s:RunDbgCmd(buf, 'breaka func Bar')
+  call s:RunDbgCmd(buf, 'breaklis', ['  1  func Bar  line 1'])
+  call s:RunDbgCmd(buf, 'breakadd func 3 Bazz')
+  call s:RunDbgCmd(buf, 'breaklist', ['  1  func Bar  line 1',
 	      \ '  2  func Bazz  line 3'])
 
   " Check whether the breakpoints are hit
-  call RunDbgCmd(buf, 'cont', [
+  call s:RunDbgCmd(buf, 'cont', [
 	      \ 'Breakpoint in "Bar" line 1',
 	      \ 'function Foo[2]..Bar',
 	      \ 'line 1: let var1 = 2 + a:var'])
-  call RunDbgCmd(buf, 'cont', [
+  call s: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 s:RunDbgCmd(buf, 'breakd 1')
+  call s:RunDbgCmd(buf, 'breakli', ['  2  func Bazz  line 3'])
+  call s:RunDbgCmd(buf, 'breakdel func 3 Bazz')
+  call s:RunDbgCmd(buf, 'breakl', ['No breakpoints defined'])
 
-  call RunDbgCmd(buf, 'cont')
+  call s:RunDbgCmd(buf, 'cont')
 
   " Make sure the breakpoints are removed
-  call RunDbgCmd(buf, ':echo Foo()', ['19'])
+  call s:RunDbgCmd(buf, ':echo Foo()', ['19'])
 
   " Delete a non-existing breakpoint
-  call RunDbgCmd(buf, ':breakdel 2', ['E161: Breakpoint not found: 2'])
+  call s:RunDbgCmd(buf, ':breakdel 2', ['E161: Breakpoint not found: 2'])
 
   " Expression breakpoint
-  call RunDbgCmd(buf, ':breakadd func 2 Bazz')
-  call RunDbgCmd(buf, ':echo Bazz(1)', [
+  call s:RunDbgCmd(buf, ':breakadd func 2 Bazz')
+  call s: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',
+  call s:RunDbgCmd(buf, 'step')
+  call s:RunDbgCmd(buf, 'step')
+  call s:RunDbgCmd(buf, 'breaka expr var3')
+  call s:RunDbgCmd(buf, 'breakl', ['  3  func Bazz  line 2',
 	      \ '  4  expr var3'])
-  call RunDbgCmd(buf, 'cont', ['Breakpoint in "Bazz" line 5',
+  call s: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'])
+  call s:RunDbgCmd(buf, 'breakdel *')
+  call s:RunDbgCmd(buf, 'breakl', ['No breakpoints defined'])
 
   " Check for error cases
-  call RunDbgCmd(buf, 'breakadd abcd', [
+  call s:RunDbgCmd(buf, 'breakadd abcd', [
 	      \ 'Error in 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'])
+  call s:RunDbgCmd(buf, 'breakadd func', ['E475: Invalid argument: func'])
+  call s:RunDbgCmd(buf, 'breakadd func 2', ['E475: Invalid argument: func 2'])
+  call s:RunDbgCmd(buf, 'breaka func a()', ['E475: Invalid argument: func a()'])
+  call s:RunDbgCmd(buf, 'breakd abcd', ['E475: Invalid argument: abcd'])
+  call s:RunDbgCmd(buf, 'breakd func', ['E475: Invalid argument: func'])
+  call s:RunDbgCmd(buf, 'breakd func a()', ['E475: Invalid argument: func a()'])
+  call s:RunDbgCmd(buf, 'breakd func a', ['E161: Breakpoint not found: func a'])
+  call s:RunDbgCmd(buf, 'breakd expr', ['E475: Invalid argument: expr'])
+  call s:RunDbgCmd(buf, 'breakd expr x', ['E161: Breakpoint not found: expr x'])
 
   " finish the current function
-  call RunDbgCmd(buf, 'finish', [
+  call s:RunDbgCmd(buf, 'finish', [
 	      \ 'function Bazz',
 	      \ 'line 8: End of function'])
-  call RunDbgCmd(buf, 'cont')
+  call s:RunDbgCmd(buf, 'cont')
 
   " Test for :next
-  call RunDbgCmd(buf, ':debug echo Bar(1)')
-  call RunDbgCmd(buf, 'step')
-  call RunDbgCmd(buf, 'next')
-  call RunDbgCmd(buf, '', [
+  call s:RunDbgCmd(buf, ':debug echo Bar(1)')
+  call s:RunDbgCmd(buf, 'step')
+  call s:RunDbgCmd(buf, 'next')
+  call s:RunDbgCmd(buf, '', [
 	      \ 'function Bar',
 	      \ 'line 3: return var2'])
-  call RunDbgCmd(buf, 'c')
+  call s: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', [
+  call s:RunDbgCmd(buf, ':debug echo Bazz(1)')
+  call s:RunDbgCmd(buf, 'step')
+  call s:RunDbgCmd(buf, 'step')
+  call s:RunDbgCmd(buf, 'interrupt', [
 	      \ 'Exception thrown: Vim:Interrupt',
 	      \ 'function Bazz',
 	      \ 'line 5: catch'])
-  call RunDbgCmd(buf, 'c')
+  call s: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')
+  call s:RunDbgCmd(buf, ':breakadd func 2 Vim9Func')
+  call s:RunDbgCmd(buf, ':call Vim9Func()', ['line 2:             for _ in [1, 2]'])
+  call s:RunDbgCmd(buf, 'next', ['line 2: for _ in [1, 2]'])
+  call s:RunDbgCmd(buf, 'echo cmd', ['confirm'])
+  call s:RunDbgCmd(buf, 'breakdel *')
+  call s: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', [
+  call s:RunDbgCmd(buf, ':debug echo Foo()')
+  call s:RunDbgCmd(buf, 'breakdel *')
+  call s:RunDbgCmd(buf, 'breakadd func 3 Foo')
+  call s:RunDbgCmd(buf, 'breakadd func 3 Bazz')
+  call s:RunDbgCmd(buf, 'cont', [
 	      \ 'Breakpoint in "Bazz" line 3',
 	      \ 'function Foo[2]..Bar[2]..Bazz',
 	      \ 'line 3: let var3 = "another var"'])
-  call RunDbgCmd(buf, 'quit', [
+  call s: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 s:RunDbgCmd(buf, 'breakdel *')
+  call s:RunDbgCmd(buf, 'quit')
+  call s:RunDbgCmd(buf, 'enew! | only!')
 
   call StopVimInTerminal(buf)
 endfunc
@@ -349,11 +349,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)
 
@@ -375,24 +375,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
@@ -431,19 +431,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',
@@ -451,8 +451,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]',
@@ -460,8 +460,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]',
@@ -469,8 +469,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]',
@@ -478,8 +478,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]',
@@ -487,8 +487,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]',
@@ -496,8 +496,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]',
@@ -505,8 +505,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]',
@@ -514,8 +514,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]',
@@ -523,12 +523,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]',
@@ -536,9 +536,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]',
@@ -549,19 +549,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]',
@@ -607,29 +607,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]',
@@ -639,8 +639,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]',
@@ -649,8 +649,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]',
@@ -659,8 +659,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]',
@@ -669,8 +669,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]',
@@ -679,8 +679,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]',
@@ -689,8 +689,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]',
@@ -699,8 +699,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', [
         \ '>backtrace',
         \ '  4 User Autocommands for "TestGlobalFunction"',
         \ '->3 function GlobalFunction[1]',
@@ -710,8 +710,8 @@ func Test_Backtrace_Autocmd()
         \ 'line 1: func DoAThing()' ] )
 
 
-  call RunDbgCmd( buf, 'down' )
-  call RunDbgCmd( buf, 'backtrace', [
+  call s:RunDbgCmd( buf, 'down' )
+  call s:RunDbgCmd( buf, 'backtrace', [
         \ '>backtrace',
         \ '  4 User Autocommands for "TestGlobalFunction"',
         \ '  3 function GlobalFunction[1]',
@@ -720,8 +720,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', [
         \ '>backtrace',
         \ '  4 User Autocommands for "TestGlobalFunction"',
         \ '  3 function GlobalFunction[1]',
@@ -730,8 +730,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', [
         \ '>backtrace',
         \ '  4 User Autocommands for "TestGlobalFunction"',
         \ '  3 function GlobalFunction[1]',
@@ -740,12 +740,12 @@ func Test_Backtrace_Autocmd()
         \ '->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',
         \ '  4 User Autocommands for "TestGlobalFunction"',
         \ '  3 function GlobalFunction[1]',
@@ -754,9 +754,9 @@ func Test_Backtrace_Autocmd()
         \ '->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',
         \ '  6 User Autocommands for "TestGlobalFunction"',
         \ '  5 function GlobalFunction[1]',
@@ -768,20 +768,20 @@ func Test_Backtrace_Autocmd()
         \ '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',
         \ '  2 User Autocommands for "TestGlobalFunction"',
         \ '  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',
         \ '  3 User Autocommands for "TestGlobalFunction"',
         \ '  2 function GlobalFunction[1]',
@@ -792,8 +792,8 @@ func Test_Backtrace_Autocmd()
 
   " Now unwind so that we get back to the original autocommand (and the second
   " cmd echo "Done")
-  call RunDbgCmd(buf, 'finish', ['line 1: End of function'])
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'finish', ['line 1: End of function'])
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '>backtrace',
         \ '  3 User Autocommands for "TestGlobalFunction"',
         \ '  2 function GlobalFunction[1]',
@@ -801,23 +801,23 @@ func Test_Backtrace_Autocmd()
         \ '->0 File2Function',
         \ 'line 1: End of function'])
 
-  call RunDbgCmd(buf, 'finish', ['line 2: End of function'])
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'finish', ['line 2: End of function'])
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '>backtrace',
         \ '  2 User Autocommands for "TestGlobalFunction"',
         \ '  1 function GlobalFunction[1]',
         \ '->0 CallAFunction',
         \ 'line 2: End of function'])
 
-  call RunDbgCmd(buf, 'finish', ['line 1: End of function'])
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'finish', ['line 1: End of function'])
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '>backtrace',
         \ '  1 User Autocommands for "TestGlobalFunction"',
         \ '->0 function GlobalFunction',
         \ 'line 1: End of function'])
 
-  call RunDbgCmd(buf, 'step', ['cmd: echo "Done"'])
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'step', ['cmd: echo "Done"'])
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '>backtrace',
         \ '->0 User Autocommands for "TestGlobalFunction"',
         \ 'cmd: echo "Done"'])
@@ -869,14 +869,14 @@ func Test_Backtrace_CmdLine()
                             \ 'cmd: call GlobalFunction()'], #{msec: 5000})
 
   " At this point the only thing in the stack is the cmdline
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '>backtrace',
         \ '->0 command line',
         \ 'cmd: call GlobalFunction()'])
 
   " 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 command line',
         \ '->0 function GlobalFunction',
@@ -930,32 +930,32 @@ func Test_Backtrace_DefFunction()
 
   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: var some = "some var"'])
-  call RunDbgCmd(buf, 'step', ['line 2: CallAFunction()'])
-  call RunDbgCmd(buf, 'echo some', ['some var'])
+  call s:RunDbgCmd(buf, 'step', ['line 1: var some = "some var"'])
+  call s:RunDbgCmd(buf, 'step', ['line 2: CallAFunction()'])
+  call s:RunDbgCmd(buf, 'echo some', ['some var'])
 
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '\V>backtrace',
         \ '\V->0 function GlobalFunction',
         \ '\Vline 2: CallAFunction()',
         \ ],
         \ #{match: 'pattern'})
 
-  call RunDbgCmd(buf, 'step', ['line 1: SourceAnotherFile()'])
-  call RunDbgCmd(buf, 'step', ['line 1: source Xtest2.vim'])
+  call s:RunDbgCmd(buf, 'step', ['line 1: SourceAnotherFile()'])
+  call s:RunDbgCmd(buf, 'step', ['line 1: source Xtest2.vim'])
   " Repeated line, because we fist are in the compiled function before the
   " EXEC and then in do_cmdline() before the :source command.
-  call RunDbgCmd(buf, 'step', ['line 1: source Xtest2.vim'])
-  call RunDbgCmd(buf, 'step', ['line 1: vim9script'])
-  call RunDbgCmd(buf, 'step', ['line 3: def DoAThing(): number'])
-  call RunDbgCmd(buf, 'step', ['line 9: export def File2Function()'])
-  call RunDbgCmd(buf, 'step', ['line 13: defcompile'])
-  call RunDbgCmd(buf, 'step', ['line 14: File2Function()'])
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'step', ['line 1: source Xtest2.vim'])
+  call s:RunDbgCmd(buf, 'step', ['line 1: vim9script'])
+  call s:RunDbgCmd(buf, 'step', ['line 3: def DoAThing(): number'])
+  call s:RunDbgCmd(buf, 'step', ['line 9: export def File2Function()'])
+  call s:RunDbgCmd(buf, 'step', ['line 13: defcompile'])
+  call s:RunDbgCmd(buf, 'step', ['line 14: File2Function()'])
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '\V>backtrace',
         \ '\V  3 function GlobalFunction[2]',
         \ '\V  2 <SNR>\.\*_CallAFunction[1]',
@@ -965,8 +965,8 @@ func Test_Backtrace_DefFunction()
         \ #{match: 'pattern'})
 
   " Don't step into compiled functions...
-  call RunDbgCmd(buf, 'next', ['line 15: End of sourced file'])
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'next', ['line 15: End of sourced file'])
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '\V>backtrace',
         \ '\V  3 function GlobalFunction[2]',
         \ '\V  2 <SNR>\.\*_CallAFunction[1]',
@@ -993,8 +993,8 @@ func Test_DefFunction_expr()
   call writefile(file3, 'Xtest3.vim', 'D')
   let buf = RunVimInTerminal('-S Xtest3.vim', {})
 
-  call RunDbgCmd(buf, ':breakadd expr g:someVar')
-  call RunDbgCmd(buf, ':call g:ChangeVar()', ['Oldval = "''foo''"', 'Newval = "''bar''"', 'function ChangeVar', 'line 2: echo "changed"'])
+  call s:RunDbgCmd(buf, ':breakadd expr g:someVar')
+  call s:RunDbgCmd(buf, ':call g:ChangeVar()', ['Oldval = "''foo''"', 'Newval = "''bar''"', 'function ChangeVar', 'line 2: echo "changed"'])
 
   call StopVimInTerminal(buf)
 endfunc
@@ -1030,17 +1030,17 @@ func Test_debug_def_and_legacy_function()
 
   let buf = RunVimInTerminal('-S XtestDebug.vim', {})
 
-  call RunDbgCmd(buf,':call SomeFunc()', ['line 2: echo "and"'])
-  call RunDbgCmd(buf,'next', ['line 3: echo "there"'])
-  call RunDbgCmd(buf,'next', ['line 4: breakadd func 2 LocalFunc'])
+  call s:RunDbgCmd(buf,':call SomeFunc()', ['line 2: echo "and"'])
+  call s:RunDbgCmd(buf,'next', ['line 3: echo "there"'])
+  call s:RunDbgCmd(buf,'next', ['line 4: breakadd func 2 LocalFunc'])
 
   " continue, next breakpoint is in LocalFunc()
-  call RunDbgCmd(buf,'cont', ['line 2: echo "second"'])
+  call s:RunDbgCmd(buf,'cont', ['line 2: echo "second"'])
 
   " continue, next breakpoint is in LegacyFunc()
-  call RunDbgCmd(buf,'cont', ['line 1: echo "legone"'])
+  call s:RunDbgCmd(buf,'cont', ['line 1: echo "legone"'])
 
-  call RunDbgCmd(buf, 'cont')
+  call s:RunDbgCmd(buf, 'cont')
 
   call StopVimInTerminal(buf)
 endfunc
@@ -1103,68 +1103,68 @@ func Test_debug_def_function()
 
   let buf = RunVimInTerminal('-S Xtest.vim', {})
 
-  call RunDbgCmd(buf,
+  call s:RunDbgCmd(buf,
                 \ ':debug call Func()',
                 \ ['cmd: call Func()'])
-  call RunDbgCmd(buf, 'next', ['result: 3'])
+  call s:RunDbgCmd(buf, 'next', ['result: 3'])
   call term_sendkeys(buf, "\r")
-  call RunDbgCmd(buf, 'cont')
+  call s:RunDbgCmd(buf, 'cont')
 
-  call RunDbgCmd(buf,
+  call s:RunDbgCmd(buf,
                 \ ':debug call FuncWithArgs("asdf", 42, 1, 2, 3)',
                 \ ['cmd: call FuncWithArgs("asdf", 42, 1, 2, 3)'])
-  call RunDbgCmd(buf, 'step', ['line 1: echo text .. nr'])
-  call RunDbgCmd(buf, 'echo text', ['asdf'])
-  call RunDbgCmd(buf, 'echo nr', ['42'])
-  call RunDbgCmd(buf, 'echo items', ['[1, 2, 3]'])
-  call RunDbgCmd(buf, 'step', ['asdf42', 'function FuncWithArgs', 'line 2:   for it in items'])
-  call RunDbgCmd(buf, 'step', ['function FuncWithArgs', 'line 2: for it in items'])
-  call RunDbgCmd(buf, 'echo it', ['0'])
-  call RunDbgCmd(buf, 'step', ['line 3: echo it'])
-  call RunDbgCmd(buf, 'echo it', ['1'])
-  call RunDbgCmd(buf, 'step', ['1', 'function FuncWithArgs', 'line 4: endfor'])
-  call RunDbgCmd(buf, 'step', ['line 2: for it in items'])
-  call RunDbgCmd(buf, 'echo it', ['1'])
-  call RunDbgCmd(buf, 'step', ['line 3: echo it'])
-  call RunDbgCmd(buf, 'step', ['2', 'function FuncWithArgs', 'line 4: endfor'])
-  call RunDbgCmd(buf, 'step', ['line 2: for it in items'])
-  call RunDbgCmd(buf, 'echo it', ['2'])
-  call RunDbgCmd(buf, 'step', ['line 3: echo it'])
-  call RunDbgCmd(buf, 'step', ['3', 'function FuncWithArgs', 'line 4: endfor'])
-  call RunDbgCmd(buf, 'step', ['line 2: for it in items'])
-  call RunDbgCmd(buf, 'step', ['line 5: echo "done"'])
-  call RunDbgCmd(buf, 'cont')
+  call s:RunDbgCmd(buf, 'step', ['line 1: echo text .. nr'])
+  call s:RunDbgCmd(buf, 'echo text', ['asdf'])
+  call s:RunDbgCmd(buf, 'echo nr', ['42'])
+  call s:RunDbgCmd(buf, 'echo items', ['[1, 2, 3]'])
+  call s:RunDbgCmd(buf, 'step', ['asdf42', 'function FuncWithArgs', 'line 2:   for it in items'])
+  call s:RunDbgCmd(buf, 'step', ['function FuncWithArgs', 'line 2: for it in items'])
+  call s:RunDbgCmd(buf, 'echo it', ['0'])
+  call s:RunDbgCmd(buf, 'step', ['line 3: echo it'])
+  call s:RunDbgCmd(buf, 'echo it', ['1'])
+  call s:RunDbgCmd(buf, 'step', ['1', 'function FuncWithArgs', 'line 4: endfor'])
+  call s:RunDbgCmd(buf, 'step', ['line 2: for it in items'])
+  call s:RunDbgCmd(buf, 'echo it', ['1'])
+  call s:RunDbgCmd(buf, 'step', ['line 3: echo it'])
+  call s:RunDbgCmd(buf, 'step', ['2', 'function FuncWithArgs', 'line 4: endfor'])
+  call s:RunDbgCmd(buf, 'step', ['line 2: for it in items'])
+  call s:RunDbgCmd(buf, 'echo it', ['2'])
+  call s:RunDbgCmd(buf, 'step', ['line 3: echo it'])
+  call s:RunDbgCmd(buf, 'step', ['3', 'function FuncWithArgs', 'line 4: endfor'])
+  call s:RunDbgCmd(buf, 'step', ['line 2: for it in items'])
+  call s:RunDbgCmd(buf, 'step', ['line 5: echo "done"'])
+  call s:RunDbgCmd(buf, 'cont')
 
-  call RunDbgCmd(buf,
+  call s:RunDbgCmd(buf,
                 \ ':debug call FuncWithDict()',
                 \ ['cmd: call FuncWithDict()'])
-  call RunDbgCmd(buf, 'step', ['line 1: var d = {  a: 1,  b: 2,  }'])
-  call RunDbgCmd(buf, 'step', ['line 6: def Inner()'])
-  call RunDbgCmd(buf, 'cont')
+  call s:RunDbgCmd(buf, 'step', ['line 1: var d = {  a: 1,  b: 2,  }'])
+  call s:RunDbgCmd(buf, 'step', ['line 6: def Inner()'])
+  call s:RunDbgCmd(buf, 'cont')
 
-  call RunDbgCmd(buf, ':breakadd func 1 FuncComment')
-  call RunDbgCmd(buf, ':call FuncComment()', ['function FuncComment', 'line 2: echo "first"  .. "one"'])
-  call RunDbgCmd(buf, ':breakadd func 3 FuncComment')
-  call RunDbgCmd(buf, 'cont', ['function FuncComment', 'line 5: echo "second"'])
-  call RunDbgCmd(buf, 'cont')
+  call s:RunDbgCmd(buf, ':breakadd func 1 FuncComment')
+  call s:RunDbgCmd(buf, ':call FuncComment()', ['function FuncComment', 'line 2: echo "first"  .. "one"'])
+  call s:RunDbgCmd(buf, ':breakadd func 3 FuncComment')
+  call s:RunDbgCmd(buf, 'cont', ['function FuncComment', 'line 5: echo "second"'])
+  call s:RunDbgCmd(buf, 'cont')
 
-  call RunDbgCmd(buf, ':breakadd func 2 FuncForLoop')
-  call RunDbgCmd(buf, ':call FuncForLoop()', ['function FuncForLoop', 'line 2:   for i in [11, 22, 33]'])
-  call RunDbgCmd(buf, 'step', ['line 2: for i in [11, 22, 33]'])
-  call RunDbgCmd(buf, 'next', ['function FuncForLoop', 'line 3: eval i + 2'])
-  call RunDbgCmd(buf, 'echo i', ['11'])
-  call RunDbgCmd(buf, 'next', ['function FuncForLoop', 'line 4: endfor'])
-  call RunDbgCmd(buf, 'next', ['function FuncForLoop', 'line 2: for i in [11, 22, 33]'])
-  call RunDbgCmd(buf, 'next', ['line 3: eval i + 2'])
-  call RunDbgCmd(buf, 'echo i', ['22'])
+  call s:RunDbgCmd(buf, ':breakadd func 2 FuncForLoop')
+  call s:RunDbgCmd(buf, ':call FuncForLoop()', ['function FuncForLoop', 'line 2:   for i in [11, 22, 33]'])
+  call s:RunDbgCmd(buf, 'step', ['line 2: for i in [11, 22, 33]'])
+  call s:RunDbgCmd(buf, 'next', ['function FuncForLoop', 'line 3: eval i + 2'])
+  call s:RunDbgCmd(buf, 'echo i', ['11'])
+  call s:RunDbgCmd(buf, 'next', ['function FuncForLoop', 'line 4: endfor'])
+  call s:RunDbgCmd(buf, 'next', ['function FuncForLoop', 'line 2: for i in [11, 22, 33]'])
+  call s:RunDbgCmd(buf, 'next', ['line 3: eval i + 2'])
+  call s:RunDbgCmd(buf, 'echo i', ['22'])
 
-  call RunDbgCmd(buf, 'breakdel *')
-  call RunDbgCmd(buf, 'cont')
+  call s:RunDbgCmd(buf, 'breakdel *')
+  call s:RunDbgCmd(buf, 'cont')
 
-  call RunDbgCmd(buf, ':breakadd func FuncWithSplitLine')
-  call RunDbgCmd(buf, ':call FuncWithSplitLine()', ['function FuncWithSplitLine', 'line 1: eval 1 + 2 | eval 2 + 3'])
+  call s:RunDbgCmd(buf, ':breakadd func FuncWithSplitLine')
+  call s:RunDbgCmd(buf, ':call FuncWithSplitLine()', ['function FuncWithSplitLine', 'line 1: eval 1 + 2 | eval 2 + 3'])
 
-  call RunDbgCmd(buf, 'cont')
+  call s:RunDbgCmd(buf, 'cont')
   call StopVimInTerminal(buf)
 endfunc
 
@@ -1184,14 +1184,14 @@ func Test_debug_def_function_with_lambda()
 
   let buf = RunVimInTerminal('-S XtestLambda.vim', {})
 
-  call RunDbgCmd(buf,
+  call s:RunDbgCmd(buf,
                 \ ':call g:Func()',
                 \ ['function Func', 'line 2: [''b'']->map((_, v) => s)'])
-  call RunDbgCmd(buf,
+  call s:RunDbgCmd(buf,
                 \ 'next',
                 \ ['function Func', 'line 3: echo "done"'])
 
-  call RunDbgCmd(buf, 'cont')
+  call s:RunDbgCmd(buf, 'cont')
   call StopVimInTerminal(buf)
 endfunc
 
@@ -1242,30 +1242,30 @@ func Test_debug_backtrace_level()
         \ ], #{msec: 5000})
 
   " step through the initial declarations
-  call RunDbgCmd(buf, 'step', [ 'line 2: let g:global_var = ''global''' ] )
-  call RunDbgCmd(buf, 'step', [ 'line 4: func s:File1Func( arg )' ] )
-  call RunDbgCmd(buf, 'echo s:file1_var', [ 'file1' ] )
-  call RunDbgCmd(buf, 'echo g:global_var', [ 'global' ] )
-  call RunDbgCmd(buf, 'echo global_var', [ 'global' ] )
+  call s:RunDbgCmd(buf, 'step', [ 'line 2: let g:global_var = ''global''' ] )
+  call s:RunDbgCmd(buf, 'step', [ 'line 4: func s:File1Func( arg )' ] )
+  call s:RunDbgCmd(buf, 'echo s:file1_var', [ 'file1' ] )
+  call s:RunDbgCmd(buf, 'echo g:global_var', [ 'global' ] )
+  call s:RunDbgCmd(buf, 'echo global_var', [ 'global' ] )
 
   " step in to the first function
-  call RunDbgCmd(buf, 'step', [ 'line 11: call s:File1Func( ''arg1'' )' ] )
-  call RunDbgCmd(buf, 'step', [ 'line 1: let s:file1_var .= a:arg' ] )
-  call RunDbgCmd(buf, 'echo a:arg', [ 'arg1' ] )
-  call RunDbgCmd(buf, 'echo s:file1_var', [ 'file1' ] )
-  call RunDbgCmd(buf, 'echo g:global_var', [ 'global' ] )
-  call RunDbgCmd(buf,
+  call s:RunDbgCmd(buf, 'step', [ 'line 11: call s:File1Func( ''arg1'' )' ] )
+  call s:RunDbgCmd(buf, 'step', [ 'line 1: let s:file1_var .= a:arg' ] )
+  call s:RunDbgCmd(buf, 'echo a:arg', [ 'arg1' ] )
+  call s:RunDbgCmd(buf, 'echo s:file1_var', [ 'file1' ] )
+  call s:RunDbgCmd(buf, 'echo g:global_var', [ 'global' ] )
+  call s:RunDbgCmd(buf,
                 \'echo global_var',
                 \[ 'E121: Undefined variable: global_var' ] )
-  call RunDbgCmd(buf,
+  call s:RunDbgCmd(buf,
                 \'echo local_var',
                 \[ 'E121: Undefined variable: local_var' ] )
-  call RunDbgCmd(buf,
+  call s:RunDbgCmd(buf,
                 \'echo l:local_var',
                 \[ 'E121: Undefined variable: l:local_var' ] )
 
   " backtrace up
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '\V>backtrace',
         \ '\V  2 command line',
         \ '\V  1 script ' .. file1 .. '[11]',
@@ -1273,9 +1273,9 @@ func Test_debug_backtrace_level()
         \ '\Vline 1: let s:file1_var .= a:arg',
         \ ],
         \ #{ match: 'pattern' } )
-  call RunDbgCmd(buf, 'up', [ '>up' ] )
+  call s:RunDbgCmd(buf, 'up', [ '>up' ] )
 
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '\V>backtrace',
         \ '\V  2 command line',
         \ '\V->1 script ' .. file1 .. '[11]',
@@ -1286,25 +1286,25 @@ func Test_debug_backtrace_level()
 
   " Expression evaluation in the script frame (not the function frame)
   " FIXME: Unexpected in this scope (a: should not be visible)
-  call RunDbgCmd(buf, 'echo a:arg', [ 'arg1' ] )
-  call RunDbgCmd(buf, 'echo s:file1_var', [ 'file1' ] )
-  call RunDbgCmd(buf, 'echo g:global_var', [ 'global' ] )
+  call s:RunDbgCmd(buf, 'echo a:arg', [ 'arg1' ] )
+  call s:RunDbgCmd(buf, 'echo s:file1_var', [ 'file1' ] )
+  call s:RunDbgCmd(buf, 'echo g:global_var', [ 'global' ] )
   " FIXME: Unexpected in this scope (global should be found)
-  call RunDbgCmd(buf,
+  call s:RunDbgCmd(buf,
                 \'echo global_var',
                 \[ 'E121: Undefined variable: global_var' ] )
-  call RunDbgCmd(buf,
+  call s:RunDbgCmd(buf,
                 \'echo local_var',
                 \[ 'E121: Undefined variable: local_var' ] )
-  call RunDbgCmd(buf,
+  call s:RunDbgCmd(buf,
                 \'echo l:local_var',
                 \[ 'E121: Undefined variable: l:local_var' ] )
 
 
   " step while backtraced jumps to the latest frame
-  call RunDbgCmd(buf, 'step', [
+  call s:RunDbgCmd(buf, 'step', [
         \ 'line 2: let local_var = s:file1_var .. '' test1''' ] )
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '\V>backtrace',
         \ '\V  2 command line',
         \ '\V  1 script ' .. file1 .. '[11]',
@@ -1313,13 +1313,13 @@ func Test_debug_backtrace_level()
         \ ],
         \ #{ match: 'pattern' } )
 
-  call RunDbgCmd(buf, 'step', [ 'line 3: let g:global_var .= local_var' ] )
-  call RunDbgCmd(buf, 'echo local_var', [ 'file1arg1 test1' ] )
-  call RunDbgCmd(buf, 'echo l:local_var', [ 'file1arg1 test1' ] )
+  call s:RunDbgCmd(buf, 'step', [ 'line 3: let g:global_var .= local_var' ] )
+  call s:RunDbgCmd(buf, 'echo local_var', [ 'file1arg1 test1' ] )
+  call s:RunDbgCmd(buf, 'echo l:local_var', [ 'file1arg1 test1' ] )
 
-  call RunDbgCmd(buf, 'step', [ 'line 4: source Xtest2.vim' ] )
-  call RunDbgCmd(buf, 'step', [ 'line 1: let s:file2_var = ''file2''' ] )
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'step', [ 'line 4: source Xtest2.vim' ] )
+  call s:RunDbgCmd(buf, 'step', [ 'line 1: let s:file2_var = ''file2''' ] )
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '\V>backtrace',
         \ '\V  3 command line',
         \ '\V  2 script ' .. file1 .. '[11]',
@@ -1330,28 +1330,28 @@ func Test_debug_backtrace_level()
         \ #{ match: 'pattern' } )
 
   " Expression evaluation in the script frame file2 (not the function frame)
-  call RunDbgCmd(buf, 'echo a:arg', [ 'E121: Undefined variable: a:arg' ] )
-  call RunDbgCmd(buf,
+  call s:RunDbgCmd(buf, 'echo a:arg', [ 'E121: Undefined variable: a:arg' ] )
+  call s:RunDbgCmd(buf,
         \ 'echo s:file1_var',
         \ [ 'E121: Undefined variable: s:file1_var' ] )
-  call RunDbgCmd(buf, 'echo g:global_var', [ 'globalfile1arg1 test1' ] )
-  call RunDbgCmd(buf, 'echo global_var', [ 'globalfile1arg1 test1' ] )
-  call RunDbgCmd(buf,
+  call s:RunDbgCmd(buf, 'echo g:global_var', [ 'globalfile1arg1 test1' ] )
+  call s:RunDbgCmd(buf, 'echo global_var', [ 'globalfile1arg1 test1' ] )
+  call s:RunDbgCmd(buf,
                 \'echo local_var',
                 \[ 'E121: Undefined variable: local_var' ] )
-  call RunDbgCmd(buf,
+  call s:RunDbgCmd(buf,
                 \'echo l:local_var',
                 \[ 'E121: Undefined variable: l:local_var' ] )
-  call RunDbgCmd(buf,
+  call s:RunDbgCmd(buf,
         \ 'echo s:file2_var',
         \ [ 'E121: Undefined variable: s:file2_var' ] )
 
-  call RunDbgCmd(buf, 'step', [ 'line 3: func s:File2Func( arg )' ] )
-  call RunDbgCmd(buf, 'echo s:file2_var', [ 'file2' ] )
+  call s:RunDbgCmd(buf, 'step', [ 'line 3: func s:File2Func( arg )' ] )
+  call s:RunDbgCmd(buf, 'echo s:file2_var', [ 'file2' ] )
 
   " Up the stack to the other script context
-  call RunDbgCmd(buf, 'up')
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'up')
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '\V>backtrace',
         \ '\V  3 command line',
         \ '\V  2 script ' .. file1 .. '[11]',
@@ -1361,13 +1361,13 @@ func Test_debug_backtrace_level()
         \ ],
         \ #{ match: 'pattern' } )
   " FIXME: Unexpected. Should see the a: and l: dicts from File1Func
-  call RunDbgCmd(buf, 'echo a:arg', [ 'E121: Undefined variable: a:arg' ] )
-  call RunDbgCmd(buf,
+  call s:RunDbgCmd(buf, 'echo a:arg', [ 'E121: Undefined variable: a:arg' ] )
+  call s:RunDbgCmd(buf,
         \ 'echo l:local_var',
         \ [ 'E121: Undefined variable: l:local_var' ] )
 
-  call RunDbgCmd(buf, 'up')
-  call RunDbgCmd(buf, 'backtrace', [
+  call s:RunDbgCmd(buf, 'up')
+  call s:RunDbgCmd(buf, 'backtrace', [
         \ '\V>backtrace',
         \ '\V  3 command line',
         \ '\V->2 script ' .. file1 .. '[11]',
@@ -1378,12 +1378,12 @@ func Test_debug_backtrace_level()
         \ #{ match: 'pattern' } )
 
   " FIXME: Unexpected (wrong script vars are used)
-  call RunDbgCmd(buf,
+  call s:RunDbgCmd(buf,
         \ 'echo s:file1_var',
         \ [ 'E121: Undefined variable: s:file1_var' ] )
-  call RunDbgCmd(buf, 'echo s:file2_var', [ 'file2' ] )
+  call s:RunDbgCmd(buf, 'echo s:file2_var', [ 'file2' ] )
 
-  call RunDbgCmd(buf, 'cont')
+  call s:RunDbgCmd(buf, 'cont')
   call StopVimInTerminal(buf)
 endfunc