diff options
Diffstat (limited to 'mnv/src/testdir/util/mnv9.mnv')
| -rw-r--r-- | mnv/src/testdir/util/mnv9.mnv | 549 |
1 files changed, 549 insertions, 0 deletions
diff --git a/mnv/src/testdir/util/mnv9.mnv b/mnv/src/testdir/util/mnv9.mnv new file mode 100644 index 0000000000..4dad00938d --- /dev/null +++ b/mnv/src/testdir/util/mnv9.mnv @@ -0,0 +1,549 @@ +mnv9script + +# Utility functions for testing MNV9 script + +# Use a different file name for each run. +var sequence = 1 + +# Check that "lines" inside a ":def" function has no error when called. +export func CheckDefSuccess(lines) + let cwd = getcwd() + let fname = 'XdefSuccess' .. s:sequence + let s:sequence += 1 + call writefile(['def Func()'] + a:lines + ['enddef', 'defcompile'], fname) + try + exe 'so ' .. fname + call Func() + finally + call chdir(cwd) + call delete(fname) + delfunc! Func + endtry +endfunc + +# Check that "lines" inside a ":def" function has no error when compiled. +export func CheckDefCompileSuccess(lines) + let fname = 'XdefSuccess' .. s:sequence + let s:sequence += 1 + call writefile(['def Func()'] + a:lines + ['enddef', 'defcompile'], fname) + try + exe 'so ' .. fname + finally + call delete(fname) + delfunc! Func + endtry +endfunc + +# Check that "lines" inside ":def" results in an "error" message. +# If "lnum" is given check that the error is reported for this line. +# Add a line before and after to make it less likely that the line number is +# accidentally correct. +export func CheckDefFailure(lines, error, lnum = -3) + let cwd = getcwd() + let fname = 'XdefFailure' .. s:sequence + let s:sequence += 1 + call writefile(['def Func()', '# comment'] + a:lines + ['#comment', 'enddef', 'defcompile'], fname) + try + call assert_fails('so ' .. fname, a:error, a:lines, a:lnum + 1) + finally + call chdir(cwd) + call delete(fname) + delfunc! Func + endtry +endfunc + +# Check that "lines" inside ":def" results in an "error" message when executed. +# If "lnum" is given check that the error is reported for this line. +# Add a line before and after to make it less likely that the line number is +# accidentally correct. +export func CheckDefExecFailure(lines, error, lnum = -3) + let cwd = getcwd() + let fname = 'XdefExecFailure' .. s:sequence + let s:sequence += 1 + call writefile(['def Func()', '# comment'] + a:lines + ['#comment', 'enddef'], fname) + try + exe 'so ' .. fname + call assert_fails('call Func()', a:error, a:lines, a:lnum + 1) + finally + call chdir(cwd) + call delete(fname) + delfunc! Func + endtry +endfunc + +export def CheckScriptFailure(lines: list<string>, error: string, lnum = -3) + var cwd = getcwd() + var fname = 'XScriptFailure' .. sequence + sequence += 1 + writefile(lines, fname) + try + assert_fails('so ' .. fname, error, lines, lnum) + finally + chdir(cwd) + delete(fname) + endtry +enddef + +export def CheckScriptFailureList(lines: list<string>, errors: list<string>, lnum = -3) + var cwd = getcwd() + var fname = 'XScriptFailure' .. sequence + sequence += 1 + writefile(lines, fname) + try + assert_fails('so ' .. fname, errors, lines, lnum) + finally + chdir(cwd) + delete(fname) + endtry +enddef + +export def CheckScriptSuccess(lines: list<string>) + var cwd = getcwd() + var fname = 'XScriptSuccess' .. sequence + sequence += 1 + writefile(lines, fname) + try + exe 'so ' .. fname + finally + chdir(cwd) + delete(fname) + endtry +enddef + +export def CheckDefAndScriptSuccess(lines: list<string>) + CheckDefSuccess(lines) + CheckScriptSuccess(['mnv9script'] + lines) +enddef + +# Check that a command fails when used in a :def function and when used in +# MNV9 script. +# When "error" is a string, both with the same error. +# When "error" is a list, the :def function fails with "error[0]" , the script +# fails with "error[1]". +export def CheckDefAndScriptFailure(lines: list<string>, error: any, lnum = -3) + var errorDef: string + var errorScript: string + if type(error) == v:t_string + errorDef = error + errorScript = error + elseif type(error) == v:t_list && len(error) == 2 + errorDef = error[0] + errorScript = error[1] + else + echoerr 'error argument must be a string or a list with two items' + return + endif + CheckDefFailure(lines, errorDef, lnum) + CheckScriptFailure(['mnv9script'] + lines, errorScript, lnum + 1) +enddef + +# Check that a command fails when executed in a :def function and when used in +# MNV9 script. +# When "error" is a string, both with the same error. +# When "error" is a list, the :def function fails with "error[0]" , the script +# fails with "error[1]". +export def CheckDefExecAndScriptFailure(lines: list<string>, error: any, lnum = -3) + var errorDef: string + var errorScript: string + if type(error) == v:t_string + errorDef = error + errorScript = error + elseif type(error) == v:t_list && len(error) == 2 + errorDef = error[0] + errorScript = error[1] + else + echoerr 'error argument must be a string or a list with two items' + return + endif + CheckDefExecFailure(lines, errorDef, lnum) + CheckScriptFailure(['mnv9script'] + lines, errorScript, lnum + 1) +enddef + + +# Check that "lines" inside a legacy function has no error. +export func CheckLegacySuccess(lines) + let cwd = getcwd() + let fname = 'XlegacySuccess' .. s:sequence + let s:sequence += 1 + call writefile(['func Func()'] + a:lines + ['endfunc'], fname) + try + exe 'so ' .. fname + call Func() + finally + delfunc! Func + call chdir(cwd) + call delete(fname) + endtry +endfunc + +# Check that "lines" inside a legacy function results in the expected error +export func CheckLegacyFailure(lines, error) + let cwd = getcwd() + let fname = 'XlegacyFails' .. s:sequence + let s:sequence += 1 + call writefile(['func Func()'] + a:lines + ['endfunc', 'call Func()'], fname) + try + call assert_fails('so ' .. fname, a:error) + finally + delfunc! Func + call chdir(cwd) + call delete(fname) + endtry +endfunc + +# Translate "lines" to legacy MNV script +def LegacyTrans(lines: list<string>): list<string> + return lines->mapnew((_, v) => + v->substitute('\<VAR\>', 'let', 'g') + ->substitute('\<LET\>', 'let', 'g') + ->substitute('\<LSTART\>', '{', 'g') + ->substitute('\<LMIDDLE\>', '->', 'g') + ->substitute('\<LEND\>', '}', 'g') + ->substitute('\<TRUE\>', '1', 'g') + ->substitute('\<FALSE\>', '0', 'g') + ->substitute('#"', ' "', 'g')) +enddef + +# Execute "lines" in a legacy function, translated as in +# CheckLegacyAndMNV9Success() +export def CheckTransLegacySuccess(lines: list<string>) + CheckLegacySuccess(LegacyTrans(lines)) +enddef + +export def MNV9Trans(lines: list<string>): list<string> + return lines->mapnew((_, v) => + v->substitute('\<VAR\>', 'var', 'g') + ->substitute('\<LET ', '', 'g') + ->substitute('\<LSTART\>', '(', 'g') + ->substitute('\<LMIDDLE\>', ') =>', 'g') + ->substitute(' *\<LEND\> *', '', 'g') + ->substitute('\<TRUE\>', 'true', 'g') + ->substitute('\<FALSE\>', 'false', 'g')) +enddef + +# Execute "lines" in a :def function, translated as in +# CheckLegacyAndMNV9Success() +export def CheckTransDefSuccess(lines: list<string>) + CheckDefSuccess(MNV9Trans(lines)) +enddef + +# Execute "lines" in a MNV9 script, translated as in +# CheckLegacyAndMNV9Success() +export def CheckTransMNV9Success(lines: list<string>) + CheckScriptSuccess(['mnv9script'] + MNV9Trans(lines)) +enddef + +# Execute "lines" in a legacy function, :def function and MNV9 script. +# Use 'VAR' for a declaration. +# Use 'LET' for an assignment +# Use ' #"' for a comment +# Use LSTART arg LMIDDLE expr LEND for lambda +# Use 'TRUE' for 1 in legacy, true in MNV9 +# Use 'FALSE' for 0 in legacy, false in MNV9 +export def CheckLegacyAndMNV9Success(lines: list<string>) + CheckTransLegacySuccess(lines) + CheckTransDefSuccess(lines) + CheckTransMNV9Success(lines) +enddef + +# Execute "lines" in a legacy function, :def function and MNV9 script. +# Use 'VAR' for a declaration. +# Use 'LET' for an assignment +# Use ' #"' for a comment +export def CheckLegacyAndMNV9Failure(lines: list<string>, error: any) + var legacyError: string + var defError: string + var scriptError: string + + if type(error) == type('string') + legacyError = error + defError = error + scriptError = error + else + legacyError = error[0] + defError = error[1] + scriptError = error[2] + endif + + var legacylines = lines->mapnew((_, v) => + v->substitute('\<VAR\>', 'let', 'g') + ->substitute('\<LET\>', 'let', 'g') + ->substitute('\<LSTART\>', '{', 'g') + ->substitute('\<LMIDDLE\>', '->', 'g') + ->substitute('\<LEND\>', '}', 'g') + ->substitute('\<TRUE\>', '1', 'g') + ->substitute('\<FALSE\>', '0', 'g') + ->substitute('#"', ' "', 'g')) + CheckLegacyFailure(legacylines, legacyError) + + var mnv9lines = lines->mapnew((_, v) => + v->substitute('\<VAR\>', 'var', 'g') + ->substitute('\<LET ', '', 'g') + ->substitute('\<LSTART\>', '(', 'g') + ->substitute('\<LMIDDLE\>', ') =>', 'g') + ->substitute(' *\<LEND\> *', '', 'g') + ->substitute('\<TRUE\>', 'true', 'g') + ->substitute('\<FALSE\>', 'false', 'g')) + CheckDefExecFailure(mnv9lines, defError) + CheckScriptFailure(['mnv9script'] + mnv9lines, scriptError) +enddef + +# Check that "lines" inside a legacy function has no error. +export func CheckSourceLegacySuccess(lines) + let cwd = getcwd() + new + call setline(1, ['func Func()'] + a:lines + ['endfunc', 'call Func()']) + let bnr = bufnr() + try + :source + finally + delfunc! Func + call chdir(cwd) + exe $':bw! {bnr}' + endtry +endfunc + +# Check that "lines" inside a legacy function results in the expected error +export func CheckSourceLegacyFailure(lines, error) + let cwd = getcwd() + new + call setline(1, ['func Func()'] + a:lines + ['endfunc', 'call Func()']) + let bnr = bufnr() + try + call assert_fails('source', a:error) + finally + delfunc! Func + call chdir(cwd) + exe $':bw! {bnr}' + endtry +endfunc + +# Execute "lines" in a legacy function, translated as in +# CheckSourceLegacyAndMNV9Success() +export def CheckSourceTransLegacySuccess(lines: list<string>) + CheckSourceLegacySuccess(LegacyTrans(lines)) +enddef + +# Execute "lines" in a :def function, translated as in +# CheckLegacyAndMNV9Success() +export def CheckSourceTransDefSuccess(lines: list<string>) + CheckSourceDefSuccess(MNV9Trans(lines)) +enddef + +# Execute "lines" in a MNV9 script, translated as in +# CheckLegacyAndMNV9Success() +export def CheckSourceTransMNV9Success(lines: list<string>) + CheckSourceScriptSuccess(['mnv9script'] + MNV9Trans(lines)) +enddef + +# Execute "lines" in a legacy function, :def function and MNV9 script. +# Use 'VAR' for a declaration. +# Use 'LET' for an assignment +# Use ' #"' for a comment +# Use LSTART arg LMIDDLE expr LEND for lambda +# Use 'TRUE' for 1 in legacy, true in MNV9 +# Use 'FALSE' for 0 in legacy, false in MNV9 +export def CheckSourceLegacyAndMNV9Success(lines: list<string>) + CheckSourceTransLegacySuccess(lines) + CheckSourceTransDefSuccess(lines) + CheckSourceTransMNV9Success(lines) +enddef + +# :source a list of "lines" and check whether it fails with "error" +export def CheckSourceScriptFailure(lines: list<string>, error: string, lnum = -3) + var cwd = getcwd() + new + setline(1, lines) + var bnr = bufnr() + try + assert_fails('source', error, lines, lnum) + finally + chdir(cwd) + exe $':bw! {bnr}' + endtry +enddef + +# :source a list of "lines" and check whether it fails with the list of +# "errors" +export def CheckSourceScriptFailureList(lines: list<string>, errors: list<string>, lnum = -3) + var cwd = getcwd() + new + var bnr = bufnr() + setline(1, lines) + try + assert_fails('source', errors, lines, lnum) + finally + chdir(cwd) + exe $':bw! {bnr}' + endtry +enddef + +# :source a list of "lines" and check whether it succeeds +export def CheckSourceScriptSuccess(lines: list<string>) + var cwd = getcwd() + new + var bnr = bufnr() + setline(1, lines) + try + :source + finally + chdir(cwd) + exe $':bw! {bnr}' + endtry +enddef + +# :source a List of "lines" inside a ":def" function and check that no error +# occurs when called. +export func CheckSourceDefSuccess(lines) + let cwd = getcwd() + new + let bnr = bufnr() + call setline(1, ['def Func()'] + a:lines + ['enddef', 'defcompile']) + try + source + call Func() + finally + call chdir(cwd) + delfunc! Func + exe $'bw! {bnr}' + endtry +endfunc + +# Check that "lines" inside a ":def" function has no error when compiled. +export func CheckSourceDefCompileSuccess(lines) + let cwd = getcwd() + new + let bnr = bufnr() + call setline(1, ['def Func()', '# comment'] + a:lines + ['#comment', 'enddef', 'defcompile']) + try + source + finally + call chdir(cwd) + delfunc! Func + exe $':bw! {bnr}' + endtry +endfunc + +# Check that "lines" inside ":def" results in an "error" message. +# If "lnum" is given check that the error is reported for this line. +# Add a line before and after to make it less likely that the line number is +# accidentally correct. +export func CheckSourceDefFailure(lines, error, lnum = -3) + let cwd = getcwd() + new + let bnr = bufnr() + call setline(1, ['def Func()', '# comment'] + a:lines + ['#comment', 'enddef', 'defcompile']) + try + call assert_fails('source', a:error, a:lines, a:lnum + 1) + finally + call chdir(cwd) + delfunc! Func + exe $':bw! {bnr}' + endtry +endfunc + +# Check that "lines" inside ":def" results in an "error" message when executed. +# If "lnum" is given check that the error is reported for this line. +# Add a line before and after to make it less likely that the line number is +# accidentally correct. +export func CheckSourceDefExecFailure(lines, error, lnum = -3) + let cwd = getcwd() + new + let bnr = bufnr() + call setline(1, ['def Func()', '# comment'] + a:lines + ['#comment', 'enddef']) + try + source + call assert_fails('call Func()', a:error, a:lines, a:lnum + 1) + finally + call chdir(cwd) + delfunc! Func + exe $':bw! {bnr}' + endtry +endfunc + +# Check that a command fails when used in a :def function and when used in +# MNV9 script. +# When "error" is a string, both with the same error. +# When "error" is a list, the :def function fails with "error[0]" , the script +# fails with "error[1]". +export def CheckSourceDefAndScriptFailure(lines: list<string>, error: any, lnum = -3) + var errorDef: string + var errorScript: string + if type(error) == v:t_string + errorDef = error + errorScript = error + elseif type(error) == v:t_list && len(error) == 2 + errorDef = error[0] + errorScript = error[1] + else + echoerr 'error argument must be a string or a list with two items' + return + endif + CheckSourceDefFailure(lines, errorDef, lnum) + CheckSourceScriptFailure(['mnv9script'] + lines, errorScript, lnum + 1) +enddef + +# Check that a command fails when executed in a :def function and when used in +# MNV9 script. +# When "error" is a string, both with the same error. +# When "error" is a list, the :def function fails with "error[0]" , the script +# fails with "error[1]". +export def CheckSourceDefExecAndScriptFailure(lines: list<string>, error: any, lnum = -3) + var errorDef: string + var errorScript: string + if type(error) == v:t_string + errorDef = error + errorScript = error + elseif type(error) == v:t_list && len(error) == 2 + errorDef = error[0] + errorScript = error[1] + else + echoerr 'error argument must be a string or a list with two items' + return + endif + CheckSourceDefExecFailure(lines, errorDef, lnum) + CheckSourceScriptFailure(['mnv9script'] + lines, errorScript, lnum + 1) +enddef + +export def CheckSourceSuccess(lines: list<string>) + CheckSourceScriptSuccess(lines) +enddef + +export def CheckSourceFailure(lines: list<string>, error: string, lnum = -3) + CheckSourceScriptFailure(lines, error, lnum) +enddef + +export def CheckSourceFailureList(lines: list<string>, errors: list<string>, lnum = -3) + CheckSourceScriptFailureList(lines, errors, lnum) +enddef + +export def CheckSourceDefAndScriptSuccess(lines: list<string>) + CheckSourceDefSuccess(lines) + CheckSourceScriptSuccess(['mnv9script'] + lines) +enddef + +# Execute "lines" in a legacy function, :def function and MNV9 script. +# Use 'VAR' for a declaration. +# Use 'LET' for an assignment +# Use ' #"' for a comment +export def CheckSourceLegacyAndMNV9Failure(lines: list<string>, error: any) + var legacyError: string + var defError: string + var scriptError: string + + if type(error) == type('string') + legacyError = error + defError = error + scriptError = error + else + legacyError = error[0] + defError = error[1] + scriptError = error[2] + endif + + CheckSourceLegacyFailure(LegacyTrans(lines), legacyError) + var mnv9lines = MNV9Trans(lines) + CheckSourceDefExecFailure(mnv9lines, defError) + CheckSourceScriptFailure(['mnv9script'] + mnv9lines, scriptError) +enddef + |