vim: src/testdir/test_vim9_expr.vim annotate

annotate src/testdir/test_vim9_expr.vim @ 21210:44611891e22c v8.2.1156

patch 8.2.1156: Vim9: No error for invalid command in compiled function Commit: https://github.com/vim/vim/commit/002262f4dee452964190b0d022aa7443f602b288 Author: Bram Moolenaar <Bram@vim.org> Date: Wed Jul 8 17:47:57 2020 +0200 patch 8.2.1156: Vim9: No error for invalid command in compiled function Problem: Vim9: No error for invalid command in compiled function. Solution: Handle CMD_SIZE.

author	Bram Moolenaar <Bram@vim.org>
date	Wed, 08 Jul 2020 18:00:05 +0200
parents	f26a606e6dbc
children	bcd08812cde3

rev	line source
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1 " Tests for Vim9 script expressions
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	2
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	3 source check.vim
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	4 source vim9.vim
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	5
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	6 " test cond ? expr : expr
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	7 def Test_expr1()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	8 assert_equal('one', true ? 'one' : 'two')
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	9 assert_equal('one', 1 ?
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	10 'one' :
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	11 'two')
19249 2a017e9dc6da patch 8.2.0183: tests fail when the float feature is disabled Bram Moolenaar <Bram@vim.org> parents: 19219 diff changeset	12 if has('float')
2a017e9dc6da patch 8.2.0183: tests fail when the float feature is disabled Bram Moolenaar <Bram@vim.org> parents: 19219 diff changeset	13 assert_equal('one', 0.1 ? 'one' : 'two')
2a017e9dc6da patch 8.2.0183: tests fail when the float feature is disabled Bram Moolenaar <Bram@vim.org> parents: 19219 diff changeset	14 endif
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	15 assert_equal('one', 'x' ? 'one' : 'two')
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	16 assert_equal('one', 'x'
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	17 ? 'one'
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	18 : 'two')
19583 ba35daca6553 patch 8.2.0348: Vim9: not all code tested Bram Moolenaar <Bram@vim.org> parents: 19558 diff changeset	19 assert_equal('one', 0z1234 ? 'one' : 'two')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	20 assert_equal('one', [0] ? 'one' : 'two')
19583 ba35daca6553 patch 8.2.0348: Vim9: not all code tested Bram Moolenaar <Bram@vim.org> parents: 19558 diff changeset	21 assert_equal('one', #{x: 0} ? 'one' : 'two')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	22 let var = 1
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	23 assert_equal('one', var ? 'one' : 'two')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	24
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	25 assert_equal('two', false ? 'one' : 'two')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	26 assert_equal('two', 0 ? 'one' : 'two')
19259 77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	27 if has('float')
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	28 assert_equal('two', 0.0 ? 'one' : 'two')
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	29 endif
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	30 assert_equal('two', '' ? 'one' : 'two')
19583 ba35daca6553 patch 8.2.0348: Vim9: not all code tested Bram Moolenaar <Bram@vim.org> parents: 19558 diff changeset	31 assert_equal('two', 0z ? 'one' : 'two')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	32 assert_equal('two', [] ? 'one' : 'two')
19583 ba35daca6553 patch 8.2.0348: Vim9: not all code tested Bram Moolenaar <Bram@vim.org> parents: 19558 diff changeset	33 assert_equal('two', {} ? 'one' : 'two')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	34 var = 0
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	35 assert_equal('two', var ? 'one' : 'two')
20207 3c247d9cd6f9 patch 8.2.0659: Vim9: no test for equal func type Bram Moolenaar <Bram@vim.org> parents: 20203 diff changeset	36
3c247d9cd6f9 patch 8.2.0659: Vim9: no test for equal func type Bram Moolenaar <Bram@vim.org> parents: 20203 diff changeset	37 let Some: func = function('len')
3c247d9cd6f9 patch 8.2.0659: Vim9: no test for equal func type Bram Moolenaar <Bram@vim.org> parents: 20203 diff changeset	38 let Other: func = function('winnr')
3c247d9cd6f9 patch 8.2.0659: Vim9: no test for equal func type Bram Moolenaar <Bram@vim.org> parents: 20203 diff changeset	39 let Res: func = g:atrue ? Some : Other
3c247d9cd6f9 patch 8.2.0659: Vim9: no test for equal func type Bram Moolenaar <Bram@vim.org> parents: 20203 diff changeset	40 assert_equal(function('len'), Res)
3c247d9cd6f9 patch 8.2.0659: Vim9: no test for equal func type Bram Moolenaar <Bram@vim.org> parents: 20203 diff changeset	41
3c247d9cd6f9 patch 8.2.0659: Vim9: no test for equal func type Bram Moolenaar <Bram@vim.org> parents: 20203 diff changeset	42 let RetOne: func(string): number = function('len')
3c247d9cd6f9 patch 8.2.0659: Vim9: no test for equal func type Bram Moolenaar <Bram@vim.org> parents: 20203 diff changeset	43 let RetTwo: func(string): number = function('winnr')
3c247d9cd6f9 patch 8.2.0659: Vim9: no test for equal func type Bram Moolenaar <Bram@vim.org> parents: 20203 diff changeset	44 let RetThat: func = g:atrue ? RetOne : RetTwo
3c247d9cd6f9 patch 8.2.0659: Vim9: no test for equal func type Bram Moolenaar <Bram@vim.org> parents: 20203 diff changeset	45 assert_equal(function('len'), RetThat)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	46 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	47
21022 9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	48 def Test_expr1_vimscript()
9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	49 " only checks line continuation
9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	50 let lines =<< trim END
9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	51 vim9script
9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	52 let var = 1
9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	53 ? 'yes'
9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	54 : 'no'
9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	55 assert_equal('yes', var)
9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	56 END
9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	57 CheckScriptSuccess(lines)
9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	58
9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	59 lines =<< trim END
9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	60 vim9script
9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	61 let var = v:false
9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	62 ? 'yes'
9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	63 : 'no'
9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	64 assert_equal('no', var)
9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	65 END
9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	66 CheckScriptSuccess(lines)
21046 0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	67
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	68 lines =<< trim END
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	69 vim9script
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	70 let var = v:false ?
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	71 'yes' :
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	72 'no'
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	73 assert_equal('no', var)
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	74 END
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	75 CheckScriptSuccess(lines)
21022 9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	76 enddef
9d8634e91d1b patch 8.2.1062: Vim9: no line break allowed inside "cond ? val1 : val2" Bram Moolenaar <Bram@vim.org> parents: 20992 diff changeset	77
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	78 func Test_expr1_fails()
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	79 call CheckDefFailure(["let x = 1 ? 'one'"], "Missing ':' after '?'")
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	80 call CheckDefFailure(["let x = 1 ? 'one' : xxx"], "E1001:")
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	81
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	82 let msg = "white space required before and after '?'"
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	83 call CheckDefFailure(["let x = 1? 'one' : 'two'"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	84 call CheckDefFailure(["let x = 1 ?'one' : 'two'"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	85 call CheckDefFailure(["let x = 1?'one' : 'two'"], msg)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	86
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	87 let msg = "white space required before and after ':'"
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	88 call CheckDefFailure(["let x = 1 ? 'one': 'two'"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	89 call CheckDefFailure(["let x = 1 ? 'one' :'two'"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	90 call CheckDefFailure(["let x = 1 ? 'one':'two'"], msg)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	91 endfunc
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	92
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	93 " TODO: define inside test function
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	94 def Record(val: any): any
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	95 g:vals->add(val)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	96 return val
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	97 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	98
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	99 " test \|\|
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	100 def Test_expr2()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	101 assert_equal(2, 2 \|\| 0)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	102 assert_equal(7, 0 \|\|
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	103 0 \|\|
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	104 7)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	105 assert_equal(0, 0 \|\| 0)
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	106 assert_equal(0, 0
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	107 \|\| 0)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	108 assert_equal('', 0 \|\| '')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	109
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	110 g:vals = []
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	111 assert_equal(3, Record(3) \|\| Record(1))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	112 assert_equal([3], g:vals)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	113
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	114 g:vals = []
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	115 assert_equal(5, Record(0) \|\| Record(5))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	116 assert_equal([0, 5], g:vals)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	117
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	118 g:vals = []
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	119 assert_equal(4, Record(0)
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	120 \|\| Record(4)
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	121 \|\| Record(0))
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	122 assert_equal([0, 4], g:vals)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	123
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	124 g:vals = []
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	125 assert_equal(0, Record([]) \|\| Record('') \|\| Record(0))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	126 assert_equal([[], '', 0], g:vals)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	127 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	128
21024 02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	129 def Test_expr2_vimscript()
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	130 " only checks line continuation
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	131 let lines =<< trim END
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	132 vim9script
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	133 let var = 0
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	134 \|\| 1
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	135 assert_equal(1, var)
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	136 END
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	137 CheckScriptSuccess(lines)
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	138
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	139 lines =<< trim END
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	140 vim9script
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	141 let var = v:false
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	142 \|\| v:true
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	143 \|\| v:false
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	144 assert_equal(1, var)
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	145 END
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	146 CheckScriptSuccess(lines)
21046 0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	147
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	148 lines =<< trim END
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	149 vim9script
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	150 let var = v:false \|\|
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	151 v:true \|\|
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	152 v:false
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	153 assert_equal(1, var)
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	154 END
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	155 CheckScriptSuccess(lines)
21024 02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	156 enddef
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	157
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	158 func Test_expr2_fails()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	159 let msg = "white space required before and after '\|\|'"
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	160 call CheckDefFailure(["let x = 1\|\|2"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	161 call CheckDefFailure(["let x = 1 \|\|2"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	162 call CheckDefFailure(["let x = 1\|\| 2"], msg)
19872 8a7bede7b138 patch 8.2.0492: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19860 diff changeset	163
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	164 call CheckDefFailure(["let x = 1 \|\| xxx"], 'E1001:')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	165 endfunc
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	166
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	167 " test &&
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	168 def Test_expr3()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	169 assert_equal(0, 2 && 0)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	170 assert_equal(0, 0 &&
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	171 0 &&
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	172 7)
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	173 assert_equal(7, 2
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	174 && 3
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	175 && 7)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	176 assert_equal(0, 0 && 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	177 assert_equal(0, 0 && '')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	178 assert_equal('', 8 && '')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	179
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	180 g:vals = []
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	181 assert_equal(1, Record(3) && Record(1))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	182 assert_equal([3, 1], g:vals)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	183
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	184 g:vals = []
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	185 assert_equal(0, Record(0) && Record(5))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	186 assert_equal([0], g:vals)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	187
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	188 g:vals = []
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	189 assert_equal(0, Record(0) && Record(4) && Record(0))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	190 assert_equal([0], g:vals)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	191
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	192 g:vals = []
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	193 assert_equal(0, Record(8) && Record(4) && Record(0))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	194 assert_equal([8, 4, 0], g:vals)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	195
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	196 g:vals = []
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	197 assert_equal(0, Record([1]) && Record('z') && Record(0))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	198 assert_equal([[1], 'z', 0], g:vals)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	199 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	200
21024 02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	201 def Test_expr3_vimscript()
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	202 " only checks line continuation
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	203 let lines =<< trim END
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	204 vim9script
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	205 let var = 0
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	206 && 1
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	207 assert_equal(0, var)
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	208 END
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	209 CheckScriptSuccess(lines)
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	210
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	211 lines =<< trim END
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	212 vim9script
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	213 let var = v:true
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	214 && v:true
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	215 && v:true
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	216 assert_equal(1, var)
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	217 END
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	218 CheckScriptSuccess(lines)
21046 0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	219
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	220 lines =<< trim END
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	221 vim9script
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	222 let var = v:true &&
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	223 v:true &&
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	224 v:true
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	225 assert_equal(1, var)
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	226 END
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	227 CheckScriptSuccess(lines)
21024 02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	228 enddef
02b03915855d patch 8.2.1063: Vim9: no line break allowed before \|\| or && Bram Moolenaar <Bram@vim.org> parents: 21022 diff changeset	229
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	230 func Test_expr3_fails()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	231 let msg = "white space required before and after '&&'"
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	232 call CheckDefFailure(["let x = 1&&2"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	233 call CheckDefFailure(["let x = 1 &&2"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	234 call CheckDefFailure(["let x = 1&& 2"], msg)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	235 endfunc
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	236
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	237 let atrue = v:true
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	238 let afalse = v:false
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	239 let anone = v:none
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	240 let anull = v:null
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	241 let anint = 10
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	242 let alsoint = 4
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	243 if has('float')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	244 let afloat = 0.1
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	245 endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	246 let astring = 'asdf'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	247 let ablob = 0z01ab
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	248 let alist = [2, 3, 4]
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	249 let adict = #{aaa: 2, bbb: 8}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	250
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	251 " test == comperator
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	252 def Test_expr4_equal()
20470 fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	253 let trueVar = true
fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	254 let falseVar = false
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	255 assert_equal(true, true == true)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	256 assert_equal(false, true ==
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	257 false)
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	258 assert_equal(true, true
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	259 == trueVar)
20470 fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	260 assert_equal(false, true == falseVar)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	261 assert_equal(true, true == g:atrue)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	262 assert_equal(false, g:atrue == false)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	263
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	264 assert_equal(true, v:none == v:none)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	265 assert_equal(false, v:none == v:null)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	266 assert_equal(true, g:anone == v:none)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	267 assert_equal(false, v:none == g:anull)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	268
20470 fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	269 let nr0 = 0
fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	270 let nr61 = 61
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	271 assert_equal(false, 2 == 0)
20470 fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	272 assert_equal(false, 2 == nr0)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	273 assert_equal(true, 61 == 61)
20470 fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	274 assert_equal(true, 61 == nr61)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	275 assert_equal(true, g:anint == 10)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	276 assert_equal(false, 61 == g:anint)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	277
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	278 if has('float')
20413 92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	279 let ff = 0.3
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	280 assert_equal(true, ff == 0.3)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	281 assert_equal(false, 0.4 == ff)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	282 assert_equal(true, 0.1 == g:afloat)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	283 assert_equal(false, g:afloat == 0.3)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	284
20413 92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	285 ff = 3.0
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	286 assert_equal(true, ff == 3)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	287 assert_equal(true, 3 == ff)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	288 ff = 3.1
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	289 assert_equal(false, ff == 3)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	290 assert_equal(false, 3 == ff)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	291 endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	292
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	293 assert_equal(true, 'abc' == 'abc')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	294 assert_equal(false, 'xyz' == 'abc')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	295 assert_equal(true, g:astring == 'asdf')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	296 assert_equal(false, 'xyz' == g:astring)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	297
19860 37c4779ca8f5 patch 8.2.0486: Vim9: some code and error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19856 diff changeset	298 assert_equal(false, 'abc' == 'aBc')
37c4779ca8f5 patch 8.2.0486: Vim9: some code and error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19856 diff changeset	299 assert_equal(false, 'abc' ==# 'aBc')
37c4779ca8f5 patch 8.2.0486: Vim9: some code and error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19856 diff changeset	300 assert_equal(true, 'abc' ==? 'aBc')
37c4779ca8f5 patch 8.2.0486: Vim9: some code and error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19856 diff changeset	301
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	302 assert_equal(false, 'abc' == 'ABC')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	303 set ignorecase
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	304 assert_equal(false, 'abc' == 'ABC')
19860 37c4779ca8f5 patch 8.2.0486: Vim9: some code and error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19856 diff changeset	305 assert_equal(false, 'abc' ==# 'ABC')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	306 set noignorecase
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	307
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	308 call CheckDefFailure(["let x = 'a' == xxx"], 'E1001:')
19860 37c4779ca8f5 patch 8.2.0486: Vim9: some code and error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19856 diff changeset	309
20413 92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	310 let bb = 0z3f
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	311 assert_equal(true, 0z3f == bb)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	312 assert_equal(false, bb == 0z4f)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	313 assert_equal(true, g:ablob == 0z01ab)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	314 assert_equal(false, 0z3f == g:ablob)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	315
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	316 assert_equal(true, [1, 2, 3] == [1, 2, 3])
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	317 assert_equal(false, [1, 2, 3] == [2, 3, 1])
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	318 assert_equal(true, [2, 3, 4] == g:alist)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	319 assert_equal(false, g:alist == [2, 3, 1])
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	320 assert_equal(false, [1, 2, 3] == [])
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	321 assert_equal(false, [1, 2, 3] == ['1', '2', '3'])
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	322
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	323 assert_equal(true, #{one: 1, two: 2} == #{one: 1, two: 2})
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	324 assert_equal(false, #{one: 1, two: 2} == #{one: 2, two: 2})
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	325 assert_equal(false, #{one: 1, two: 2} == #{two: 2})
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	326 assert_equal(false, #{one: 1, two: 2} == #{})
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	327 assert_equal(true, g:adict == #{bbb: 8, aaa: 2})
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	328 assert_equal(false, #{ccc: 9, aaa: 2} == g:adict)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	329
20189 63cc54100ae4 patch 8.2.0650: Vim9: script function can be deleted Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	330 assert_equal(true, function('g:Test_expr4_equal') == function('g:Test_expr4_equal'))
63cc54100ae4 patch 8.2.0650: Vim9: script function can be deleted Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	331 assert_equal(false, function('g:Test_expr4_equal') == function('g:Test_expr4_is'))
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	332
20189 63cc54100ae4 patch 8.2.0650: Vim9: script function can be deleted Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	333 assert_equal(true, function('g:Test_expr4_equal', [123]) == function('g:Test_expr4_equal', [123]))
63cc54100ae4 patch 8.2.0650: Vim9: script function can be deleted Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	334 assert_equal(false, function('g:Test_expr4_equal', [123]) == function('g:Test_expr4_is', [123]))
63cc54100ae4 patch 8.2.0650: Vim9: script function can be deleted Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	335 assert_equal(false, function('g:Test_expr4_equal', [123]) == function('g:Test_expr4_equal', [999]))
20203 5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	336
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	337 let OneFunc: func
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	338 let TwoFunc: func
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	339 OneFunc = function('len')
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	340 TwoFunc = function('len')
5a397db2c1ed patch 8.2.0657: Vim9: no check if called variable is a FuncRef Bram Moolenaar <Bram@vim.org> parents: 20189 diff changeset	341 assert_equal(true, OneFunc('abc') == TwoFunc('123'))
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	342 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	343
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	344 " test != comperator
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	345 def Test_expr4_notequal()
20470 fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	346 let trueVar = true
fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	347 let falseVar = false
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	348 assert_equal(false, true != true)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	349 assert_equal(true, true !=
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	350 false)
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	351 assert_equal(false, true
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	352 != trueVar)
20470 fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	353 assert_equal(true, true != falseVar)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	354 assert_equal(false, true != g:atrue)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	355 assert_equal(true, g:atrue != false)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	356
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	357 assert_equal(false, v:none != v:none)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	358 assert_equal(true, v:none != v:null)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	359 assert_equal(false, g:anone != v:none)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	360 assert_equal(true, v:none != g:anull)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	361
20470 fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	362 let nr55 = 55
fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	363 let nr0 = 55
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	364 assert_equal(true, 2 != 0)
20470 fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	365 assert_equal(true, 2 != nr0)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	366 assert_equal(false, 55 != 55)
20470 fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	367 assert_equal(false, 55 != nr55)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	368 assert_equal(false, g:anint != 10)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	369 assert_equal(true, 61 != g:anint)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	370
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	371 if has('float')
20413 92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	372 let ff = 0.3
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	373 assert_equal(false, 0.3 != ff)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	374 assert_equal(true, 0.4 != ff)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	375 assert_equal(false, 0.1 != g:afloat)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	376 assert_equal(true, g:afloat != 0.3)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	377
20413 92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	378 ff = 3.0
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	379 assert_equal(false, ff != 3)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	380 assert_equal(false, 3 != ff)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	381 ff = 3.1
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	382 assert_equal(true, ff != 3)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	383 assert_equal(true, 3 != ff)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	384 endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	385
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	386 assert_equal(false, 'abc' != 'abc')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	387 assert_equal(true, 'xyz' != 'abc')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	388 assert_equal(false, g:astring != 'asdf')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	389 assert_equal(true, 'xyz' != g:astring)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	390
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	391 assert_equal(true, 'abc' != 'ABC')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	392 set ignorecase
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	393 assert_equal(true, 'abc' != 'ABC')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	394 set noignorecase
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	395
20413 92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	396 let bb = 0z3f
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	397 assert_equal(false, 0z3f != bb)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	398 assert_equal(true, bb != 0z4f)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	399 assert_equal(false, g:ablob != 0z01ab)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	400 assert_equal(true, 0z3f != g:ablob)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	401
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	402 assert_equal(false, [1, 2, 3] != [1, 2, 3])
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	403 assert_equal(true, [1, 2, 3] != [2, 3, 1])
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	404 assert_equal(false, [2, 3, 4] != g:alist)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	405 assert_equal(true, g:alist != [2, 3, 1])
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	406 assert_equal(true, [1, 2, 3] != [])
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	407 assert_equal(true, [1, 2, 3] != ['1', '2', '3'])
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	408
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	409 assert_equal(false, #{one: 1, two: 2} != #{one: 1, two: 2})
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	410 assert_equal(true, #{one: 1, two: 2} != #{one: 2, two: 2})
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	411 assert_equal(true, #{one: 1, two: 2} != #{two: 2})
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	412 assert_equal(true, #{one: 1, two: 2} != #{})
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	413 assert_equal(false, g:adict != #{bbb: 8, aaa: 2})
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	414 assert_equal(true, #{ccc: 9, aaa: 2} != g:adict)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	415
20189 63cc54100ae4 patch 8.2.0650: Vim9: script function can be deleted Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	416 assert_equal(false, function('g:Test_expr4_equal') != function('g:Test_expr4_equal'))
63cc54100ae4 patch 8.2.0650: Vim9: script function can be deleted Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	417 assert_equal(true, function('g:Test_expr4_equal') != function('g:Test_expr4_is'))
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	418
20189 63cc54100ae4 patch 8.2.0650: Vim9: script function can be deleted Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	419 assert_equal(false, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_equal', [123]))
63cc54100ae4 patch 8.2.0650: Vim9: script function can be deleted Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	420 assert_equal(true, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_is', [123]))
63cc54100ae4 patch 8.2.0650: Vim9: script function can be deleted Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	421 assert_equal(true, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_equal', [999]))
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	422 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	423
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	424 " test > comperator
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	425 def Test_expr4_greater()
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	426 assert_true(2 > 0)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	427 assert_true(2 >
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	428 1)
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	429 assert_false(2 > 2)
08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	430 assert_false(2 > 3)
20470 fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	431 let nr2 = 2
fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	432 assert_true(nr2 > 0)
fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	433 assert_true(nr2 >
fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	434 1)
fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	435 assert_false(nr2 > 2)
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	436 assert_false(nr2
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	437 > 3)
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	438 if has('float')
20413 92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	439 let ff = 2.0
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	440 assert_true(ff > 0.0)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	441 assert_true(ff > 1.0)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	442 assert_false(ff > 2.0)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	443 assert_false(ff > 3.0)
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	444 endif
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	445 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	446
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	447 " test >= comperator
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	448 def Test_expr4_greaterequal()
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	449 assert_true(2 >= 0)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	450 assert_true(2 >=
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	451 2)
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	452 assert_false(2 >= 3)
20470 fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	453 let nr2 = 2
fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	454 assert_true(nr2 >= 0)
fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	455 assert_true(nr2 >= 2)
fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	456 assert_false(nr2 >= 3)
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	457 if has('float')
20413 92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	458 let ff = 2.0
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	459 assert_true(ff >= 0.0)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	460 assert_true(ff >= 2.0)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	461 assert_false(ff >= 3.0)
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	462 endif
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	463 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	464
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	465 " test < comperator
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	466 def Test_expr4_smaller()
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	467 assert_false(2 < 0)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	468 assert_false(2 <
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	469 2)
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	470 assert_true(2
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	471 < 3)
20470 fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	472 let nr2 = 2
fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	473 assert_false(nr2 < 0)
fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	474 assert_false(nr2 < 2)
fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	475 assert_true(nr2 < 3)
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	476 if has('float')
20413 92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	477 let ff = 2.0
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	478 assert_false(ff < 0.0)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	479 assert_false(ff < 2.0)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	480 assert_true(ff < 3.0)
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	481 endif
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	482 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	483
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	484 " test <= comperator
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	485 def Test_expr4_smallerequal()
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	486 assert_false(2 <= 0)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	487 assert_false(2 <=
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	488 1)
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	489 assert_true(2
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	490 <= 2)
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	491 assert_true(2 <= 3)
20470 fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	492 let nr2 = 2
fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	493 assert_false(nr2 <= 0)
fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	494 assert_false(nr2 <= 1)
fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	495 assert_true(nr2 <= 2)
fafa48fd3461 patch 8.2.0789: Vim9: expression testing lost coverage using constants Bram Moolenaar <Bram@vim.org> parents: 20413 diff changeset	496 assert_true(nr2 <= 3)
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	497 if has('float')
20413 92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	498 let ff = 2.0
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	499 assert_false(ff <= 0.0)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	500 assert_false(ff <= 1.0)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	501 assert_true(ff <= 2.0)
92826050c45e patch 8.2.0761: Vim9: instructions not tested Bram Moolenaar <Bram@vim.org> parents: 20411 diff changeset	502 assert_true(ff <= 3.0)
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	503 endif
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	504 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	505
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	506 " test =~ comperator
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	507 def Test_expr4_match()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	508 assert_equal(false, '2' =~ '0')
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	509 assert_equal(false, ''
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	510 =~ '0')
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	511 assert_equal(true, '2' =~
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	512 '[0-9]')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	513 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	514
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	515 " test !~ comperator
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	516 def Test_expr4_nomatch()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	517 assert_equal(true, '2' !~ '0')
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	518 assert_equal(true, ''
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	519 !~ '0')
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	520 assert_equal(false, '2' !~
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	521 '[0-9]')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	522 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	523
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	524 " test is comperator
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	525 def Test_expr4_is()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	526 let mylist = [2]
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	527 assert_false(mylist is [2])
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	528 let other = mylist
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	529 assert_true(mylist is
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	530 other)
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	531
08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	532 let myblob = 0z1234
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	533 assert_false(myblob
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	534 is 0z1234)
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	535 let otherblob = myblob
08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	536 assert_true(myblob is otherblob)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	537 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	538
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	539 " test isnot comperator
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	540 def Test_expr4_isnot()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	541 let mylist = [2]
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	542 assert_true('2' isnot '0')
08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	543 assert_true(mylist isnot [2])
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	544 let other = mylist
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	545 assert_false(mylist isnot
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	546 other)
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	547
08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	548 let myblob = 0z1234
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	549 assert_true(myblob
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	550 isnot 0z1234)
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	551 let otherblob = myblob
08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	552 assert_false(myblob isnot otherblob)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	553 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	554
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	555 def RetVoid()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	556 let x = 1
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	557 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	558
21026 fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	559 def Test_expr4_vimscript()
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	560 " only checks line continuation
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	561 let lines =<< trim END
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	562 vim9script
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	563 let var = 0
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	564 < 1
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	565 assert_equal(1, var)
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	566 END
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	567 CheckScriptSuccess(lines)
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	568
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	569 lines =<< trim END
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	570 vim9script
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	571 let var = 123
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	572 != 123
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	573 assert_equal(0, var)
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	574 END
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	575 CheckScriptSuccess(lines)
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	576
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	577 lines =<< trim END
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	578 vim9script
21046 0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	579 let var = 123 ==
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	580 123
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	581 assert_equal(1, var)
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	582 END
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	583 CheckScriptSuccess(lines)
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	584
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	585 lines =<< trim END
0ca7e04d39e3 patch 8.2.1074: Vim9: no line break allowed after some operators Bram Moolenaar <Bram@vim.org> parents: 21044 diff changeset	586 vim9script
21026 fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	587 let list = [1, 2, 3]
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	588 let var = list
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	589 is list
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	590 assert_equal(1, var)
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	591 END
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	592 CheckScriptSuccess(lines)
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	593
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	594 lines =<< trim END
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	595 vim9script
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	596 let myblob = 0z1234
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	597 let var = myblob
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	598 isnot 0z11
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	599 assert_equal(1, var)
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	600 END
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	601 CheckScriptSuccess(lines)
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	602 enddef
fe2ed85db946 patch 8.2.1064: Vim9: no line break allowed before comperators Bram Moolenaar <Bram@vim.org> parents: 21024 diff changeset	603
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	604 func Test_expr4_fails()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	605 let msg = "white space required before and after '>'"
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	606 call CheckDefFailure(["let x = 1>2"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	607 call CheckDefFailure(["let x = 1 >2"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	608 call CheckDefFailure(["let x = 1> 2"], msg)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	609
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	610 let msg = "white space required before and after '=='"
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	611 call CheckDefFailure(["let x = 1==2"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	612 call CheckDefFailure(["let x = 1 ==2"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	613 call CheckDefFailure(["let x = 1== 2"], msg)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	614
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	615 let msg = "white space required before and after 'is'"
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	616 call CheckDefFailure(["let x = '1'is'2'"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	617 call CheckDefFailure(["let x = '1' is'2'"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	618 call CheckDefFailure(["let x = '1'is '2'"], msg)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	619
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	620 let msg = "white space required before and after 'isnot'"
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	621 call CheckDefFailure(["let x = '1'isnot'2'"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	622 call CheckDefFailure(["let x = '1' isnot'2'"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	623 call CheckDefFailure(["let x = '1'isnot '2'"], msg)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	624
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	625 call CheckDefFailure(["let x = 1 is# 2"], 'E15:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	626 call CheckDefFailure(["let x = 1 is? 2"], 'E15:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	627 call CheckDefFailure(["let x = 1 isnot# 2"], 'E15:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	628 call CheckDefFailure(["let x = 1 isnot? 2"], 'E15:')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	629
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	630 call CheckDefFailure(["let x = 1 == '2'"], 'Cannot compare number with string')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	631 call CheckDefFailure(["let x = '1' == 2"], 'Cannot compare string with number')
20328 445c2b2ea44b patch 8.2.0719: Vim9: more expressions can be evaluated at compile time Bram Moolenaar <Bram@vim.org> parents: 20318 diff changeset	632 call CheckDefFailure(["let x = 1 == RetVoid()"], 'Cannot compare number with void')
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	633 call CheckDefFailure(["let x = RetVoid() == 1"], 'Cannot compare void with number')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	634
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	635 call CheckDefFailure(["let x = true > false"], 'Cannot compare bool with bool')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	636 call CheckDefFailure(["let x = true >= false"], 'Cannot compare bool with bool')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	637 call CheckDefFailure(["let x = true < false"], 'Cannot compare bool with bool')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	638 call CheckDefFailure(["let x = true <= false"], 'Cannot compare bool with bool')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	639 call CheckDefFailure(["let x = true =~ false"], 'Cannot compare bool with bool')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	640 call CheckDefFailure(["let x = true !~ false"], 'Cannot compare bool with bool')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	641 call CheckDefFailure(["let x = true is false"], 'Cannot use "is" with bool')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	642 call CheckDefFailure(["let x = true isnot false"], 'Cannot use "isnot" with bool')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	643
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	644 call CheckDefFailure(["let x = v:none is v:null"], 'Cannot use "is" with special')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	645 call CheckDefFailure(["let x = v:none isnot v:null"], 'Cannot use "isnot" with special')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	646 call CheckDefFailure(["let x = 123 is 123"], 'Cannot use "is" with number')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	647 call CheckDefFailure(["let x = 123 isnot 123"], 'Cannot use "isnot" with number')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	648 if has('float')
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	649 call CheckDefFailure(["let x = 1.3 is 1.3"], 'Cannot use "is" with float')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	650 call CheckDefFailure(["let x = 1.3 isnot 1.3"], 'Cannot use "isnot" with float')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	651 endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	652
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	653 call CheckDefFailure(["let x = 0za1 > 0z34"], 'Cannot compare blob with blob')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	654 call CheckDefFailure(["let x = 0za1 >= 0z34"], 'Cannot compare blob with blob')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	655 call CheckDefFailure(["let x = 0za1 < 0z34"], 'Cannot compare blob with blob')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	656 call CheckDefFailure(["let x = 0za1 <= 0z34"], 'Cannot compare blob with blob')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	657 call CheckDefFailure(["let x = 0za1 =~ 0z34"], 'Cannot compare blob with blob')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	658 call CheckDefFailure(["let x = 0za1 !~ 0z34"], 'Cannot compare blob with blob')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	659
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	660 call CheckDefFailure(["let x = [13] > [88]"], 'Cannot compare list with list')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	661 call CheckDefFailure(["let x = [13] >= [88]"], 'Cannot compare list with list')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	662 call CheckDefFailure(["let x = [13] < [88]"], 'Cannot compare list with list')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	663 call CheckDefFailure(["let x = [13] <= [88]"], 'Cannot compare list with list')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	664 call CheckDefFailure(["let x = [13] =~ [88]"], 'Cannot compare list with list')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	665 call CheckDefFailure(["let x = [13] !~ [88]"], 'Cannot compare list with list')
19583 ba35daca6553 patch 8.2.0348: Vim9: not all code tested Bram Moolenaar <Bram@vim.org> parents: 19558 diff changeset	666
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	667 call CheckDefFailure(['let j: job', 'let chan: channel', 'let r = j == chan'], 'Cannot compare job with channel')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	668 call CheckDefFailure(['let j: job', 'let x: list<any>', 'let r = j == x'], 'Cannot compare job with list')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	669 call CheckDefFailure(['let j: job', 'let Xx: func', 'let r = j == Xx'], 'Cannot compare job with func')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	670 call CheckDefFailure(['let j: job', 'let Xx: func', 'let r = j == Xx'], 'Cannot compare job with func')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	671 endfunc
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	672
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	673 " test addition, subtraction, concatenation
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	674 def Test_expr5()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	675 assert_equal(66, 60 + 6)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	676 assert_equal(70, 60 +
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	677 g:anint)
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	678 assert_equal(9, g:alsoint
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	679 + 5)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	680 assert_equal(14, g:alsoint + g:anint)
20919 96bf2b304932 patch 8.2.1011: Vim9: some code not tested Bram Moolenaar <Bram@vim.org> parents: 20470 diff changeset	681 assert_equal([1, 2, 3, 4], [1] + g:alist)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	682
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	683 assert_equal(54, 60 - 6)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	684 assert_equal(50, 60 -
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	685 g:anint)
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	686 assert_equal(-1, g:alsoint
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	687 - 5)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	688 assert_equal(-6, g:alsoint - g:anint)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	689
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	690 assert_equal('hello', 'hel' .. 'lo')
20318 3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	691 assert_equal('hello 123', 'hello ' ..
3cbcee39fc5c patch 8.2.0714: Vim9: handling constant expression does not scale Bram Moolenaar <Bram@vim.org> parents: 20305 diff changeset	692 123)
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	693 assert_equal('hello 123', 'hello '
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	694 .. 123)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	695 assert_equal('123 hello', 123 .. ' hello')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	696 assert_equal('123456', 123 .. 456)
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	697
08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	698 assert_equal([1, 2, 3, 4], [1, 2] + [3, 4])
08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	699 assert_equal(0z11223344, 0z1122 + 0z3344)
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	700 assert_equal(0z112201ab, 0z1122
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	701 + g:ablob)
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	702 assert_equal(0z01ab3344, g:ablob + 0z3344)
08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	703 assert_equal(0z01ab01ab, g:ablob + g:ablob)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	704 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	705
20992 7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	706 def Test_expr5_vim9script()
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	707 " only checks line continuation
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	708 let lines =<< trim END
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	709 vim9script
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	710 let var = 11
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	711 + 77
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	712 - 22
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	713 assert_equal(66, var)
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	714 END
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	715 CheckScriptSuccess(lines)
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	716
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	717 lines =<< trim END
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	718 vim9script
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	719 let var = 'one'
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	720 .. 'two'
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	721 assert_equal('onetwo', var)
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	722 END
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	723 CheckScriptSuccess(lines)
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	724 enddef
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	725
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	726 def Test_expr5_float()
19259 77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	727 if !has('float')
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	728 MissingFeature 'float'
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	729 else
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	730 assert_equal(66.0, 60.0 + 6.0)
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	731 assert_equal(66.0, 60.0 + 6)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	732 assert_equal(66.0, 60 +
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	733 6.0)
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	734 assert_equal(5.1, g:afloat
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	735 + 5)
19259 77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	736 assert_equal(8.1, 8 + g:afloat)
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	737 assert_equal(10.1, g:anint + g:afloat)
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	738 assert_equal(10.1, g:afloat + g:anint)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	739
19259 77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	740 assert_equal(54.0, 60.0 - 6.0)
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	741 assert_equal(54.0, 60.0
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	742 - 6)
19259 77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	743 assert_equal(54.0, 60 - 6.0)
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	744 assert_equal(-4.9, g:afloat - 5)
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	745 assert_equal(7.9, 8 - g:afloat)
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	746 assert_equal(9.9, g:anint - g:afloat)
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	747 assert_equal(-9.9, g:afloat - g:anint)
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	748 endif
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	749 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	750
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	751 func Test_expr5_fails()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	752 let msg = "white space required before and after '+'"
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	753 call CheckDefFailure(["let x = 1+2"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	754 call CheckDefFailure(["let x = 1 +2"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	755 call CheckDefFailure(["let x = 1+ 2"], msg)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	756
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	757 let msg = "white space required before and after '-'"
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	758 call CheckDefFailure(["let x = 1-2"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	759 call CheckDefFailure(["let x = 1 -2"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	760 call CheckDefFailure(["let x = 1- 2"], msg)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	761
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	762 let msg = "white space required before and after '..'"
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	763 call CheckDefFailure(["let x = '1'..'2'"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	764 call CheckDefFailure(["let x = '1' ..'2'"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	765 call CheckDefFailure(["let x = '1'.. '2'"], msg)
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	766
20982 bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20955 diff changeset	767 call CheckDefFailure(["let x = 0z1122 + 33"], 'E1051')
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20955 diff changeset	768 call CheckDefFailure(["let x = 0z1122 + [3]"], 'E1051')
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20955 diff changeset	769 call CheckDefFailure(["let x = 0z1122 + 'asd'"], 'E1051')
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20955 diff changeset	770 call CheckDefFailure(["let x = 33 + 0z1122"], 'E1051')
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20955 diff changeset	771 call CheckDefFailure(["let x = [3] + 0z1122"], 'E1051')
bb49b5090a9c patch 8.2.1042: Vim9: cannot put an operator on the next line Bram Moolenaar <Bram@vim.org> parents: 20955 diff changeset	772 call CheckDefFailure(["let x = 'asdf' + 0z1122"], 'E1051')
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	773 call CheckDefFailure(["let x = 6 + xxx"], 'E1001')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	774 endfunc
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	775
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	776 " test multiply, divide, modulo
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	777 def Test_expr6()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	778 assert_equal(36, 6 * 6)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	779 assert_equal(24, 6 *
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	780 g:alsoint)
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	781 assert_equal(24, g:alsoint
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	782 * 6)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	783 assert_equal(40, g:anint * g:alsoint)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	784
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	785 assert_equal(10, 60 / 6)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	786 assert_equal(6, 60 /
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	787 g:anint)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	788 assert_equal(1, g:anint / 6)
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	789 assert_equal(2, g:anint
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	790 / g:alsoint)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	791
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	792 assert_equal(5, 11 % 6)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	793 assert_equal(4, g:anint % 6)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	794 assert_equal(3, 13 %
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	795 g:anint)
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	796 assert_equal(2, g:anint
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	797 % g:alsoint)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	798
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	799 assert_equal(4, 6 * 4 / 6)
19423 f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	800
f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	801 let x = [2]
f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	802 let y = [3]
f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	803 assert_equal(5, x[0] + y[0])
f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	804 assert_equal(6, x[0] * y[0])
f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	805 if has('float')
f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	806 let xf = [2.0]
f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	807 let yf = [3.0]
20988 ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	808 assert_equal(5.0, xf[0]
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	809 + yf[0])
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	810 assert_equal(6.0, xf[0]
ae4b1d497a06 patch 8.2.1045: Vim9: line break before operator does not work Bram Moolenaar <Bram@vim.org> parents: 20982 diff changeset	811 * yf[0])
19423 f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	812 endif
19856 90eec641cc8c patch 8.2.0484: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19854 diff changeset	813
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	814 call CheckDefFailure(["let x = 6 * xxx"], 'E1001')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	815 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	816
20992 7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	817 def Test_expr6_vim9script()
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	818 " only checks line continuation
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	819 let lines =<< trim END
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	820 vim9script
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	821 let var = 11
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	822 * 22
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	823 / 3
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	824 assert_equal(80, var)
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	825 END
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	826 CheckScriptSuccess(lines)
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	827
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	828 lines =<< trim END
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	829 vim9script
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	830 let var = 25
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	831 % 10
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	832 assert_equal(5, var)
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	833 END
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	834 CheckScriptSuccess(lines)
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	835 enddef
7ee565134d4a patch 8.2.1047: Vim9: script cannot use line continuation like :def function Bram Moolenaar <Bram@vim.org> parents: 20988 diff changeset	836
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	837 def Test_expr6_float()
19259 77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	838 if !has('float')
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	839 MissingFeature 'float'
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	840 else
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	841 assert_equal(36.0, 6.0 * 6)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	842 assert_equal(36.0, 6 *
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	843 6.0)
19259 77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	844 assert_equal(36.0, 6.0 * 6.0)
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	845 assert_equal(1.0, g:afloat * g:anint)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	846
19259 77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	847 assert_equal(10.0, 60 / 6.0)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	848 assert_equal(10.0, 60.0 /
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	849 6)
19259 77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	850 assert_equal(10.0, 60.0 / 6.0)
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	851 assert_equal(0.01, g:afloat / g:anint)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	852
19259 77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	853 assert_equal(4.0, 6.0 * 4 / 6)
20013 bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	854 assert_equal(4.0, 6 *
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	855 4.0 /
bf377a9ffccb patch 8.2.0562: Vim9: cannot split an expression into multiple lines Bram Moolenaar <Bram@vim.org> parents: 20005 diff changeset	856 6)
19259 77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	857 assert_equal(4.0, 6 * 4 / 6.0)
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	858 assert_equal(4.0, 6.0 * 4.0 / 6)
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	859 assert_equal(4.0, 6 * 4.0 / 6.0)
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	860 assert_equal(4.0, 6.0 * 4 / 6.0)
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	861 assert_equal(4.0, 6.0 * 4.0 / 6.0)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	862
19259 77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	863 assert_equal(4.0, 6.0 * 4.0 / 6.0)
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	864 endif
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	865 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	866
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	867 func Test_expr6_fails()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	868 let msg = "white space required before and after '*'"
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	869 call CheckDefFailure(["let x = 1*2"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	870 call CheckDefFailure(["let x = 1 *2"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	871 call CheckDefFailure(["let x = 1* 2"], msg)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	872
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	873 let msg = "white space required before and after '/'"
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	874 call CheckDefFailure(["let x = 1/2"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	875 call CheckDefFailure(["let x = 1 /2"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	876 call CheckDefFailure(["let x = 1/ 2"], msg)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	877
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	878 let msg = "white space required before and after '%'"
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	879 call CheckDefFailure(["let x = 1%2"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	880 call CheckDefFailure(["let x = 1 %2"], msg)
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	881 call CheckDefFailure(["let x = 1% 2"], msg)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	882
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	883 call CheckDefFailure(["let x = '1' * '2'"], 'E1036:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	884 call CheckDefFailure(["let x = '1' / '2'"], 'E1036:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	885 call CheckDefFailure(["let x = '1' % '2'"], 'E1035:')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	886
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	887 call CheckDefFailure(["let x = 0z01 * 0z12"], 'E1036:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	888 call CheckDefFailure(["let x = 0z01 / 0z12"], 'E1036:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	889 call CheckDefFailure(["let x = 0z01 % 0z12"], 'E1035:')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	890
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	891 call CheckDefFailure(["let x = [1] * [2]"], 'E1036:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	892 call CheckDefFailure(["let x = [1] / [2]"], 'E1036:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	893 call CheckDefFailure(["let x = [1] % [2]"], 'E1035:')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	894
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	895 call CheckDefFailure(["let x = #{one: 1} * #{two: 2}"], 'E1036:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	896 call CheckDefFailure(["let x = #{one: 1} / #{two: 2}"], 'E1036:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	897 call CheckDefFailure(["let x = #{one: 1} % #{two: 2}"], 'E1035:')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	898
20349 e29b2ec8d4d2 patch 8.2.0730: Vim9: Assignment to dict member does not work Bram Moolenaar <Bram@vim.org> parents: 20328 diff changeset	899 call CheckDefFailure(["let x = 0xff[1]"], 'E1090:')
19423 f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	900 if has('float')
20349 e29b2ec8d4d2 patch 8.2.0730: Vim9: Assignment to dict member does not work Bram Moolenaar <Bram@vim.org> parents: 20328 diff changeset	901 call CheckDefFailure(["let x = 0.7[1]"], 'E1090:')
19423 f3e8e74cb747 patch 8.2.0269: Vim9: operator after list index does not work Bram Moolenaar <Bram@vim.org> parents: 19259 diff changeset	902 endif
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	903 endfunc
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	904
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	905 func Test_expr6_float_fails()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	906 CheckFeature float
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	907 call CheckDefFailure(["let x = 1.0 % 2"], 'E1035:')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	908 endfunc
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	909
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	910 " define here to use old style parsing
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	911 if has('float')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	912 let g:float_zero = 0.0
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	913 let g:float_neg = -9.8
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	914 let g:float_big = 9.9e99
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	915 endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	916 let g:blob_empty = 0z
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	917 let g:blob_one = 0z01
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	918 let g:blob_long = 0z0102.0304
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	919
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	920 let g:string_empty = ''
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	921 let g:string_short = 'x'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	922 let g:string_long = 'abcdefghijklm'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	923 let g:string_special = "ab\ncd\ref\ekk"
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	924
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	925 let g:special_true = v:true
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	926 let g:special_false = v:false
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	927 let g:special_null = v:null
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	928 let g:special_none = v:none
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	929
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	930 let g:list_empty = []
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	931 let g:list_mixed = [1, 'b', v:false]
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	932
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	933 let g:dict_empty = {}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	934 let g:dict_one = #{one: 1}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	935
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	936 let $TESTVAR = 'testvar'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	937
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	938 " test low level expression
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	939 def Test_expr7_number()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	940 " number constant
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	941 assert_equal(0, 0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	942 assert_equal(654, 0654)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	943
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	944 assert_equal(6, 0x6)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	945 assert_equal(15, 0xf)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	946 assert_equal(255, 0xff)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	947 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	948
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	949 def Test_expr7_float()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	950 " float constant
19259 77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	951 if !has('float')
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	952 MissingFeature 'float'
77cce0439714 patch 8.2.0188: Check commands don't work well with Vim9 script Bram Moolenaar <Bram@vim.org> parents: 19249 diff changeset	953 else
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	954 assert_equal(g:float_zero, .0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	955 assert_equal(g:float_zero, 0.0)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	956 assert_equal(g:float_neg, -9.8)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	957 assert_equal(g:float_big, 9.9e99)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	958 endif
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	959 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	960
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	961 def Test_expr7_blob()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	962 " blob constant
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	963 assert_equal(g:blob_empty, 0z)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	964 assert_equal(g:blob_one, 0z01)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	965 assert_equal(g:blob_long, 0z0102.0304)
19856 90eec641cc8c patch 8.2.0484: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19854 diff changeset	966
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	967 call CheckDefFailure(["let x = 0z123"], 'E973:')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	968 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	969
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	970 def Test_expr7_string()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	971 " string constant
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	972 assert_equal(g:string_empty, '')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	973 assert_equal(g:string_empty, "")
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	974 assert_equal(g:string_short, 'x')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	975 assert_equal(g:string_short, "x")
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	976 assert_equal(g:string_long, 'abcdefghijklm')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	977 assert_equal(g:string_long, "abcdefghijklm")
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	978 assert_equal(g:string_special, "ab\ncd\ref\ekk")
19856 90eec641cc8c patch 8.2.0484: Vim9: some error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19854 diff changeset	979
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	980 call CheckDefFailure(['let x = "abc'], 'E114:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	981 call CheckDefFailure(["let x = 'abc"], 'E115:')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	982 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	983
19960 3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19912 diff changeset	984 def Test_expr7_vimvar()
3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19912 diff changeset	985 let old: list<string> = v:oldfiles
3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19912 diff changeset	986 let compl: dict<any> = v:completed_item
3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19912 diff changeset	987
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	988 call CheckDefFailure(["let old: list<number> = v:oldfiles"], 'E1013: type mismatch, expected list<number> but got list<string>')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	989 call CheckDefFailure(["let old: dict<number> = v:completed_item"], 'E1013: type mismatch, expected dict<number> but got dict<any>')
19960 3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19912 diff changeset	990 enddef
3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19912 diff changeset	991
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	992 def Test_expr7_special()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	993 " special constant
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	994 assert_equal(g:special_true, true)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	995 assert_equal(g:special_false, false)
19960 3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19912 diff changeset	996 assert_equal(g:special_true, v:true)
3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19912 diff changeset	997 assert_equal(g:special_false, v:false)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	998 assert_equal(g:special_null, v:null)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	999 assert_equal(g:special_none, v:none)
19960 3c11b9f6fa03 patch 8.2.0536: Vim9: some compilation code not tested Bram Moolenaar <Bram@vim.org> parents: 19912 diff changeset	1000
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1001 call CheckDefFailure(['v:true = true'], 'E46:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1002 call CheckDefFailure(['v:true = false'], 'E46:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1003 call CheckDefFailure(['v:false = true'], 'E46:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1004 call CheckDefFailure(['v:null = 11'], 'E46:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1005 call CheckDefFailure(['v:none = 22'], 'E46:')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1006 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1007
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1008 def Test_expr7_list()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1009 " list
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1010 assert_equal(g:list_empty, [])
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1011 assert_equal(g:list_empty, [ ])
21028 7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1012 assert_equal(g:list_mixed, [1, 'b', false,])
19848 36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1013 assert_equal('b', g:list_mixed[1])
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	1014
20287 ce1b73835822 patch 8.2.0699: Vim9: not all errors tested Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1015 call CheckDefExecFailure(["let x = g:anint[3]"], 'E714:')
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1016 call CheckDefFailure(["let x = g:list_mixed[xxx]"], 'E1001:')
20287 ce1b73835822 patch 8.2.0699: Vim9: not all errors tested Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1017 call CheckDefExecFailure(["let x = g:list_mixed['xx']"], 'E39:')
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1018 call CheckDefFailure(["let x = g:list_mixed[0"], 'E111:')
20287 ce1b73835822 patch 8.2.0699: Vim9: not all errors tested Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1019 call CheckDefExecFailure(["let x = g:list_empty[3]"], 'E684:')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1020 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1021
21028 7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1022 def Test_expr7_list_vim9script()
7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1023 let lines =<< trim END
7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1024 vim9script
7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1025 let l = [
7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1026 11,
7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1027 22,
7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1028 ]
7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1029 assert_equal([11, 22], l)
7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1030 END
7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1031 CheckScriptSuccess(lines)
7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1032
7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1033 lines =<< trim END
7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1034 vim9script
7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1035 let l = [11,
7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1036 22]
7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1037 assert_equal([11, 22], l)
7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1038 END
7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1039 CheckScriptSuccess(lines)
21034 2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1040
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1041 lines =<< trim END
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1042 vim9script
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1043 let l = [11,22]
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1044 END
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1045 CheckScriptFailure(lines, 'E1069:')
21028 7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1046 enddef
7acceb76669f patch 8.2.1065: Vim9: no line break allowed inside a list Bram Moolenaar <Bram@vim.org> parents: 21026 diff changeset	1047
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1048 def Test_expr7_lambda()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1049 " lambda
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1050 let La = { -> 'result'}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1051 assert_equal('result', La())
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1052 assert_equal([1, 3, 5], [1, 2, 3]->map({key, val -> key + val}))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1053 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1054
21040 d9e0db9b2b99 patch 8.2.1071: Vim9: no line break allowed inside a lambda Bram Moolenaar <Bram@vim.org> parents: 21034 diff changeset	1055 def Test_expr7_lambda_vim9script()
d9e0db9b2b99 patch 8.2.1071: Vim9: no line break allowed inside a lambda Bram Moolenaar <Bram@vim.org> parents: 21034 diff changeset	1056 let lines =<< trim END
d9e0db9b2b99 patch 8.2.1071: Vim9: no line break allowed inside a lambda Bram Moolenaar <Bram@vim.org> parents: 21034 diff changeset	1057 vim9script
d9e0db9b2b99 patch 8.2.1071: Vim9: no line break allowed inside a lambda Bram Moolenaar <Bram@vim.org> parents: 21034 diff changeset	1058 let v = 10->{a ->
d9e0db9b2b99 patch 8.2.1071: Vim9: no line break allowed inside a lambda Bram Moolenaar <Bram@vim.org> parents: 21034 diff changeset	1059 a
d9e0db9b2b99 patch 8.2.1071: Vim9: no line break allowed inside a lambda Bram Moolenaar <Bram@vim.org> parents: 21034 diff changeset	1060 + 2
d9e0db9b2b99 patch 8.2.1071: Vim9: no line break allowed inside a lambda Bram Moolenaar <Bram@vim.org> parents: 21034 diff changeset	1061 }()
d9e0db9b2b99 patch 8.2.1071: Vim9: no line break allowed inside a lambda Bram Moolenaar <Bram@vim.org> parents: 21034 diff changeset	1062 assert_equal(12, v)
d9e0db9b2b99 patch 8.2.1071: Vim9: no line break allowed inside a lambda Bram Moolenaar <Bram@vim.org> parents: 21034 diff changeset	1063 END
d9e0db9b2b99 patch 8.2.1071: Vim9: no line break allowed inside a lambda Bram Moolenaar <Bram@vim.org> parents: 21034 diff changeset	1064 CheckScriptSuccess(lines)
d9e0db9b2b99 patch 8.2.1071: Vim9: no line break allowed inside a lambda Bram Moolenaar <Bram@vim.org> parents: 21034 diff changeset	1065 enddef
d9e0db9b2b99 patch 8.2.1071: Vim9: no line break allowed inside a lambda Bram Moolenaar <Bram@vim.org> parents: 21034 diff changeset	1066
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1067 def Test_expr7_dict()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1068 " dictionary
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1069 assert_equal(g:dict_empty, {})
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1070 assert_equal(g:dict_empty, { })
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1071 assert_equal(g:dict_one, {'one': 1})
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1072 let key = 'one'
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1073 let val = 1
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1074 assert_equal(g:dict_one, {key: val})
19461 08ef11a81daa patch 8.2.0288: Vim9: some float and blob operators not tested Bram Moolenaar <Bram@vim.org> parents: 19451 diff changeset	1075
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1076 call CheckDefFailure(["let x = #{8: 8}"], 'E1014:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1077 call CheckDefFailure(["let x = #{xxx}"], 'E720:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1078 call CheckDefFailure(["let x = #{xxx: 1", "let y = 2"], 'E722:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1079 call CheckDefFailure(["let x = #{xxx: 1,"], 'E723:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1080 call CheckDefFailure(["let x = {'a': xxx}"], 'E1001:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1081 call CheckDefFailure(["let x = {xxx: 8}"], 'E1001:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1082 call CheckDefFailure(["let x = #{a: 1, a: 2}"], 'E721:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1083 call CheckDefFailure(["let x = #"], 'E1015:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1084 call CheckDefFailure(["let x += 1"], 'E1020:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1085 call CheckDefFailure(["let x = x + 1"], 'E1001:')
20287 ce1b73835822 patch 8.2.0699: Vim9: not all errors tested Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1086 call CheckDefExecFailure(["let x = g:anint.member"], 'E715:')
ce1b73835822 patch 8.2.0699: Vim9: not all errors tested Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1087 call CheckDefExecFailure(["let x = g:dict_empty.member"], 'E716:')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1088 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1089
21034 2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1090 def Test_expr7_dict_vim9script()
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1091 let lines =<< trim END
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1092 vim9script
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1093 let d = {
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1094 'one':
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1095 1,
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1096 'two': 2,
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1097 }
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1098 assert_equal({'one': 1, 'two': 2}, d)
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1099 END
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1100 CheckScriptSuccess(lines)
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1101
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1102 lines =<< trim END
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1103 vim9script
21118 b0baa80cb53f patch 8.2.1110: Vim9: line continuation does not work in function arguments Bram Moolenaar <Bram@vim.org> parents: 21046 diff changeset	1104 let d = { "one": "one", "two": "two", }
b0baa80cb53f patch 8.2.1110: Vim9: line continuation does not work in function arguments Bram Moolenaar <Bram@vim.org> parents: 21046 diff changeset	1105 assert_equal({'one': 'one', 'two': 'two'}, d)
b0baa80cb53f patch 8.2.1110: Vim9: line continuation does not work in function arguments Bram Moolenaar <Bram@vim.org> parents: 21046 diff changeset	1106 END
b0baa80cb53f patch 8.2.1110: Vim9: line continuation does not work in function arguments Bram Moolenaar <Bram@vim.org> parents: 21046 diff changeset	1107 CheckScriptSuccess(lines)
b0baa80cb53f patch 8.2.1110: Vim9: line continuation does not work in function arguments Bram Moolenaar <Bram@vim.org> parents: 21046 diff changeset	1108
b0baa80cb53f patch 8.2.1110: Vim9: line continuation does not work in function arguments Bram Moolenaar <Bram@vim.org> parents: 21046 diff changeset	1109 lines =<< trim END
b0baa80cb53f patch 8.2.1110: Vim9: line continuation does not work in function arguments Bram Moolenaar <Bram@vim.org> parents: 21046 diff changeset	1110 vim9script
21034 2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1111 let d = #{one: 1,
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1112 two: 2,
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1113 }
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1114 assert_equal({'one': 1, 'two': 2}, d)
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1115 END
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1116 CheckScriptSuccess(lines)
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1117
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1118 lines =<< trim END
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1119 vim9script
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1120 let d = #{one:1, two: 2}
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1121 END
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1122 CheckScriptFailure(lines, 'E1069:')
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1123
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1124 lines =<< trim END
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1125 vim9script
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1126 let d = #{one: 1,two: 2}
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1127 END
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1128 CheckScriptFailure(lines, 'E1069:')
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1129 enddef
2f8b0812819f patch 8.2.1068: Vim9: no line break allowed inside a dict Bram Moolenaar <Bram@vim.org> parents: 21032 diff changeset	1130
21168 f26a606e6dbc patch 8.2.1135: Vim9: getting a dict member may not work Bram Moolenaar <Bram@vim.org> parents: 21166 diff changeset	1131 let g:oneString = 'one'
f26a606e6dbc patch 8.2.1135: Vim9: getting a dict member may not work Bram Moolenaar <Bram@vim.org> parents: 21166 diff changeset	1132
19848 36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1133 def Test_expr_member()
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1134 assert_equal(1, g:dict_one.one)
20411 23af9e1a5283 patch 8.2.0760: Vim9: dict member errors not tested Bram Moolenaar <Bram@vim.org> parents: 20349 diff changeset	1135 let d: dict<number> = g:dict_one
23af9e1a5283 patch 8.2.0760: Vim9: dict member errors not tested Bram Moolenaar <Bram@vim.org> parents: 20349 diff changeset	1136 assert_equal(1, d['one'])
19848 36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1137
21152 1561311249bb patch 8.2.1127: Vim9: getting a dict member may not work Bram Moolenaar <Bram@vim.org> parents: 21142 diff changeset	1138 # getting the one member should clear the dict after getting the item
1561311249bb patch 8.2.1127: Vim9: getting a dict member may not work Bram Moolenaar <Bram@vim.org> parents: 21142 diff changeset	1139 assert_equal('one', #{one: 'one'}.one)
21168 f26a606e6dbc patch 8.2.1135: Vim9: getting a dict member may not work Bram Moolenaar <Bram@vim.org> parents: 21166 diff changeset	1140 assert_equal('one', #{one: 'one'}[g:oneString])
21152 1561311249bb patch 8.2.1127: Vim9: getting a dict member may not work Bram Moolenaar <Bram@vim.org> parents: 21142 diff changeset	1141
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1142 call CheckDefFailure(["let x = g:dict_one.#$!"], 'E1002:')
20411 23af9e1a5283 patch 8.2.0760: Vim9: dict member errors not tested Bram Moolenaar <Bram@vim.org> parents: 20349 diff changeset	1143 call CheckDefExecFailure(["let d: dict<any>", "echo d['a']"], 'E716:')
23af9e1a5283 patch 8.2.0760: Vim9: dict member errors not tested Bram Moolenaar <Bram@vim.org> parents: 20349 diff changeset	1144 call CheckDefExecFailure(["let d: dict<number>", "d = g:list_empty"], 'E1029: Expected dict but got list')
19848 36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1145 enddef
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1146
21166 64f664f9b23a patch 8.2.1134: Vim9: getting a list member may not work Bram Moolenaar <Bram@vim.org> parents: 21152 diff changeset	1147 def Test_expr_index()
64f664f9b23a patch 8.2.1134: Vim9: getting a list member may not work Bram Moolenaar <Bram@vim.org> parents: 21152 diff changeset	1148 # getting the one member should clear the list only after getting the item
64f664f9b23a patch 8.2.1134: Vim9: getting a list member may not work Bram Moolenaar <Bram@vim.org> parents: 21152 diff changeset	1149 assert_equal('bbb', ['aaa', 'bbb', 'ccc'][1])
64f664f9b23a patch 8.2.1134: Vim9: getting a list member may not work Bram Moolenaar <Bram@vim.org> parents: 21152 diff changeset	1150 enddef
64f664f9b23a patch 8.2.1134: Vim9: getting a list member may not work Bram Moolenaar <Bram@vim.org> parents: 21152 diff changeset	1151
21142 165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1152 def Test_expr_member_vim9script()
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1153 let lines =<< trim END
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1154 vim9script
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1155 let d = #{one:
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1156 'one',
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1157 two: 'two'}
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1158 assert_equal('one', d.one)
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1159 assert_equal('one', d
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1160 .one)
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1161 assert_equal('one', d[
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1162 'one'
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1163 ])
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1164 END
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1165 CheckScriptSuccess(lines)
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1166
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1167 lines =<< trim END
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1168 vim9script
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1169 let l = [1,
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1170 2,
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1171 3, 4
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1172 ]
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1173 assert_equal(2, l[
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1174 1
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1175 ])
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1176 assert_equal([2, 3], l[1 : 2])
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1177 assert_equal([1, 2, 3], l[
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1178 :
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1179 2
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1180 ])
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1181 assert_equal([3, 4], l[
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1182 2
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1183 :
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1184 ])
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1185 END
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1186 CheckScriptSuccess(lines)
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1187 enddef
165cea61e974 patch 8.2.1122: Vim9: line continuation in dict member not recognized Bram Moolenaar <Bram@vim.org> parents: 21122 diff changeset	1188
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1189 def Test_expr7_option()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1190 " option
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1191 set ts=11
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1192 assert_equal(11, &ts)
19449 f8408ba21982 patch 8.2.0282: Vim9: setting number option not tested Bram Moolenaar <Bram@vim.org> parents: 19437 diff changeset	1193 &ts = 9
f8408ba21982 patch 8.2.0282: Vim9: setting number option not tested Bram Moolenaar <Bram@vim.org> parents: 19437 diff changeset	1194 assert_equal(9, &ts)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1195 set ts=8
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1196 set grepprg=some\ text
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1197 assert_equal('some text', &grepprg)
19219 89931701e033 patch 8.2.0168: Coverity warning for assigning NULL to an option Bram Moolenaar <Bram@vim.org> parents: 19217 diff changeset	1198 &grepprg = test_null_string()
89931701e033 patch 8.2.0168: Coverity warning for assigning NULL to an option Bram Moolenaar <Bram@vim.org> parents: 19217 diff changeset	1199 assert_equal('', &grepprg)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1200 set grepprg&
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1201 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1202
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1203 def Test_expr7_environment()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1204 " environment variable
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1205 assert_equal('testvar', $TESTVAR)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1206 assert_equal('', $ASDF_ASD_XXX)
19842 e4ade28bfaf7 patch 8.2.0477: Vim9: error messages not tested Bram Moolenaar <Bram@vim.org> parents: 19826 diff changeset	1207
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1208 call CheckDefFailure(["let x = $$$"], 'E1002:')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1209 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1210
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1211 def Test_expr7_register()
19449 f8408ba21982 patch 8.2.0282: Vim9: setting number option not tested Bram Moolenaar <Bram@vim.org> parents: 19437 diff changeset	1212 @a = 'register a'
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1213 assert_equal('register a', @a)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1214 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1215
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1216 def Test_expr7_parens()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1217 " (expr)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1218 assert_equal(4, (6 * 4) / 6)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1219 assert_equal(0, 6 * ( 4 / 6 ))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1220
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1221 assert_equal(6, +6)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1222 assert_equal(-6, -6)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1223 assert_equal(6, --6)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1224 assert_equal(6, -+-6)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1225 assert_equal(-6, ---6)
21032 f80e822a310d patch 8.2.1067: expression "!expr->func()" does not work Bram Moolenaar <Bram@vim.org> parents: 21028 diff changeset	1226 assert_equal(false, !-3)
f80e822a310d patch 8.2.1067: expression "!expr->func()" does not work Bram Moolenaar <Bram@vim.org> parents: 21028 diff changeset	1227 assert_equal(true, !+-+0)
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1228 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1229
21044 dc2ca403a217 patch 8.2.1073: Vim9: no line break allowed in () expression Bram Moolenaar <Bram@vim.org> parents: 21040 diff changeset	1230 def Test_expr7_parens_vim9script()
dc2ca403a217 patch 8.2.1073: Vim9: no line break allowed in () expression Bram Moolenaar <Bram@vim.org> parents: 21040 diff changeset	1231 let lines =<< trim END
dc2ca403a217 patch 8.2.1073: Vim9: no line break allowed in () expression Bram Moolenaar <Bram@vim.org> parents: 21040 diff changeset	1232 vim9script
dc2ca403a217 patch 8.2.1073: Vim9: no line break allowed in () expression Bram Moolenaar <Bram@vim.org> parents: 21040 diff changeset	1233 let s = (
dc2ca403a217 patch 8.2.1073: Vim9: no line break allowed in () expression Bram Moolenaar <Bram@vim.org> parents: 21040 diff changeset	1234 'one'
dc2ca403a217 patch 8.2.1073: Vim9: no line break allowed in () expression Bram Moolenaar <Bram@vim.org> parents: 21040 diff changeset	1235 ..
dc2ca403a217 patch 8.2.1073: Vim9: no line break allowed in () expression Bram Moolenaar <Bram@vim.org> parents: 21040 diff changeset	1236 'two'
dc2ca403a217 patch 8.2.1073: Vim9: no line break allowed in () expression Bram Moolenaar <Bram@vim.org> parents: 21040 diff changeset	1237 )
dc2ca403a217 patch 8.2.1073: Vim9: no line break allowed in () expression Bram Moolenaar <Bram@vim.org> parents: 21040 diff changeset	1238 assert_equal('onetwo', s)
dc2ca403a217 patch 8.2.1073: Vim9: no line break allowed in () expression Bram Moolenaar <Bram@vim.org> parents: 21040 diff changeset	1239 END
dc2ca403a217 patch 8.2.1073: Vim9: no line break allowed in () expression Bram Moolenaar <Bram@vim.org> parents: 21040 diff changeset	1240 CheckScriptSuccess(lines)
dc2ca403a217 patch 8.2.1073: Vim9: no line break allowed in () expression Bram Moolenaar <Bram@vim.org> parents: 21040 diff changeset	1241 enddef
dc2ca403a217 patch 8.2.1073: Vim9: no line break allowed in () expression Bram Moolenaar <Bram@vim.org> parents: 21040 diff changeset	1242
19848 36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1243 def Test_expr7_negate()
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1244 assert_equal(-99, -99)
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1245 assert_equal(99, --99)
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1246 let nr = 88
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1247 assert_equal(-88, -nr)
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1248 assert_equal(88, --nr)
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1249 enddef
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1250
20029 8fb1cf4c44d5 patch 8.2.0570: Vim9: no error when omitting type from argument Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	1251 def Echo(arg: any): string
19848 36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1252 return arg
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1253 enddef
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1254
20029 8fb1cf4c44d5 patch 8.2.0570: Vim9: no error when omitting type from argument Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	1255 def s:EchoArg(arg: any): string
19848 36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1256 return arg
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1257 enddef
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1258
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1259 def Test_expr7_call()
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1260 assert_equal('yes', 'yes'->Echo())
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1261 assert_equal('yes', 'yes'->s:EchoArg())
21032 f80e822a310d patch 8.2.1067: expression "!expr->func()" does not work Bram Moolenaar <Bram@vim.org> parents: 21028 diff changeset	1262 assert_equal(1, !range(5)->empty())
f80e822a310d patch 8.2.1067: expression "!expr->func()" does not work Bram Moolenaar <Bram@vim.org> parents: 21028 diff changeset	1263 assert_equal([0, 1, 2], --3->range())
19848 36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1264
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1265 call CheckDefFailure(["let x = 'yes'->Echo"], 'E107:')
19848 36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1266 enddef
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1267
36d629aa3d6e patch 8.2.0480: Vim9: some code is not tested Bram Moolenaar <Bram@vim.org> parents: 19842 diff changeset	1268
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1269 def Test_expr7_not()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1270 assert_equal(true, !'')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1271 assert_equal(true, ![])
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1272 assert_equal(false, !'asdf')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1273 assert_equal(false, ![2])
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1274 assert_equal(true, !!'asdf')
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1275 assert_equal(true, !![2])
19483 0d3dcb4476ba patch 8.2.0299: Vim9: ISN_STORE with argument not tested Bram Moolenaar <Bram@vim.org> parents: 19469 diff changeset	1276
0d3dcb4476ba patch 8.2.0299: Vim9: ISN_STORE with argument not tested Bram Moolenaar <Bram@vim.org> parents: 19469 diff changeset	1277 assert_equal(true, !test_null_partial())
0d3dcb4476ba patch 8.2.0299: Vim9: ISN_STORE with argument not tested Bram Moolenaar <Bram@vim.org> parents: 19469 diff changeset	1278 assert_equal(false, !{-> 'yes'})
0d3dcb4476ba patch 8.2.0299: Vim9: ISN_STORE with argument not tested Bram Moolenaar <Bram@vim.org> parents: 19469 diff changeset	1279
0d3dcb4476ba patch 8.2.0299: Vim9: ISN_STORE with argument not tested Bram Moolenaar <Bram@vim.org> parents: 19469 diff changeset	1280 assert_equal(true, !test_null_dict())
0d3dcb4476ba patch 8.2.0299: Vim9: ISN_STORE with argument not tested Bram Moolenaar <Bram@vim.org> parents: 19469 diff changeset	1281 assert_equal(true, !{})
0d3dcb4476ba patch 8.2.0299: Vim9: ISN_STORE with argument not tested Bram Moolenaar <Bram@vim.org> parents: 19469 diff changeset	1282 assert_equal(false, !{'yes': 'no'})
0d3dcb4476ba patch 8.2.0299: Vim9: ISN_STORE with argument not tested Bram Moolenaar <Bram@vim.org> parents: 19469 diff changeset	1283
19485 a09636ecee3c patch 8.2.0300: Vim9: expression test fails without channel support Bram Moolenaar <Bram@vim.org> parents: 19483 diff changeset	1284 if has('channel')
a09636ecee3c patch 8.2.0300: Vim9: expression test fails without channel support Bram Moolenaar <Bram@vim.org> parents: 19483 diff changeset	1285 assert_equal(true, !test_null_job())
a09636ecee3c patch 8.2.0300: Vim9: expression test fails without channel support Bram Moolenaar <Bram@vim.org> parents: 19483 diff changeset	1286 assert_equal(true, !test_null_channel())
a09636ecee3c patch 8.2.0300: Vim9: expression test fails without channel support Bram Moolenaar <Bram@vim.org> parents: 19483 diff changeset	1287 endif
19483 0d3dcb4476ba patch 8.2.0299: Vim9: ISN_STORE with argument not tested Bram Moolenaar <Bram@vim.org> parents: 19469 diff changeset	1288
0d3dcb4476ba patch 8.2.0299: Vim9: ISN_STORE with argument not tested Bram Moolenaar <Bram@vim.org> parents: 19469 diff changeset	1289 assert_equal(true, !test_null_blob())
0d3dcb4476ba patch 8.2.0299: Vim9: ISN_STORE with argument not tested Bram Moolenaar <Bram@vim.org> parents: 19469 diff changeset	1290 assert_equal(true, !0z)
0d3dcb4476ba patch 8.2.0299: Vim9: ISN_STORE with argument not tested Bram Moolenaar <Bram@vim.org> parents: 19469 diff changeset	1291 assert_equal(false, !0z01)
0d3dcb4476ba patch 8.2.0299: Vim9: ISN_STORE with argument not tested Bram Moolenaar <Bram@vim.org> parents: 19469 diff changeset	1292
0d3dcb4476ba patch 8.2.0299: Vim9: ISN_STORE with argument not tested Bram Moolenaar <Bram@vim.org> parents: 19469 diff changeset	1293 assert_equal(true, !test_void())
0d3dcb4476ba patch 8.2.0299: Vim9: ISN_STORE with argument not tested Bram Moolenaar <Bram@vim.org> parents: 19469 diff changeset	1294 assert_equal(true, !test_unknown())
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1295 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1296
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1297 func Test_expr7_fails()
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1298 call CheckDefFailure(["let x = (12"], "E110:")
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1299
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1300 call CheckDefFailure(["let x = -'xx'"], "E1030:")
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1301 call CheckDefFailure(["let x = +'xx'"], "E1030:")
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1302 call CheckDefFailure(["let x = -0z12"], "E974:")
20287 ce1b73835822 patch 8.2.0699: Vim9: not all errors tested Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1303 call CheckDefExecFailure(["let x = -[8]"], "E39:")
ce1b73835822 patch 8.2.0699: Vim9: not all errors tested Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1304 call CheckDefExecFailure(["let x = -{'a': 1}"], "E39:")
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1305
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1306 call CheckDefFailure(["let x = @"], "E1002:")
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1307 call CheckDefFailure(["let x = @<"], "E354:")
19217 1235c26d9f04 patch 8.2.0167: Coverity warning for ignoring return value Bram Moolenaar <Bram@vim.org> parents: 19181 diff changeset	1308
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1309 call CheckDefFailure(["let x = [1, 2"], "E697:")
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1310 call CheckDefFailure(["let x = [notfound]"], "E1001:")
19826 293a22b677a8 patch 8.2.0469: Vim9: no error for missing ] after list Bram Moolenaar <Bram@vim.org> parents: 19822 diff changeset	1311
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1312 call CheckDefFailure(["let x = { -> 123) }"], "E451:")
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1313 call CheckDefFailure(["let x = 123->{x -> x + 5) }"], "E451:")
19826 293a22b677a8 patch 8.2.0469: Vim9: no error for missing ] after list Bram Moolenaar <Bram@vim.org> parents: 19822 diff changeset	1314
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1315 call CheckDefFailure(["let x = &notexist"], 'E113:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1316 call CheckDefFailure(["&grepprg = [343]"], 'E1013:')
19451 b26e96f7c12f patch 8.2.0283: Vim9: failing to load script var not tested Bram Moolenaar <Bram@vim.org> parents: 19449 diff changeset	1317
20287 ce1b73835822 patch 8.2.0699: Vim9: not all errors tested Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1318 call CheckDefExecFailure(["echo s:doesnt_exist"], 'E121:')
ce1b73835822 patch 8.2.0699: Vim9: not all errors tested Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1319 call CheckDefExecFailure(["echo g:doesnt_exist"], 'E121:')
19469 55656a51d2af patch 8.2.0292: Vim9: CHECKNR and CHECKTYPE instructions not tested Bram Moolenaar <Bram@vim.org> parents: 19461 diff changeset	1320
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1321 call CheckDefFailure(["echo a:somevar"], 'E1075:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1322 call CheckDefFailure(["echo l:somevar"], 'E1075:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1323 call CheckDefFailure(["echo x:somevar"], 'E1075:')
19822 fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1324
20287 ce1b73835822 patch 8.2.0699: Vim9: not all errors tested Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1325 call CheckDefExecFailure(["let x = +g:astring"], 'E1030:')
ce1b73835822 patch 8.2.0699: Vim9: not all errors tested Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1326 call CheckDefExecFailure(["let x = +g:ablob"], 'E974:')
ce1b73835822 patch 8.2.0699: Vim9: not all errors tested Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1327 call CheckDefExecFailure(["let x = +g:alist"], 'E745:')
ce1b73835822 patch 8.2.0699: Vim9: not all errors tested Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1328 call CheckDefExecFailure(["let x = +g:adict"], 'E728:')
19558 8eeec8886c02 patch 8.2.0336: Vim9: insufficient test coverage for compiling Bram Moolenaar <Bram@vim.org> parents: 19521 diff changeset	1329
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1330 call CheckDefFailure(["let x = ''", "let y = x.memb"], 'E715:')
19822 fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1331
21122 839ace6773aa patch 8.2.1112: Vim9: no line continuation allowed in method call Bram Moolenaar <Bram@vim.org> parents: 21118 diff changeset	1332 call CheckDefExecFailure(["[1, 2->len()"], 'E697:')
20287 ce1b73835822 patch 8.2.0699: Vim9: not all errors tested Bram Moolenaar <Bram@vim.org> parents: 20207 diff changeset	1333 call CheckDefExecFailure(["#{a: 1->len()"], 'E488:')
21122 839ace6773aa patch 8.2.1112: Vim9: no line continuation allowed in method call Bram Moolenaar <Bram@vim.org> parents: 21118 diff changeset	1334 call CheckDefExecFailure(["{'a': 1->len()"], 'E723:')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1335 endfunc
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1336
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1337 let g:Funcrefs = [function('add')]
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1338
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1339 func CallMe(arg)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1340 return a:arg
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1341 endfunc
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1342
19437 5d34ae66118e patch 8.2.0276: Vim9: not allowing space before ")" in function call Bram Moolenaar <Bram@vim.org> parents: 19423 diff changeset	1343 func CallMe2(one, two)
5d34ae66118e patch 8.2.0276: Vim9: not allowing space before ")" in function call Bram Moolenaar <Bram@vim.org> parents: 19423 diff changeset	1344 return a:one .. a:two
5d34ae66118e patch 8.2.0276: Vim9: not allowing space before ")" in function call Bram Moolenaar <Bram@vim.org> parents: 19423 diff changeset	1345 endfunc
5d34ae66118e patch 8.2.0276: Vim9: not allowing space before ")" in function call Bram Moolenaar <Bram@vim.org> parents: 19423 diff changeset	1346
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1347 def Test_expr7_trailing()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1348 " user function call
20189 63cc54100ae4 patch 8.2.0650: Vim9: script function can be deleted Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	1349 assert_equal(123, g:CallMe(123))
63cc54100ae4 patch 8.2.0650: Vim9: script function can be deleted Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	1350 assert_equal(123, g:CallMe( 123))
63cc54100ae4 patch 8.2.0650: Vim9: script function can be deleted Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	1351 assert_equal(123, g:CallMe(123 ))
63cc54100ae4 patch 8.2.0650: Vim9: script function can be deleted Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	1352 assert_equal('yesno', g:CallMe2('yes', 'no'))
63cc54100ae4 patch 8.2.0650: Vim9: script function can be deleted Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	1353 assert_equal('yesno', g:CallMe2( 'yes', 'no' ))
63cc54100ae4 patch 8.2.0650: Vim9: script function can be deleted Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	1354 assert_equal('nothing', g:CallMe('nothing'))
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1355
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1356 " partial call
20189 63cc54100ae4 patch 8.2.0650: Vim9: script function can be deleted Bram Moolenaar <Bram@vim.org> parents: 20170 diff changeset	1357 let Part = function('g:CallMe')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1358 assert_equal('yes', Part('yes'))
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1359
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1360 " funcref call, using list index
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1361 let l = []
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1362 g:Funcrefs[0](l, 2)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1363 assert_equal([2], l)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1364
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1365 " method call
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1366 l = [2, 5, 6]
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1367 l->map({k, v -> k + v})
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1368 assert_equal([2, 6, 8], l)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1369
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1370 " lambda method call
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1371 l = [2, 5]
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1372 l->{l -> add(l, 8)}()
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1373 assert_equal([2, 5, 8], l)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1374
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1375 " dict member
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1376 let d = #{key: 123}
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1377 assert_equal(123, d.key)
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1378 enddef
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1379
20949 62912ad41aff patch 8.2.1026: Vim9: cannot break the line after "->" Bram Moolenaar <Bram@vim.org> parents: 20919 diff changeset	1380 def Test_expr7_subscript_linebreak()
62912ad41aff patch 8.2.1026: Vim9: cannot break the line after "->" Bram Moolenaar <Bram@vim.org> parents: 20919 diff changeset	1381 let range = range(
62912ad41aff patch 8.2.1026: Vim9: cannot break the line after "->" Bram Moolenaar <Bram@vim.org> parents: 20919 diff changeset	1382 3)
62912ad41aff patch 8.2.1026: Vim9: cannot break the line after "->" Bram Moolenaar <Bram@vim.org> parents: 20919 diff changeset	1383 let l = range->
62912ad41aff patch 8.2.1026: Vim9: cannot break the line after "->" Bram Moolenaar <Bram@vim.org> parents: 20919 diff changeset	1384 map('string(v:key)')
62912ad41aff patch 8.2.1026: Vim9: cannot break the line after "->" Bram Moolenaar <Bram@vim.org> parents: 20919 diff changeset	1385 assert_equal(['0', '1', '2'], l)
62912ad41aff patch 8.2.1026: Vim9: cannot break the line after "->" Bram Moolenaar <Bram@vim.org> parents: 20919 diff changeset	1386
20955 396fe712eb0f patch 8.2.1029: Vim9: cannot chain function calls with -> at line start Bram Moolenaar <Bram@vim.org> parents: 20953 diff changeset	1387 l = range
396fe712eb0f patch 8.2.1029: Vim9: cannot chain function calls with -> at line start Bram Moolenaar <Bram@vim.org> parents: 20953 diff changeset	1388 ->map('string(v:key)')
396fe712eb0f patch 8.2.1029: Vim9: cannot chain function calls with -> at line start Bram Moolenaar <Bram@vim.org> parents: 20953 diff changeset	1389 assert_equal(['0', '1', '2'], l)
396fe712eb0f patch 8.2.1029: Vim9: cannot chain function calls with -> at line start Bram Moolenaar <Bram@vim.org> parents: 20953 diff changeset	1390
396fe712eb0f patch 8.2.1029: Vim9: cannot chain function calls with -> at line start Bram Moolenaar <Bram@vim.org> parents: 20953 diff changeset	1391 l = range # comment
396fe712eb0f patch 8.2.1029: Vim9: cannot chain function calls with -> at line start Bram Moolenaar <Bram@vim.org> parents: 20953 diff changeset	1392 ->map('string(v:key)')
396fe712eb0f patch 8.2.1029: Vim9: cannot chain function calls with -> at line start Bram Moolenaar <Bram@vim.org> parents: 20953 diff changeset	1393 assert_equal(['0', '1', '2'], l)
396fe712eb0f patch 8.2.1029: Vim9: cannot chain function calls with -> at line start Bram Moolenaar <Bram@vim.org> parents: 20953 diff changeset	1394
396fe712eb0f patch 8.2.1029: Vim9: cannot chain function calls with -> at line start Bram Moolenaar <Bram@vim.org> parents: 20953 diff changeset	1395 l = range
396fe712eb0f patch 8.2.1029: Vim9: cannot chain function calls with -> at line start Bram Moolenaar <Bram@vim.org> parents: 20953 diff changeset	1396
396fe712eb0f patch 8.2.1029: Vim9: cannot chain function calls with -> at line start Bram Moolenaar <Bram@vim.org> parents: 20953 diff changeset	1397 ->map('string(v:key)')
396fe712eb0f patch 8.2.1029: Vim9: cannot chain function calls with -> at line start Bram Moolenaar <Bram@vim.org> parents: 20953 diff changeset	1398 assert_equal(['0', '1', '2'], l)
396fe712eb0f patch 8.2.1029: Vim9: cannot chain function calls with -> at line start Bram Moolenaar <Bram@vim.org> parents: 20953 diff changeset	1399
396fe712eb0f patch 8.2.1029: Vim9: cannot chain function calls with -> at line start Bram Moolenaar <Bram@vim.org> parents: 20953 diff changeset	1400 l = range
396fe712eb0f patch 8.2.1029: Vim9: cannot chain function calls with -> at line start Bram Moolenaar <Bram@vim.org> parents: 20953 diff changeset	1401 # comment
396fe712eb0f patch 8.2.1029: Vim9: cannot chain function calls with -> at line start Bram Moolenaar <Bram@vim.org> parents: 20953 diff changeset	1402 ->map('string(v:key)')
396fe712eb0f patch 8.2.1029: Vim9: cannot chain function calls with -> at line start Bram Moolenaar <Bram@vim.org> parents: 20953 diff changeset	1403 assert_equal(['0', '1', '2'], l)
396fe712eb0f patch 8.2.1029: Vim9: cannot chain function calls with -> at line start Bram Moolenaar <Bram@vim.org> parents: 20953 diff changeset	1404
20949 62912ad41aff patch 8.2.1026: Vim9: cannot break the line after "->" Bram Moolenaar <Bram@vim.org> parents: 20919 diff changeset	1405 assert_equal('1', l[
62912ad41aff patch 8.2.1026: Vim9: cannot break the line after "->" Bram Moolenaar <Bram@vim.org> parents: 20919 diff changeset	1406 1])
62912ad41aff patch 8.2.1026: Vim9: cannot break the line after "->" Bram Moolenaar <Bram@vim.org> parents: 20919 diff changeset	1407
62912ad41aff patch 8.2.1026: Vim9: cannot break the line after "->" Bram Moolenaar <Bram@vim.org> parents: 20919 diff changeset	1408 let d = #{one: 33}
62912ad41aff patch 8.2.1026: Vim9: cannot break the line after "->" Bram Moolenaar <Bram@vim.org> parents: 20919 diff changeset	1409 assert_equal(33, d.
62912ad41aff patch 8.2.1026: Vim9: cannot break the line after "->" Bram Moolenaar <Bram@vim.org> parents: 20919 diff changeset	1410 one)
62912ad41aff patch 8.2.1026: Vim9: cannot break the line after "->" Bram Moolenaar <Bram@vim.org> parents: 20919 diff changeset	1411 enddef
62912ad41aff patch 8.2.1026: Vim9: cannot break the line after "->" Bram Moolenaar <Bram@vim.org> parents: 20919 diff changeset	1412
20029 8fb1cf4c44d5 patch 8.2.0570: Vim9: no error when omitting type from argument Bram Moolenaar <Bram@vim.org> parents: 20013 diff changeset	1413
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1414 func Test_expr7_trailing_fails()
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1415 call CheckDefFailure(['let l = [2]', 'l->{l -> add(l, 8)}'], 'E107')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1416 call CheckDefFailure(['let l = [2]', 'l->{l -> add(l, 8)} ()'], 'E274')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1417 endfunc
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1418
94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1419 func Test_expr_fails()
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1420 call CheckDefFailure(["let x = '1'is2"], 'E488:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1421 call CheckDefFailure(["let x = '1'isnot2"], 'E488:')
19437 5d34ae66118e patch 8.2.0276: Vim9: not allowing space before ")" in function call Bram Moolenaar <Bram@vim.org> parents: 19423 diff changeset	1422
21210 44611891e22c patch 8.2.1156: Vim9: No error for invalid command in compiled function Bram Moolenaar <Bram@vim.org> parents: 21168 diff changeset	1423 call CheckDefFailure(["CallMe ('yes')"], 'E476:')
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1424 call CheckDefFailure(["CallMe2('yes','no')"], 'E1069:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1425 call CheckDefFailure(["CallMe2('yes' , 'no')"], 'E1068:')
19521 860b39ed0e0b patch 8.2.0318: Vim9: types not sufficiently tested Bram Moolenaar <Bram@vim.org> parents: 19485 diff changeset	1426
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1427 call CheckDefFailure(["v:nosuch += 3"], 'E1001:')
20953 6b4b887a12f0 patch 8.2.1028: Vim9: no error for declaring buffer, window, etc. variable Bram Moolenaar <Bram@vim.org> parents: 20949 diff changeset	1428 call CheckDefFailure(["let v:statusmsg = ''"], 'E1016: Cannot declare a v: variable:')
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1429 call CheckDefFailure(["let asdf = v:nosuch"], 'E1001:')
19822 fc3cdc819d80 patch 8.2.0467: Vim9: some errors are not tested Bram Moolenaar <Bram@vim.org> parents: 19583 diff changeset	1430
20170 0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1431 call CheckDefFailure(["echo len('asdf'"], 'E110:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1432 call CheckDefFailure(["echo Func0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789()"], 'E1011:')
0612c64a2b87 patch 8.2.0640: Vim9: expanding does not work Bram Moolenaar <Bram@vim.org> parents: 20089 diff changeset	1433 call CheckDefFailure(["echo doesnotexist()"], 'E117:')
19181 94eda51ba9ba patch 8.2.0149: maintaining a Vim9 branch separately is more work Bram Moolenaar <Bram@vim.org> parents: diff changeset	1434 endfunc

Mercurial > vim

annotate src/testdir/test_vim9_expr.vim @ 21210:44611891e22c v8.2.1156