test compiler literal-1 -body {
	
	vexpr {{1 2 3 4}}
	
} -result {1 2 3 4}

test compiler literal-2 -body {
	
	vexpr {{{1 2} {3 4}}}
	
} -result {{1 2} {3 4}}

test compiler sliceexpression-1 -body {
	
	set x {1 2 3 4 5 6 7}
	vexpr {n=2; m=3; x[n:m]}
	
} -result {3 4}

test compiler sliceexpression-2 -body {
	
	set x {1 2 3 4 5 6 7}
	vexpr {n=2; m=3; x[n:m*n]}
	
} -result {3 4 5 6 7}

test compiler sliceexpression-3 -body {
	
	set x {1 2 3 4 5 6 7}
	vexpr {n=2; m=3; x[n:m+n]}
	
} -result {3 4 5 6}

test compiler sliceexpression-4 -body {
	
	set x {1 2 3 4 5 6 7}
	vexpr {n=2; m=3; x[n:m*2]}
	
} -result {3 4 5 6 7}

test compiler sliceexpression-5 -body {
	
	set x {1 2 3 4 5 6 7}
	vexpr {n=2; m=3; x[n:m*3]}
	
} -result {Stop index out of bounds} -returnCodes 1

test compiler sliceexpression-6 -body {
	
	set x {1 2 3 4 5 6 7}
	vexpr {end=-1; x[2:end]}
	
} -result {3 4 5 6 7}

test compiler sliceexpression-7 -body {
	
	set x {1 2 3 4 5 6 7}
	vexpr {end=-1; x[2:end-2]}
	
} -result {3 4 5}

test compiler sliceexpression-8 -body {
	
	set x {1 2 3 4 5 6 7}
	vexpr {end=-1; s=2; x[0:end-1:s]}
	
} -result {1 3 5}

test compiler sliceexpression-9 -body {
	
	set x {1 2 3 4 5 6 7}
	vexpr {end=-1; s=2; x[0:end-1:s*2]}
	
} -result {1 5}

test compiler boolif-1 -body {
	
	vexpr {r={ }; for x=1:20 { if x>5 && x<15 { r=vstack(r,x) }}; r}
	
} -result {6 7 8 9 10 11 12 13 14}

test compiler boolif-2 -body {
	
	vexpr {r={ }; for x=1:20 { if x>3 && x<5 || x>17 { r=vstack(r,x) }}; r}
	
} -result {4 18 19 20}

test compiler boolif-3 -body {
	
	vexpr {r={ }; for x=1:20 { if x>=3 && (x<=5 || x>=17) { r=vstack(r,x) }}; r}
	
} -result {3 4 5 17 18 19 20}

test compiler boolif-4 -body {
	
	vexpr {r={ }; for x=1:20 { if x>=3 { r=vstack(r,x) }}; r}
	
} -result {3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20}

test compiler boolif-5 -body {
	
	vexpr {r={ }; for x=1:20 { if !(x>=3) { r=vstack(r,x) }}; r}
	
} -result {1 2}

test compiler namespace-1 -body {
	
	set ::A {1 2 3}
	vexpr ::A
	
} -result {1 2 3}


test compiler namespace-2 -body {
	
	namespace eval a {
	  namespace eval b { variable f 7 }
	  proc t {} { vexpr b::f }
	}
	
	a::t
	
} -result 7

test compiler whitespace-1 -body {
	
	set a 2
	set b 3
	vexpr {min(a,b)}
	
} -result 2

test compiler whitespace-2 -body {
	
	set a 2
	set b 3
	vexpr { min(a,b)}
	
} -result 2

test compiler whitespace-3 -body {
	
	set a 2
	set b 3
	vexpr { min(a,b) }
	
} -result 2

test compiler whitespace-4 -body {
	
	set a 2
	set b 3
	vexpr { min(a,b ) }
	
} -result 2

test compiler whitespace-5 -body {
	
	set a 2
	set b 3
	vexpr { min( a,b ) }
	
} -result 2

test compiler whitespace-6 -body {
	
	set a 2
	set b 3
	vexpr { min( a ,b ) }
	
} -result 2

test compiler whitespace-7 -body {
	
	set a 2
	set b 3
	vexpr { min( a , b ) }
	
} -result 2

test compiler whitespace-8 -body {
	
	proc fun {} {}
	vexpr {fun()}
	
} -result {}

test compiler whitespace-9 -body {
	
	proc fun {} {}
	vexpr { fun()}
	
} -result {}

test compiler whitespace-10 -body {
	
	proc fun {} {}
	vexpr { fun() }
	
} -result {}

test compiler whitespace-13 -body {
	
	proc fun {} {}
	vexpr {fun(  )}
	
} -result {Error: Parse error in line 1:6
fun(  )
      ^} -returnCodes 1

test compiler whitespace-14 -body {
	
	proc fun {} {}
	vexpr {fun ()}
	
} -result {Error: Parse error in line 1:4
fun ()
    ^} -returnCodes 1

test compiler precedence-1 -body {
	
	vexpr {0 && 1 || 1}
	
} -result 1

test compiler precedence-2 -body {
	
	vexpr {0 && (1 || 1)}
	
} -result 0

test compiler precedence-3 -body {
	
	vexpr {1 || 1 && 0}
	
} -result 1

test compiler precedence-4 -body {
	
	vexpr {(1 || 1) && 0}
	
} -result 0

