core/xgo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
xgo/vm_test.go

3982 lines
108 KiB
Go
Raw Blame History

package tengo_test
import (
"errors"
"fmt"
"math"
"math/rand"
"reflect"
_runtime "runtime"
"strings"
"testing"
"github.com/d5/tengo/v2"
"github.com/d5/tengo/v2/parser"
"github.com/d5/tengo/v2/require"
"github.com/d5/tengo/v2/stdlib"
"github.com/d5/tengo/v2/token"
)
const testOut = "out"
type IARR []interface{}
type IMAP map[string]interface{}
type MAP = map[string]interface{}
type ARR = []interface{}
type testopts struct {
modules *tengo.ModuleMap
symbols map[string]tengo.Object
maxAllocs int64
skip2ndPass bool
}
func Opts() *testopts {
return &testopts{
modules: tengo.NewModuleMap(),
symbols: make(map[string]tengo.Object),
maxAllocs: -1,
skip2ndPass: false,
}
}
func (o *testopts) copy() *testopts {
c := &testopts{
modules: o.modules.Copy(),
symbols: make(map[string]tengo.Object),
maxAllocs: o.maxAllocs,
skip2ndPass: o.skip2ndPass,
}
for k, v := range o.symbols {
c.symbols[k] = v
}
return c
}
func (o *testopts) Stdlib() *testopts {
o.modules.AddMap(stdlib.GetModuleMap(stdlib.AllModuleNames()...))
return o
}
func (o *testopts) Module(name string, mod interface{}) *testopts {
c := o.copy()
switch mod := mod.(type) {
case tengo.Importable:
c.modules.Add(name, mod)
case string:
c.modules.AddSourceModule(name, []byte(mod))
case []byte:
c.modules.AddSourceModule(name, mod)
default:
panic(fmt.Errorf("invalid module type: %T", mod))
}
return c
}
func (o *testopts) Symbol(name string, value tengo.Object) *testopts {
c := o.copy()
c.symbols[name] = value
return c
}
func (o *testopts) MaxAllocs(limit int64) *testopts {
c := o.copy()
c.maxAllocs = limit
return c
}
func (o *testopts) Skip2ndPass() *testopts {
c := o.copy()
c.skip2ndPass = true
return c
}
type customError struct {
err error
str string
}
func (c *customError) Error() string {
return c.str
}
func (c *customError) Unwrap() error {
return c.err
}
func TestArray(t *testing.T) {
expectRun(t, `out = [1, 2 * 2, 3 + 3]`, nil, ARR{1, 4, 6})
// array copy-by-reference
expectRun(t, `a1 := [1, 2, 3]; a2 := a1; a1[0] = 5; out = a2`,
nil, ARR{5, 2, 3})
expectRun(t, `func () { a1 := [1, 2, 3]; a2 := a1; a1[0] = 5; out = a2 }()`,
nil, ARR{5, 2, 3})
// array index set
expectError(t, `a1 := [1, 2, 3]; a1[3] = 5`,
nil, "index out of bounds")
// index operator
arr := ARR{1, 2, 3, 4, 5, 6}
arrStr := `[1, 2, 3, 4, 5, 6]`
arrLen := 6
for idx := 0; idx < arrLen; idx++ {
expectRun(t, fmt.Sprintf("out = %s[%d]", arrStr, idx),
nil, arr[idx])
expectRun(t, fmt.Sprintf("out = %s[0 + %d]", arrStr, idx),
nil, arr[idx])
expectRun(t, fmt.Sprintf("out = %s[1 + %d - 1]", arrStr, idx),
nil, arr[idx])
expectRun(t, fmt.Sprintf("idx := %d; out = %s[idx]", idx, arrStr),
nil, arr[idx])
}
expectRun(t, fmt.Sprintf("%s[%d]", arrStr, -1),
nil, tengo.UndefinedValue)
expectRun(t, fmt.Sprintf("%s[%d]", arrStr, arrLen),
nil, tengo.UndefinedValue)
// slice operator
for low := 0; low < arrLen; low++ {
expectRun(t, fmt.Sprintf("out = %s[%d:%d]", arrStr, low, low),
nil, ARR{})
for high := low; high <= arrLen; high++ {
expectRun(t, fmt.Sprintf("out = %s[%d:%d]", arrStr, low, high),
nil, arr[low:high])
expectRun(t, fmt.Sprintf("out = %s[0 + %d : 0 + %d]",
arrStr, low, high), nil, arr[low:high])
expectRun(t, fmt.Sprintf("out = %s[1 + %d - 1 : 1 + %d - 1]",
arrStr, low, high), nil, arr[low:high])
expectRun(t, fmt.Sprintf("out = %s[:%d]", arrStr, high),
nil, arr[:high])
expectRun(t, fmt.Sprintf("out = %s[%d:]", arrStr, low),
nil, arr[low:])
}
}
expectRun(t, fmt.Sprintf("out = %s[:]", arrStr),
nil, arr)
expectRun(t, fmt.Sprintf("out = %s[%d:]", arrStr, -1),
nil, arr)
expectRun(t, fmt.Sprintf("out = %s[:%d]", arrStr, arrLen+1),
nil, arr)
expectRun(t, fmt.Sprintf("out = %s[%d:%d]", arrStr, 2, 2),
nil, ARR{})
expectError(t, fmt.Sprintf("%s[:%d]", arrStr, -1),
nil, "invalid slice index")
expectError(t, fmt.Sprintf("%s[%d:]", arrStr, arrLen+1),
nil, "invalid slice index")
expectError(t, fmt.Sprintf("%s[%d:%d]", arrStr, 0, -1),
nil, "invalid slice index")
expectError(t, fmt.Sprintf("%s[%d:%d]", arrStr, 2, 1),
nil, "invalid slice index")
}
func TestAssignment(t *testing.T) {
expectRun(t, `a := 1; a = 2; out = a`, nil, 2)
expectRun(t, `a := 1; a = 2; out = a`, nil, 2)
expectRun(t, `a := 1; a = a + 4; out = a`, nil, 5)
expectRun(t, `a := 1; f1 := func() { a = 2; return a }; out = f1()`,
nil, 2)
expectRun(t, `a := 1; f1 := func() { a := 3; a = 2; return a }; out = f1()`,
nil, 2)
expectRun(t, `a := 1; out = a`, nil, 1)
expectRun(t, `a := 1; a = 2; out = a`, nil, 2)
expectRun(t, `a := 1; func() { a = 2 }(); out = a`, nil, 2)
expectRun(t, `a := 1; func() { a := 2 }(); out = a`, nil, 1) // "a := 2" defines a new local variable 'a'
expectRun(t, `a := 1; func() { b := 2; out = b }()`, nil, 2)
expectRun(t, `
out = func() {
a := 2
func() {
a = 3 // captured from outer scope
}()
return a
}()
`, nil, 3)
expectRun(t, `
func() {
a := 5
out = func() {
a := 4
return a
}()
}()`, nil, 4)
expectError(t, `a := 1; a := 2`, nil, "redeclared") // redeclared in the same scope
expectError(t, `func() { a := 1; a := 2 }()`, nil, "redeclared") // redeclared in the same scope
expectRun(t, `a := 1; a += 2; out = a`, nil, 3)
expectRun(t, `a := 1; a += 4 - 2;; out = a`, nil, 3)
expectRun(t, `a := 3; a -= 1;; out = a`, nil, 2)
expectRun(t, `a := 3; a -= 5 - 4;; out = a`, nil, 2)
expectRun(t, `a := 2; a *= 4;; out = a`, nil, 8)
expectRun(t, `a := 2; a *= 1 + 3;; out = a`, nil, 8)
expectRun(t, `a := 10; a /= 2;; out = a`, nil, 5)
expectRun(t, `a := 10; a /= 5 - 3;; out = a`, nil, 5)
// compound assignment operator does not define new variable
expectError(t, `a += 4`, nil, "unresolved reference")
expectError(t, `a -= 4`, nil, "unresolved reference")
expectError(t, `a *= 4`, nil, "unresolved reference")
expectError(t, `a /= 4`, nil, "unresolved reference")
expectRun(t, `
f1 := func() {
f2 := func() {
a := 1
a += 2 // it's a statement, not an expression
return a
};
return f2();
};
out = f1();`, nil, 3)
expectRun(t, `f1 := func() { f2 := func() { a := 1; a += 4 - 2; return a }; return f2(); }; out = f1()`,
nil, 3)
expectRun(t, `f1 := func() { f2 := func() { a := 3; a -= 1; return a }; return f2(); }; out = f1()`,
nil, 2)
expectRun(t, `f1 := func() { f2 := func() { a := 3; a -= 5 - 4; return a }; return f2(); }; out = f1()`,
nil, 2)
expectRun(t, `f1 := func() { f2 := func() { a := 2; a *= 4; return a }; return f2(); }; out = f1()`,
nil, 8)
expectRun(t, `f1 := func() { f2 := func() { a := 2; a *= 1 + 3; return a }; return f2(); }; out = f1()`,
nil, 8)
expectRun(t, `f1 := func() { f2 := func() { a := 10; a /= 2; return a }; return f2(); }; out = f1()`,
nil, 5)
expectRun(t, `f1 := func() { f2 := func() { a := 10; a /= 5 - 3; return a }; return f2(); }; out = f1()`,
nil, 5)
expectRun(t, `a := 1; f1 := func() { f2 := func() { a += 2; return a }; return f2(); }; out = f1()`,
nil, 3)
expectRun(t, `
f1 := func(a) {
return func(b) {
c := a
c += b * 2
return c
}
}
out = f1(3)(4)
`, nil, 11)
expectRun(t, `
out = func() {
a := 1
func() {
a = 2
func() {
a = 3
func() {
a := 4 // declared new
}()
}()
}()
return a
}()
`, nil, 3)
// write on free variables
expectRun(t, `
f1 := func() {
a := 5
return func() {
a += 3
return a
}()
}
out = f1()
`, nil, 8)
expectRun(t, `
out = func() {
f1 := func() {
a := 5
add1 := func() { a += 1 }
add2 := func() { a += 2 }
a += 3
return func() { a += 4; add1(); add2(); a += 5; return a }
}
return f1()
}()()
`, nil, 20)
expectRun(t, `
it := func(seq, fn) {
fn(seq[0])
fn(seq[1])
fn(seq[2])
}
foo := func(a) {
b := 0
it([1, 2, 3], func(x) {
b = x + a
})
return b
}
out = foo(2)
`, nil, 5)
expectRun(t, `
it := func(seq, fn) {
fn(seq[0])
fn(seq[1])
fn(seq[2])
}
foo := func(a) {
b := 0
it([1, 2, 3], func(x) {
b += x + a
})
return b
}
out = foo(2)
`, nil, 12)
expectRun(t, `
out = func() {
a := 1
func() {
a = 2
}()
return a
}()
`, nil, 2)
expectRun(t, `
f := func() {
a := 1
return {
b: func() { a += 3 },
c: func() { a += 2 },
d: func() { return a }
}
}
m := f()
m.b()
m.c()
out = m.d()
`, nil, 6)
expectRun(t, `
each := func(s, x) { for i:=0; i<len(s); i++ { x(s[i]) } }
out = func() {
a := 100
each([1, 2, 3], func(x) {
a += x
})
a += 10
return func(b) {
return a + b
}
}()(20)
`, nil, 136)
// assigning different type value
expectRun(t, `a := 1; a = "foo"; out = a`, nil, "foo") // global
expectRun(t, `func() { a := 1; a = "foo"; out = a }()`, nil, "foo") // local
expectRun(t, `
out = func() {
a := 5
return func() {
a = "foo"
return a
}()
}()`, nil, "foo") // free
// variables declared in if/for blocks
expectRun(t, `for a:=0; a<5; a++ {}; a := "foo"; out = a`,
nil, "foo")
expectRun(t, `func() { for a:=0; a<5; a++ {}; a := "foo"; out = a }()`,
nil, "foo")
// selectors
expectRun(t, `a:=[1,2,3]; a[1] = 5; out = a[1]`, nil, 5)
expectRun(t, `a:=[1,2,3]; a[1] += 5; out = a[1]`, nil, 7)
expectRun(t, `a:={b:1,c:2}; a.b = 5; out = a.b`, nil, 5)
expectRun(t, `a:={b:1,c:2}; a.b += 5; out = a.b`, nil, 6)
expectRun(t, `a:={b:1,c:2}; a.b += a.c; out = a.b`, nil, 3)
expectRun(t, `a:={b:1,c:2}; a.b += a.c; out = a.c`, nil, 2)
expectRun(t, `
a := {
b: [1, 2, 3],
c: {
d: 8,
e: "foo",
f: [9, 8]
}
}
a.c.f[1] += 2
out = a["c"]["f"][1]
`, nil, 10)
expectRun(t, `
a := {
b: [1, 2, 3],
c: {
d: 8,
e: "foo",
f: [9, 8]
}
}
a.c.h = "bar"
out = a.c.h
`, nil, "bar")
expectError(t, `
a := {
b: [1, 2, 3],
c: {
d: 8,
e: "foo",
f: [9, 8]
}
}
a.x.e = "bar"`, nil, "not index-assignable")
}
func TestBitwise(t *testing.T) {
expectRun(t, `out = 1 & 1`, nil, 1)
expectRun(t, `out = 1 & 0`, nil, 0)
expectRun(t, `out = 0 & 1`, nil, 0)
expectRun(t, `out = 0 & 0`, nil, 0)
expectRun(t, `out = 1 | 1`, nil, 1)
expectRun(t, `out = 1 | 0`, nil, 1)
expectRun(t, `out = 0 | 1`, nil, 1)
expectRun(t, `out = 0 | 0`, nil, 0)
expectRun(t, `out = 1 ^ 1`, nil, 0)
expectRun(t, `out = 1 ^ 0`, nil, 1)
expectRun(t, `out = 0 ^ 1`, nil, 1)
expectRun(t, `out = 0 ^ 0`, nil, 0)
expectRun(t, `out = 1 &^ 1`, nil, 0)
expectRun(t, `out = 1 &^ 0`, nil, 1)
expectRun(t, `out = 0 &^ 1`, nil, 0)
expectRun(t, `out = 0 &^ 0`, nil, 0)
expectRun(t, `out = 1 << 2`, nil, 4)
expectRun(t, `out = 16 >> 2`, nil, 4)
expectRun(t, `out = 1; out &= 1`, nil, 1)
expectRun(t, `out = 1; out |= 0`, nil, 1)
expectRun(t, `out = 1; out ^= 0`, nil, 1)
expectRun(t, `out = 1; out &^= 0`, nil, 1)
expectRun(t, `out = 1; out <<= 2`, nil, 4)
expectRun(t, `out = 16; out >>= 2`, nil, 4)
expectRun(t, `out = ^0`, nil, ^0)
expectRun(t, `out = ^1`, nil, ^1)
expectRun(t, `out = ^55`, nil, ^55)
expectRun(t, `out = ^-55`, nil, ^-55)
}
func TestBoolean(t *testing.T) {
expectRun(t, `out = true`, nil, true)
expectRun(t, `out = false`, nil, false)
expectRun(t, `out = 1 < 2`, nil, true)
expectRun(t, `out = 1 > 2`, nil, false)
expectRun(t, `out = 1 < 1`, nil, false)
expectRun(t, `out = 1 > 2`, nil, false)
expectRun(t, `out = 1 == 1`, nil, true)
expectRun(t, `out = 1 != 1`, nil, false)
expectRun(t, `out = 1 == 2`, nil, false)
expectRun(t, `out = 1 != 2`, nil, true)
expectRun(t, `out = 1 <= 2`, nil, true)
expectRun(t, `out = 1 >= 2`, nil, false)
expectRun(t, `out = 1 <= 1`, nil, true)
expectRun(t, `out = 1 >= 2`, nil, false)
expectRun(t, `out = true == true`, nil, true)
expectRun(t, `out = false == false`, nil, true)
expectRun(t, `out = true == false`, nil, false)
expectRun(t, `out = true != false`, nil, true)
expectRun(t, `out = false != true`, nil, true)
expectRun(t, `out = (1 < 2) == true`, nil, true)
expectRun(t, `out = (1 < 2) == false`, nil, false)
expectRun(t, `out = (1 > 2) == true`, nil, false)
expectRun(t, `out = (1 > 2) == false`, nil, true)
expectError(t, `5 + true`, nil, "invalid operation")
expectError(t, `5 + true; 5`, nil, "invalid operation")
expectError(t, `-true`, nil, "invalid operation")
expectError(t, `true + false`, nil, "invalid operation")
expectError(t, `5; true + false; 5`, nil, "invalid operation")
expectError(t, `if (10 > 1) { true + false; }`, nil, "invalid operation")
expectError(t, `
func() {
if (10 > 1) {
if (10 > 1) {
return true + false;
}
return 1;
}
}()
`, nil, "invalid operation")
expectError(t, `if (true + false) { 10 }`, nil, "invalid operation")
expectError(t, `10 + (true + false)`, nil, "invalid operation")
expectError(t, `(true + false) + 20`, nil, "invalid operation")
expectError(t, `!(true + false)`, nil, "invalid operation")
}
func TestUndefined(t *testing.T) {
expectRun(t, `out = undefined`, nil, tengo.UndefinedValue)
expectRun(t, `out = undefined.a`, nil, tengo.UndefinedValue)
expectRun(t, `out = undefined[1]`, nil, tengo.UndefinedValue)
expectRun(t, `out = undefined.a.b`, nil, tengo.UndefinedValue)
expectRun(t, `out = undefined[1][2]`, nil, tengo.UndefinedValue)
expectRun(t, `out = undefined ? 1 : 2`, nil, 2)
expectRun(t, `out = undefined == undefined`, nil, true)
expectRun(t, `out = undefined == 1`, nil, false)
expectRun(t, `out = 1 == undefined`, nil, false)
expectRun(t, `out = undefined == float([])`, nil, true)
expectRun(t, `out = float([]) == undefined`, nil, true)
}
func TestBuiltinFunction(t *testing.T) {
expectRun(t, `out = len("")`, nil, 0)
expectRun(t, `out = len("four")`, nil, 4)
expectRun(t, `out = len("hello world")`, nil, 11)
expectRun(t, `out = len([])`, nil, 0)
expectRun(t, `out = len([1, 2, 3])`, nil, 3)
expectRun(t, `out = len({})`, nil, 0)
expectRun(t, `out = len({a:1, b:2})`, nil, 2)
expectRun(t, `out = len(immutable([]))`, nil, 0)
expectRun(t, `out = len(immutable([1, 2, 3]))`, nil, 3)
expectRun(t, `out = len(immutable({}))`, nil, 0)
expectRun(t, `out = len(immutable({a:1, b:2}))`, nil, 2)
expectError(t, `len(1)`, nil, "invalid type for argument")
expectError(t, `len("one", "two")`, nil, "wrong number of arguments")
expectRun(t, `out = copy(1)`, nil, 1)
expectError(t, `copy(1, 2)`, nil, "wrong number of arguments")
expectRun(t, `out = append([1, 2, 3], 4)`, nil, ARR{1, 2, 3, 4})
expectRun(t, `out = append([1, 2, 3], 4, 5, 6)`, nil, ARR{1, 2, 3, 4, 5, 6})
expectRun(t, `out = append([1, 2, 3], "foo", false)`,
nil, ARR{1, 2, 3, "foo", false})
expectRun(t, `out = int(1)`, nil, 1)
expectRun(t, `out = int(1.8)`, nil, 1)
expectRun(t, `out = int("-522")`, nil, -522)
expectRun(t, `out = int(true)`, nil, 1)
expectRun(t, `out = int(false)`, nil, 0)
expectRun(t, `out = int('8')`, nil, 56)
expectRun(t, `out = int([1])`, nil, tengo.UndefinedValue)
expectRun(t, `out = int({a: 1})`, nil, tengo.UndefinedValue)
expectRun(t, `out = int(undefined)`, nil, tengo.UndefinedValue)
expectRun(t, `out = int("-522", 1)`, nil, -522)
expectRun(t, `out = int(undefined, 1)`, nil, 1)
expectRun(t, `out = int(undefined, 1.8)`, nil, 1.8)
expectRun(t, `out = int(undefined, string(1))`, nil, "1")
expectRun(t, `out = int(undefined, undefined)`, nil, tengo.UndefinedValue)
expectRun(t, `out = string(1)`, nil, "1")
expectRun(t, `out = string(1.8)`, nil, "1.8")
expectRun(t, `out = string("-522")`, nil, "-522")
expectRun(t, `out = string(true)`, nil, "true")
expectRun(t, `out = string(false)`, nil, "false")
expectRun(t, `out = string('8')`, nil, "8")
expectRun(t, `out = string([1,8.1,true,3])`, nil, "[1, 8.1, true, 3]")
expectRun(t, `out = string({b: "foo"})`, nil, `{b: "foo"}`)
expectRun(t, `out = string(undefined)`, nil, tengo.UndefinedValue) // not "undefined"
expectRun(t, `out = string(1, "-522")`, nil, "1")
expectRun(t, `out = string(undefined, "-522")`, nil, "-522") // not "undefined"
expectRun(t, `out = float(1)`, nil, 1.0)
expectRun(t, `out = float(1.8)`, nil, 1.8)
expectRun(t, `out = float("-52.2")`, nil, -52.2)
expectRun(t, `out = float(true)`, nil, tengo.UndefinedValue)
expectRun(t, `out = float(false)`, nil, tengo.UndefinedValue)
expectRun(t, `out = float('8')`, nil, tengo.UndefinedValue)
expectRun(t, `out = float([1,8.1,true,3])`, nil, tengo.UndefinedValue)
expectRun(t, `out = float({a: 1, b: "foo"})`, nil, tengo.UndefinedValue)
expectRun(t, `out = float(undefined)`, nil, tengo.UndefinedValue)
expectRun(t, `out = float("-52.2", 1.8)`, nil, -52.2)
expectRun(t, `out = float(undefined, 1)`, nil, 1)
expectRun(t, `out = float(undefined, 1.8)`, nil, 1.8)
expectRun(t, `out = float(undefined, "-52.2")`, nil, "-52.2")
expectRun(t, `out = float(undefined, char(56))`, nil, '8')
expectRun(t, `out = float(undefined, undefined)`, nil, tengo.UndefinedValue)
expectRun(t, `out = char(56)`, nil, '8')
expectRun(t, `out = char(1.8)`, nil, tengo.UndefinedValue)
expectRun(t, `out = char("-52.2")`, nil, tengo.UndefinedValue)
expectRun(t, `out = char(true)`, nil, tengo.UndefinedValue)
expectRun(t, `out = char(false)`, nil, tengo.UndefinedValue)
expectRun(t, `out = char('8')`, nil, '8')
expectRun(t, `out = char([1,8.1,true,3])`, nil, tengo.UndefinedValue)
expectRun(t, `out = char({a: 1, b: "foo"})`, nil, tengo.UndefinedValue)
expectRun(t, `out = char(undefined)`, nil, tengo.UndefinedValue)
expectRun(t, `out = char(56, 'a')`, nil, '8')
expectRun(t, `out = char(undefined, '8')`, nil, '8')
expectRun(t, `out = char(undefined, 56)`, nil, 56)
expectRun(t, `out = char(undefined, "-52.2")`, nil, "-52.2")
expectRun(t, `out = char(undefined, undefined)`, nil, tengo.UndefinedValue)
expectRun(t, `out = bool(1)`, nil, true) // non-zero integer: true
expectRun(t, `out = bool(0)`, nil, false) // zero: true
expectRun(t, `out = bool(1.8)`, nil, true) // all floats (except for NaN): true
expectRun(t, `out = bool(0.0)`, nil, true) // all floats (except for NaN): true
expectRun(t, `out = bool("false")`, nil, true) // non-empty string: true
expectRun(t, `out = bool("")`, nil, false) // empty string: false
expectRun(t, `out = bool(true)`, nil, true) // true: true
expectRun(t, `out = bool(false)`, nil, false) // false: false
expectRun(t, `out = bool('8')`, nil, true) // non-zero chars: true
expectRun(t, `out = bool(char(0))`, nil, false) // zero char: false
expectRun(t, `out = bool([1])`, nil, true) // non-empty arrays: true
expectRun(t, `out = bool([])`, nil, false) // empty array: false
expectRun(t, `out = bool({a: 1})`, nil, true) // non-empty maps: true
expectRun(t, `out = bool({})`, nil, false) // empty maps: false
expectRun(t, `out = bool(undefined)`, nil, false) // undefined: false
expectRun(t, `out = bytes(1)`, nil, []byte{0})
expectRun(t, `out = bytes(1.8)`, nil, tengo.UndefinedValue)
expectRun(t, `out = bytes("-522")`, nil, []byte{'-', '5', '2', '2'})
expectRun(t, `out = bytes(true)`, nil, tengo.UndefinedValue)
expectRun(t, `out = bytes(false)`, nil, tengo.UndefinedValue)
expectRun(t, `out = bytes('8')`, nil, tengo.UndefinedValue)
expectRun(t, `out = bytes([1])`, nil, tengo.UndefinedValue)
expectRun(t, `out = bytes({a: 1})`, nil, tengo.UndefinedValue)
expectRun(t, `out = bytes(undefined)`, nil, tengo.UndefinedValue)
expectRun(t, `out = bytes("-522", ['8'])`, nil, []byte{'-', '5', '2', '2'})
expectRun(t, `out = bytes(undefined, "-522")`, nil, "-522")
expectRun(t, `out = bytes(undefined, 1)`, nil, 1)
expectRun(t, `out = bytes(undefined, 1.8)`, nil, 1.8)
expectRun(t, `out = bytes(undefined, int("-522"))`, nil, -522)
expectRun(t, `out = bytes(undefined, undefined)`, nil, tengo.UndefinedValue)
expectRun(t, `out = is_error(error(1))`, nil, true)
expectRun(t, `out = is_error(1)`, nil, false)
expectRun(t, `out = is_undefined(undefined)`, nil, true)
expectRun(t, `out = is_undefined(error(1))`, nil, false)
// type_name
expectRun(t, `out = type_name(1)`, nil, "int")
expectRun(t, `out = type_name(1.1)`, nil, "float")
expectRun(t, `out = type_name("a")`, nil, "string")
expectRun(t, `out = type_name([1,2,3])`, nil, "array")
expectRun(t, `out = type_name({k:1})`, nil, "map")
expectRun(t, `out = type_name('a')`, nil, "char")
expectRun(t, `out = type_name(true)`, nil, "bool")
expectRun(t, `out = type_name(false)`, nil, "bool")
expectRun(t, `out = type_name(bytes( 1))`, nil, "bytes")
expectRun(t, `out = type_name(undefined)`, nil, "undefined")
expectRun(t, `out = type_name(error("err"))`, nil, "error")
expectRun(t, `out = type_name(func() {})`, nil, "compiled-function")
expectRun(t, `a := func(x) { return func() { return x } }; out = type_name(a(5))`,
nil, "compiled-function") // closure
// is_function
expectRun(t, `out = is_function(1)`, nil, false)
expectRun(t, `out = is_function(func() {})`, nil, true)
expectRun(t, `out = is_function(func(x) { return x })`, nil, true)
expectRun(t, `out = is_function(len)`, nil, false) // builtin function
expectRun(t, `a := func(x) { return func() { return x } }; out = is_function(a)`,
nil, true) // function
expectRun(t, `a := func(x) { return func() { return x } }; out = is_function(a(5))`,
nil, true) // closure
expectRun(t, `out = is_function(x)`,
Opts().Symbol("x", &StringArray{
Value: []string{"foo", "bar"},
}).Skip2ndPass(),
false) // user object
// is_callable
expectRun(t, `out = is_callable(1)`, nil, false)
expectRun(t, `out = is_callable(func() {})`, nil, true)
expectRun(t, `out = is_callable(func(x) { return x })`, nil, true)
expectRun(t, `out = is_callable(len)`, nil, true) // builtin function
expectRun(t, `a := func(x) { return func() { return x } }; out = is_callable(a)`,
nil, true) // function
expectRun(t, `a := func(x) { return func() { return x } }; out = is_callable(a(5))`,
nil, true) // closure
expectRun(t, `out = is_callable(x)`,
Opts().Symbol("x", &StringArray{
Value: []string{"foo", "bar"},
}).Skip2ndPass(), true) // user object
expectRun(t, `out = format("")`, nil, "")
expectRun(t, `out = format("foo")`, nil, "foo")
expectRun(t, `out = format("foo %d %v %s", 1, 2, "bar")`,
nil, "foo 1 2 bar")
expectRun(t, `out = format("foo %v", [1, "bar", true])`,
nil, `foo [1, "bar", true]`)
expectRun(t, `out = format("foo %v %d", [1, "bar", true], 19)`,
nil, `foo [1, "bar", true] 19`)
expectRun(t, `out = format("foo %v", {"a": {"b": {"c": [1, 2, 3]}}})`,
nil, `foo {a: {b: {c: [1, 2, 3]}}}`)
expectRun(t, `out = format("%v", [1, [2, [3, 4]]])`,
nil, `[1, [2, [3, 4]]]`)
tengo.MaxStringLen = 9
expectError(t, `format("%s", "1234567890")`,
nil, "exceeding string size limit")
tengo.MaxStringLen = 2147483647
// delete
expectError(t, `delete()`, nil, tengo.ErrWrongNumArguments.Error())
expectError(t, `delete(1)`, nil, tengo.ErrWrongNumArguments.Error())
expectError(t, `delete(1, 2, 3)`, nil, tengo.ErrWrongNumArguments.Error())
expectError(t, `delete({}, "", 3)`, nil, tengo.ErrWrongNumArguments.Error())
expectError(t, `delete(1, 1)`, nil, `invalid type for argument 'first'`)
expectError(t, `delete(1.0, 1)`, nil, `invalid type for argument 'first'`)
expectError(t, `delete("str", 1)`, nil, `invalid type for argument 'first'`)
expectError(t, `delete(bytes("str"), 1)`, nil,
`invalid type for argument 'first'`)
expectError(t, `delete(error("err"), 1)`, nil,
`invalid type for argument 'first'`)
expectError(t, `delete(true, 1)`, nil, `invalid type for argument 'first'`)
expectError(t, `delete(char('c'), 1)`, nil,
`invalid type for argument 'first'`)
expectError(t, `delete(undefined, 1)`, nil,
`invalid type for argument 'first'`)
expectError(t, `delete(time(1257894000), 1)`, nil,
`invalid type for argument 'first'`)
expectError(t, `delete(immutable({}), "key")`, nil,
`invalid type for argument 'first'`)
expectError(t, `delete(immutable([]), "")`, nil,
`invalid type for argument 'first'`)
expectError(t, `delete([], "")`, nil, `invalid type for argument 'first'`)
expectError(t, `delete({}, 1)`, nil, `invalid type for argument 'second'`)
expectError(t, `delete({}, 1.0)`, nil, `invalid type for argument 'second'`)
expectError(t, `delete({}, undefined)`, nil,
`invalid type for argument 'second'`)
expectError(t, `delete({}, [])`, nil, `invalid type for argument 'second'`)
expectError(t, `delete({}, {})`, nil, `invalid type for argument 'second'`)
expectError(t, `delete({}, error("err"))`, nil,
`invalid type for argument 'second'`)
expectError(t, `delete({}, bytes("str"))`, nil,
`invalid type for argument 'second'`)
expectError(t, `delete({}, char(35))`, nil,
`invalid type for argument 'second'`)
expectError(t, `delete({}, time(1257894000))`, nil,
`invalid type for argument 'second'`)
expectError(t, `delete({}, immutable({}))`, nil,
`invalid type for argument 'second'`)
expectError(t, `delete({}, immutable([]))`, nil,
`invalid type for argument 'second'`)
expectRun(t, `out = delete({}, "")`, nil, tengo.UndefinedValue)
expectRun(t, `out = {key1: 1}; delete(out, "key1")`, nil, MAP{})
expectRun(t, `out = {key1: 1, key2: "2"}; delete(out, "key1")`, nil,
MAP{"key2": "2"})
expectRun(t, `out = [1, "2", {a: "b", c: 10}]; delete(out[2], "c")`, nil,
ARR{1, "2", MAP{"a": "b"}})
// splice
expectError(t, `splice()`, nil, tengo.ErrWrongNumArguments.Error())
expectError(t, `splice(1)`, nil, `invalid type for argument 'first'`)
expectError(t, `splice(1.0)`, nil, `invalid type for argument 'first'`)
expectError(t, `splice("str")`, nil, `invalid type for argument 'first'`)
expectError(t, `splice(bytes("str"))`, nil,
`invalid type for argument 'first'`)
expectError(t, `splice(error("err"))`, nil,
`invalid type for argument 'first'`)
expectError(t, `splice(true)`, nil, `invalid type for argument 'first'`)
expectError(t, `splice(char('c'))`, nil,
`invalid type for argument 'first'`)
expectError(t, `splice(undefined)`, nil,
`invalid type for argument 'first'`)
expectError(t, `splice(time(1257894000))`, nil,
`invalid type for argument 'first'`)
expectError(t, `splice(immutable({}))`, nil,
`invalid type for argument 'first'`)
expectError(t, `splice(immutable([]))`, nil,
`invalid type for argument 'first'`)
expectError(t, `splice({})`, nil, `invalid type for argument 'first'`)
expectError(t, `splice([], 1.0)`, nil,
`invalid type for argument 'second'`)
expectError(t, `splice([], "str")`, nil,
`invalid type for argument 'second'`)
expectError(t, `splice([], bytes("str"))`, nil,
`invalid type for argument 'second'`)
expectError(t, `splice([], error("error"))`, nil,
`invalid type for argument 'second'`)
expectError(t, `splice([], false)`, nil,
`invalid type for argument 'second'`)
expectError(t, `splice([], char('d'))`, nil,
`invalid type for argument 'second'`)
expectError(t, `splice([], undefined)`, nil,
`invalid type for argument 'second'`)
expectError(t, `splice([], time(0))`, nil,
`invalid type for argument 'second'`)
expectError(t, `splice([], [])`, nil,
`invalid type for argument 'second'`)
expectError(t, `splice([], {})`, nil,
`invalid type for argument 'second'`)
expectError(t, `splice([], immutable([]))`, nil,
`invalid type for argument 'second'`)
expectError(t, `splice([], immutable({}))`, nil,
`invalid type for argument 'second'`)
expectError(t, `splice([], 0, 1.0)`, nil,
`invalid type for argument 'third'`)
expectError(t, `splice([], 0, "string")`, nil,
`invalid type for argument 'third'`)
expectError(t, `splice([], 0, bytes("string"))`, nil,
`invalid type for argument 'third'`)
expectError(t, `splice([], 0, error("string"))`, nil,
`invalid type for argument 'third'`)
expectError(t, `splice([], 0, true)`, nil,
`invalid type for argument 'third'`)
expectError(t, `splice([], 0, char('f'))`, nil,
`invalid type for argument 'third'`)
expectError(t, `splice([], 0, undefined)`, nil,
`invalid type for argument 'third'`)
expectError(t, `splice([], 0, time(0))`, nil,
`invalid type for argument 'third'`)
expectError(t, `splice([], 0, [])`, nil,
`invalid type for argument 'third'`)
expectError(t, `splice([], 0, {})`, nil,
`invalid type for argument 'third'`)
expectError(t, `splice([], 0, immutable([]))`, nil,
`invalid type for argument 'third'`)
expectError(t, `splice([], 0, immutable({}))`, nil,
`invalid type for argument 'third'`)
expectError(t, `splice([], 1)`, nil, tengo.ErrIndexOutOfBounds.Error())
expectError(t, `splice([1, 2, 3], 0, -1)`, nil,
tengo.ErrIndexOutOfBounds.Error())
expectError(t, `splice([1, 2, 3], 99, 0, "a", "b")`, nil,
tengo.ErrIndexOutOfBounds.Error())
expectRun(t, `out = []; splice(out)`, nil, ARR{})
expectRun(t, `out = ["a"]; splice(out, 1)`, nil, ARR{"a"})
expectRun(t, `out = ["a"]; out = splice(out, 1)`, nil, ARR{})
expectRun(t, `out = [1, 2, 3]; splice(out, 0, 1)`, nil, ARR{2, 3})
expectRun(t, `out = [1, 2, 3]; out = splice(out, 0, 1)`, nil, ARR{1})
expectRun(t, `out = [1, 2, 3]; splice(out, 0, 0, "a", "b")`, nil,
ARR{"a", "b", 1, 2, 3})
expectRun(t, `out = [1, 2, 3]; out = splice(out, 0, 0, "a", "b")`, nil,
ARR{})
expectRun(t, `out = [1, 2, 3]; splice(out, 1, 0, "a", "b")`, nil,
ARR{1, "a", "b", 2, 3})
expectRun(t, `out = [1, 2, 3]; out = splice(out, 1, 0, "a", "b")`, nil,
ARR{})
expectRun(t, `out = [1, 2, 3]; splice(out, 1, 0, "a", "b")`, nil,
ARR{1, "a", "b", 2, 3})
expectRun(t, `out = [1, 2, 3]; splice(out, 2, 0, "a", "b")`, nil,
ARR{1, 2, "a", "b", 3})
expectRun(t, `out = [1, 2, 3]; splice(out, 3, 0, "a", "b")`, nil,
ARR{1, 2, 3, "a", "b"})
expectRun(t, `array := [1, 2, 3]; deleted := splice(array, 1, 1, "a", "b");
out = [deleted, array]`, nil, ARR{ARR{2}, ARR{1, "a", "b", 3}})
expectRun(t, `array := [1, 2, 3]; deleted := splice(array, 1);
out = [deleted, array]`, nil, ARR{ARR{2, 3}, ARR{1}})
expectRun(t, `out = []; splice(out, 0, 0, "a", "b")`, nil, ARR{"a", "b"})
expectRun(t, `out = []; splice(out, 0, 1, "a", "b")`, nil, ARR{"a", "b"})
expectRun(t, `out = []; out = splice(out, 0, 0, "a", "b")`, nil, ARR{})
expectRun(t, `out = splice(splice([1, 2, 3], 0, 3), 1, 3)`, nil, ARR{2, 3})
// splice doc examples
expectRun(t, `v := [1, 2, 3]; deleted := splice(v, 0);
out = [deleted, v]`, nil, ARR{ARR{1, 2, 3}, ARR{}})
expectRun(t, `v := [1, 2, 3]; deleted := splice(v, 1);
out = [deleted, v]`, nil, ARR{ARR{2, 3}, ARR{1}})
expectRun(t, `v := [1, 2, 3]; deleted := splice(v, 0, 1);
out = [deleted, v]`, nil, ARR{ARR{1}, ARR{2, 3}})
expectRun(t, `v := ["a", "b", "c"]; deleted := splice(v, 1, 2);
out = [deleted, v]`, nil, ARR{ARR{"b", "c"}, ARR{"a"}})
expectRun(t, `v := ["a", "b", "c"]; deleted := splice(v, 2, 1, "d");
out = [deleted, v]`, nil, ARR{ARR{"c"}, ARR{"a", "b", "d"}})
expectRun(t, `v := ["a", "b", "c"]; deleted := splice(v, 0, 0, "d", "e");
out = [deleted, v]`, nil, ARR{ARR{}, ARR{"d", "e", "a", "b", "c"}})
expectRun(t, `v := ["a", "b", "c"]; deleted := splice(v, 1, 1, "d", "e");
out = [deleted, v]`, nil, ARR{ARR{"b"}, ARR{"a", "d", "e", "c"}})
}
func TestBytesN(t *testing.T) {
curMaxBytesLen := tengo.MaxBytesLen
defer func() { tengo.MaxBytesLen = curMaxBytesLen }()
tengo.MaxBytesLen = 10
expectRun(t, `out = bytes(0)`, nil, make([]byte, 0))
expectRun(t, `out = bytes(10)`, nil, make([]byte, 10))
expectError(t, `bytes(11)`, nil, "bytes size limit")
tengo.MaxBytesLen = 1000
expectRun(t, `out = bytes(1000)`, nil, make([]byte, 1000))
expectError(t, `bytes(1001)`, nil, "bytes size limit")
}
func TestBytes(t *testing.T) {
expectRun(t, `out = bytes("Hello World!")`, nil, []byte("Hello World!"))
expectRun(t, `out = bytes("Hello") + bytes(" ") + bytes("World!")`,
nil, []byte("Hello World!"))
// bytes[] -> int
expectRun(t, `out = bytes("abcde")[0]`, nil, 97)
expectRun(t, `out = bytes("abcde")[1]`, nil, 98)
expectRun(t, `out = bytes("abcde")[4]`, nil, 101)
expectRun(t, `out = bytes("abcde")[10]`, nil, tengo.UndefinedValue)
}
func TestCall(t *testing.T) {
expectRun(t, `a := { b: func(x) { return x + 2 } }; out = a.b(5)`,
nil, 7)
expectRun(t, `a := { b: { c: func(x) { return x + 2 } } }; out = a.b.c(5)`,
nil, 7)
expectRun(t, `a := { b: { c: func(x) { return x + 2 } } }; out = a["b"].c(5)`,
nil, 7)
expectError(t, `a := 1
b := func(a, c) {
c(a)
}
c := func(a) {
a()
}
b(a, c)
`, nil, "Runtime Error: not callable: int\n\tat test:7:4\n\tat test:3:4\n\tat test:9:1")
}
func TestChar(t *testing.T) {
expectRun(t, `out = 'a'`, nil, 'a')
expectRun(t, `out = '九'`, nil, rune(20061))
expectRun(t, `out = 'Æ'`, nil, rune(198))
expectRun(t, `out = '0' + '9'`, nil, rune(105))
expectRun(t, `out = '0' + 9`, nil, '9')
expectRun(t, `out = '9' - 4`, nil, '5')
expectRun(t, `out = '0' == '0'`, nil, true)
expectRun(t, `out = '0' != '0'`, nil, false)
expectRun(t, `out = '2' < '4'`, nil, true)
expectRun(t, `out = '2' > '4'`, nil, false)
expectRun(t, `out = '2' <= '4'`, nil, true)
expectRun(t, `out = '2' >= '4'`, nil, false)
expectRun(t, `out = '4' < '4'`, nil, false)
expectRun(t, `out = '4' > '4'`, nil, false)
expectRun(t, `out = '4' <= '4'`, nil, true)
expectRun(t, `out = '4' >= '4'`, nil, true)
}
func TestCondExpr(t *testing.T) {
expectRun(t, `out = true ? 5 : 10`, nil, 5)
expectRun(t, `out = false ? 5 : 10`, nil, 10)
expectRun(t, `out = (1 == 1) ? 2 + 3 : 12 - 2`, nil, 5)
expectRun(t, `out = (1 != 1) ? 2 + 3 : 12 - 2`, nil, 10)
expectRun(t, `out = (1 == 1) ? true ? 10 - 8 : 1 + 3 : 12 - 2`, nil, 2)
expectRun(t, `out = (1 == 1) ? false ? 10 - 8 : 1 + 3 : 12 - 2`, nil, 4)
expectRun(t, `
out = 0
f1 := func() { out += 10 }
f2 := func() { out = -out }
true ? f1() : f2()
`, nil, 10)
expectRun(t, `
out = 5
f1 := func() { out += 10 }
f2 := func() { out = -out }
false ? f1() : f2()
`, nil, -5)
expectRun(t, `
f1 := func(a) { return a + 2 }
f2 := func(a) { return a - 2 }
f3 := func(a) { return a + 10 }
f4 := func(a) { return -a }
f := func(c) {
return c == 0 ? f1(c) : f2(c) ? f3(c) : f4(c)
}
out = [f(0), f(1), f(2)]
`, nil, ARR{2, 11, -2})
expectRun(t, `f := func(a) { return -a }; out = f(true ? 5 : 3)`, nil, -5)
expectRun(t, `out = [false?5:10, true?1:2]`, nil, ARR{10, 1})
expectRun(t, `
out = 1 > 2 ?
1 + 2 + 3 :
10 - 5`, nil, 5)
}
func TestEquality(t *testing.T) {
testEquality(t, `1`, `1`, true)
testEquality(t, `1`, `2`, false)
testEquality(t, `1.0`, `1.0`, true)
testEquality(t, `1.0`, `1.1`, false)
testEquality(t, `true`, `true`, true)
testEquality(t, `true`, `false`, false)
testEquality(t, `"foo"`, `"foo"`, true)
testEquality(t, `"foo"`, `"bar"`, false)
testEquality(t, `'f'`, `'f'`, true)
testEquality(t, `'f'`, `'b'`, false)
testEquality(t, `[]`, `[]`, true)
testEquality(t, `[1]`, `[1]`, true)
testEquality(t, `[1]`, `[1, 2]`, false)
testEquality(t, `["foo", "bar"]`, `["foo", "bar"]`, true)
testEquality(t, `["foo", "bar"]`, `["bar", "foo"]`, false)
testEquality(t, `{}`, `{}`, true)
testEquality(t, `{a: 1, b: 2}`, `{b: 2, a: 1}`, true)
testEquality(t, `{a: 1, b: 2}`, `{b: 2}`, false)
testEquality(t, `{a: 1, b: {}}`, `{b: {}, a: 1}`, true)
testEquality(t, `1`, `"foo"`, false)
testEquality(t, `1`, `true`, false)
testEquality(t, `[1]`, `["1"]`, false)
testEquality(t, `[1, [2]]`, `[1, ["2"]]`, false)
testEquality(t, `{a: 1}`, `{a: "1"}`, false)
testEquality(t, `{a: 1, b: {c: 2}}`, `{a: 1, b: {c: "2"}}`, false)
}
func testEquality(t *testing.T, lhs, rhs string, expected bool) {
// 1. equality is commutative
// 2. equality and inequality must be always opposite
expectRun(t, fmt.Sprintf("out = %s == %s", lhs, rhs), nil, expected)
expectRun(t, fmt.Sprintf("out = %s == %s", rhs, lhs), nil, expected)
expectRun(t, fmt.Sprintf("out = %s != %s", lhs, rhs), nil, !expected)
expectRun(t, fmt.Sprintf("out = %s != %s", rhs, lhs), nil, !expected)
}
func TestVMErrorInfo(t *testing.T) {
expectError(t, `a := 5
a + "boo"`,
nil, "Runtime Error: invalid operation: int + string\n\tat test:2:1")
expectError(t, `a := 5
b := a(5)`,
nil, "Runtime Error: not callable: int\n\tat test:2:6")
expectError(t, `a := 5
b := {}
b.x.y = 10`,
nil, "Runtime Error: not index-assignable: undefined\n\tat test:3:1")
expectError(t, `
a := func() {
b := 5
b += "foo"
}
a()`,
nil, "Runtime Error: invalid operation: int + string\n\tat test:4:2")
expectError(t, `a := 5
a + import("mod1")`, Opts().Module(
"mod1", `export "foo"`,
), ": invalid operation: int + string\n\tat test:2:1")
expectError(t, `a := import("mod1")()`,
Opts().Module(
"mod1", `
export func() {
b := 5
return b + "foo"
}`), "Runtime Error: invalid operation: int + string\n\tat mod1:4:9")
expectError(t, `a := import("mod1")()`,
Opts().Module(
"mod1", `export import("mod2")()`).
Module(
"mod2", `
export func() {
b := 5
return b + "foo"
}`), "Runtime Error: invalid operation: int + string\n\tat mod2:4:9")
}
func TestVMErrorUnwrap(t *testing.T) {
userErr := errors.New("user runtime error")
userFunc := func(err error) *tengo.UserFunction {
return &tengo.UserFunction{Name: "user_func", Value: func(args ...tengo.Object) (tengo.Object, error) {
return nil, err
}}
}
userModule := func(err error) *tengo.BuiltinModule {
return &tengo.BuiltinModule{
Attrs: map[string]tengo.Object{
"afunction": &tengo.UserFunction{
Name: "afunction",
Value: func(a ...tengo.Object) (tengo.Object, error) {
return nil, err
},
},
},
}
}
expectError(t, `user_func()`,
Opts().Symbol("user_func", userFunc(userErr)),
"Runtime Error: "+userErr.Error(),
)
expectErrorIs(t, `user_func()`,
Opts().Symbol("user_func", userFunc(userErr)),
userErr,
)
wrapUserErr := &customError{err: userErr, str: "custom error"}
expectErrorIs(t, `user_func()`,
Opts().Symbol("user_func", userFunc(wrapUserErr)),
wrapUserErr,
)
expectErrorIs(t, `user_func()`,
Opts().Symbol("user_func", userFunc(wrapUserErr)),
userErr,
)
var asErr1 *customError
expectErrorAs(t, `user_func()`,
Opts().Symbol("user_func", userFunc(wrapUserErr)),
&asErr1,
)
require.True(t, asErr1.Error() == wrapUserErr.Error(),
"expected error as:%v, got:%v", wrapUserErr, asErr1)
expectError(t, `import("mod1").afunction()`,
Opts().Module("mod1", userModule(userErr)),
"Runtime Error: "+userErr.Error(),
)
expectErrorIs(t, `import("mod1").afunction()`,
Opts().Module("mod1", userModule(userErr)),
userErr,
)
expectError(t, `import("mod1").afunction()`,
Opts().Module("mod1", userModule(wrapUserErr)),
"Runtime Error: "+wrapUserErr.Error(),
)
expectErrorIs(t, `import("mod1").afunction()`,
Opts().Module("mod1", userModule(wrapUserErr)),
wrapUserErr,
)
expectErrorIs(t, `import("mod1").afunction()`,
Opts().Module("mod1", userModule(wrapUserErr)),
userErr,
)
var asErr2 *customError
expectErrorAs(t, `import("mod1").afunction()`,
Opts().Module("mod1", userModule(wrapUserErr)),
&asErr2,
)
require.True(t, asErr2.Error() == wrapUserErr.Error(),
"expected error as:%v, got:%v", wrapUserErr, asErr2)
}
func TestError(t *testing.T) {
expectRun(t, `out = error(1)`, nil, errorObject(1))
expectRun(t, `out = error(1).value`, nil, 1)
expectRun(t, `out = error("some error")`, nil, errorObject("some error"))
expectRun(t, `out = error("some" + " error")`, nil, errorObject("some error"))
expectRun(t, `out = func() { return error(5) }()`, nil, errorObject(5))
expectRun(t, `out = error(error("foo"))`, nil, errorObject(errorObject("foo")))
expectRun(t, `out = error("some error")`, nil, errorObject("some error"))
expectRun(t, `out = error("some error").value`, nil, "some error")
expectRun(t, `out = error("some error")["value"]`, nil, "some error")
expectError(t, `error("error").err`, nil, "invalid index on error")
expectError(t, `error("error").value_`, nil, "invalid index on error")
expectError(t, `error([1,2,3])[1]`, nil, "invalid index on error")
}
func TestFloat(t *testing.T) {
expectRun(t, `out = 0.0`, nil, 0.0)
expectRun(t, `out = -10.3`, nil, -10.3)
expectRun(t, `out = 3.2 + 2.0 * -4.0`, nil, -4.8)
expectRun(t, `out = 4 + 2.3`, nil, 6.3)
expectRun(t, `out = 2.3 + 4`, nil, 6.3)
expectRun(t, `out = +5.0`, nil, 5.0)
expectRun(t, `out = -5.0 + +5.0`, nil, 0.0)
}
func TestForIn(t *testing.T) {
// array
expectRun(t, `out = 0; for x in [1, 2, 3] { out += x }`,
nil, 6) // value
expectRun(t, `out = 0; for i, x in [1, 2, 3] { out += i + x }`,
nil, 9) // index, value
expectRun(t, `out = 0; func() { for i, x in [1, 2, 3] { out += i + x } }()`,
nil, 9) // index, value
expectRun(t, `out = 0; for i, _ in [1, 2, 3] { out += i }`,
nil, 3) // index, _
expectRun(t, `out = 0; func() { for i, _ in [1, 2, 3] { out += i } }()`,
nil, 3) // index, _
// map
expectRun(t, `out = 0; for v in {a:2,b:3,c:4} { out += v }`,
nil, 9) // value
expectRun(t, `out = ""; for k, v in {a:2,b:3,c:4} { out = k; if v==3 { break } }`,
nil, "b") // key, value
expectRun(t, `out = ""; for k, _ in {a:2} { out += k }`,
nil, "a") // key, _
expectRun(t, `out = 0; for _, v in {a:2,b:3,c:4} { out += v }`,
nil, 9) // _, value
expectRun(t, `out = ""; func() { for k, v in {a:2,b:3,c:4} { out = k; if v==3 { break } } }()`,
nil, "b") // key, value
// string
expectRun(t, `out = ""; for c in "abcde" { out += c }`,
nil, "abcde")
expectRun(t, `out = ""; for i, c in "abcde" { if i == 2 { continue }; out += c }`,
nil, "abde")
}
func TestFor(t *testing.T) {
expectRun(t, `
out = 0
for {
out++
if out == 5 {
break
}
}`, nil, 5)
expectRun(t, `
out = 0
for {
out++
if out == 5 {
break
}
}`, nil, 5)
expectRun(t, `
out = 0
a := 0
for {
a++
if a == 3 { continue }
if a == 5 { break }
out += a
}`, nil, 7) // 1 + 2 + 4
expectRun(t, `
out = 0
a := 0
for {
a++
if a == 3 { continue }
out += a
if a == 5 { break }
}`, nil, 12) // 1 + 2 + 4 + 5
expectRun(t, `
out = 0
for true {
out++
if out == 5 {
break
}
}`, nil, 5)
expectRun(t, `
a := 0
for true {
a++
if a == 5 {
break
}
}
out = a`, nil, 5)
expectRun(t, `
out = 0
a := 0
for true {
a++
if a == 3 { continue }
if a == 5 { break }
out += a
}`, nil, 7) // 1 + 2 + 4
expectRun(t, `
out = 0
a := 0
for true {
a++
if a == 3 { continue }
out += a
if a == 5 { break }
}`, nil, 12) // 1 + 2 + 4 + 5
expectRun(t, `
out = 0
func() {
for true {
out++
if out == 5 {
return
}
}
}()`, nil, 5)
expectRun(t, `
out = 0
for a:=1; a<=10; a++ {
out += a
}`, nil, 55)
expectRun(t, `
out = 0
for a:=1; a<=3; a++ {
for b:=3; b<=6; b++ {
out += b
}
}`, nil, 54)
expectRun(t, `
out = 0
func() {
for {
out++
if out == 5 {
break
}
}
}()`, nil, 5)
expectRun(t, `
out = 0
func() {
for true {
out++
if out == 5 {
break
}
}
}()`, nil, 5)
expectRun(t, `
out = func() {
a := 0
for {
a++
if a == 5 {
break
}
}
return a
}()`, nil, 5)
expectRun(t, `
out = func() {
a := 0
for true {
a++
if a== 5 {
break
}
}
return a
}()`, nil, 5)
expectRun(t, `
out = func() {
a := 0
func() {
for {
a++
if a == 5 {
break
}
}
}()
return a
}()`, nil, 5)
expectRun(t, `
out = func() {
a := 0
func() {
for true {
a++
if a == 5 {
break
}
}
}()
return a
}()`, nil, 5)
expectRun(t, `
out = func() {
sum := 0
for a:=1; a<=10; a++ {
sum += a
}
return sum
}()`, nil, 55)
expectRun(t, `
out = func() {
sum := 0
for a:=1; a<=4; a++ {
for b:=3; b<=5; b++ {
sum += b
}
}
return sum
}()`, nil, 48) // (3+4+5) * 4
expectRun(t, `
a := 1
for ; a<=10; a++ {
if a == 5 {
break
}
}
out = a`, nil, 5)
expectRun(t, `
out = 0
for a:=1; a<=10; a++ {
if a == 3 {
continue
}
out += a
if a == 5 {
break
}
}`, nil, 12) // 1 + 2 + 4 + 5
expectRun(t, `
out = 0
for a:=1; a<=10; {
if a == 3 {
a++
continue
}
out += a
if a == 5 {
break
}
a++
}`, nil, 12) // 1 + 2 + 4 + 5
}
func TestFunction(t *testing.T) {
// function with no "return" statement returns "invalid" value.
expectRun(t, `f1 := func() {}; out = f1();`,
nil, tengo.UndefinedValue)
expectRun(t, `f1 := func() {}; f2 := func() { return f1(); }; f1(); out = f2();`,
nil, tengo.UndefinedValue)
expectRun(t, `f := func(x) { x; }; out = f(5);`,
nil, tengo.UndefinedValue)
expectRun(t, `f := func(...x) { return x; }; out = f(1,2,3);`,
nil, ARR{1, 2, 3})
expectRun(t, `f := func(a, b, ...x) { return [a, b, x]; }; out = f(8,9,1,2,3);`,
nil, ARR{8, 9, ARR{1, 2, 3}})
expectRun(t, `f := func(v) { x := 2; return func(a, ...b){ return [a, b, v+x]}; }; out = f(5)("a", "b");`,
nil, ARR{"a", ARR{"b"}, 7})
expectRun(t, `f := func(...x) { return x; }; out = f();`,
nil, &tengo.Array{Value: []tengo.Object{}})
expectRun(t, `f := func(a, b, ...x) { return [a, b, x]; }; out = f(8, 9);`,
nil, ARR{8, 9, ARR{}})
expectRun(t, `f := func(v) { x := 2; return func(a, ...b){ return [a, b, v+x]}; }; out = f(5)("a");`,
nil, ARR{"a", ARR{}, 7})
expectError(t, `f := func(a, b, ...x) { return [a, b, x]; }; f();`, nil,
"Runtime Error: wrong number of arguments: want>=2, got=0\n\tat test:1:46")
expectError(t, `f := func(a, b, ...x) { return [a, b, x]; }; f(1);`, nil,
"Runtime Error: wrong number of arguments: want>=2, got=1\n\tat test:1:46")
expectRun(t, `f := func(x) { return x; }; out = f(5);`, nil, 5)
expectRun(t, `f := func(x) { return x * 2; }; out = f(5);`, nil, 10)
expectRun(t, `f := func(x, y) { return x + y; }; out = f(5, 5);`, nil, 10)
expectRun(t, `f := func(x, y) { return x + y; }; out = f(5 + 5, f(5, 5));`,
nil, 20)
expectRun(t, `out = func(x) { return x; }(5)`, nil, 5)
expectRun(t, `x := 10; f := func(x) { return x; }; f(5); out = x;`, nil, 10)
expectRun(t, `
f2 := func(a) {
f1 := func(a) {
return a * 2;
};
return f1(a) * 3;
};
out = f2(10);
`, nil, 60)
expectRun(t, `
f1 := func(f) {
a := [undefined]
a[0] = func() { return f(a) }
return a[0]()
}
out = f1(func(a) { return 2 })
`, nil, 2)
// closures
expectRun(t, `
newAdder := func(x) {
return func(y) { return x + y };
};
add2 := newAdder(2);
out = add2(5);
`, nil, 7)
expectRun(t, `
m := {a: 1}
for k,v in m {
func(){
out = k
}()
}
`, nil, "a")
expectRun(t, `
m := {a: 1}
for k,v in m {
func(){
out = v
}()
}
`, nil, 1)
// function as a argument
expectRun(t, `
add := func(a, b) { return a + b };
sub := func(a, b) { return a - b };
applyFunc := func(a, b, f) { return f(a, b) };
out = applyFunc(applyFunc(2, 2, add), 3, sub);
`, nil, 1)
expectRun(t, `f1 := func() { return 5 + 10; }; out = f1();`,
nil, 15)
expectRun(t, `f1 := func() { return 1 }; f2 := func() { return 2 }; out = f1() + f2()`,
nil, 3)
expectRun(t, `f1 := func() { return 1 }; f2 := func() { return f1() + 2 }; f3 := func() { return f2() + 3 }; out = f3()`,
nil, 6)
expectRun(t, `f1 := func() { return 99; 100 }; out = f1();`,
nil, 99)
expectRun(t, `f1 := func() { return 99; return 100 }; out = f1();`,
nil, 99)
expectRun(t, `f1 := func() { return 33; }; f2 := func() { return f1 }; out = f2()();`,
nil, 33)
expectRun(t, `one := func() { one = 1; return one }; out = one()`,
nil, 1)
expectRun(t, `three := func() { one := 1; two := 2; return one + two }; out = three()`,
nil, 3)
expectRun(t, `three := func() { one := 1; two := 2; return one + two }; seven := func() { three := 3; four := 4; return three + four }; out = three() + seven()`,
nil, 10)
expectRun(t, `
foo1 := func() {
foo := 50
return foo
}
foo2 := func() {
foo := 100
return foo
}
out = foo1() + foo2()`, nil, 150)
expectRun(t, `
g := 50;
minusOne := func() {
n := 1;
return g - n;
};
minusTwo := func() {
n := 2;
return g - n;
};
out = minusOne() + minusTwo()
`, nil, 97)
expectRun(t, `
f1 := func() {
f2 := func() { return 1; }
return f2
};
out = f1()()
`, nil, 1)
expectRun(t, `
f1 := func(a) { return a; };
out = f1(4)`, nil, 4)
expectRun(t, `
f1 := func(a, b) { return a + b; };
out = f1(1, 2)`, nil, 3)
expectRun(t, `
sum := func(a, b) {
c := a + b;
return c;
};
out = sum(1, 2);`, nil, 3)
expectRun(t, `
sum := func(a, b) {
c := a + b;
return c;
};
out = sum(1, 2) + sum(3, 4);`, nil, 10)
expectRun(t, `
sum := func(a, b) {
c := a + b
return c
};
outer := func() {
return sum(1, 2) + sum(3, 4)
};
out = outer();`, nil, 10)
expectRun(t, `
g := 10;
sum := func(a, b) {
c := a + b;
return c + g;
}
outer := func() {
return sum(1, 2) + sum(3, 4) + g;
}
out = outer() + g
`, nil, 50)
expectError(t, `func() { return 1; }(1)`,
nil, "wrong number of arguments")
expectError(t, `func(a) { return a; }()`,
nil, "wrong number of arguments")
expectError(t, `func(a, b) { return a + b; }(1)`,
nil, "wrong number of arguments")
expectRun(t, `
f1 := func(a) {
return func() { return a; };
};
f2 := f1(99);
out = f2()
`, nil, 99)
expectRun(t, `
f1 := func(a, b) {
return func(c) { return a + b + c };
};
f2 := f1(1, 2);
out = f2(8);
`, nil, 11)
expectRun(t, `
f1 := func(a, b) {
c := a + b;
return func(d) { return c + d };
};
f2 := f1(1, 2);
out = f2(8);
`, nil, 11)
expectRun(t, `
f1 := func(a, b) {
c := a + b;
return func(d) {
e := d + c;
return func(f) { return e + f };
}
};
f2 := f1(1, 2);
f3 := f2(3);
out = f3(8);
`, nil, 14)
expectRun(t, `
a := 1;
f1 := func(b) {
return func(c) {
return func(d) { return a + b + c + d }
};
};
f2 := f1(2);
f3 := f2(3);
out = f3(8);
`, nil, 14)
expectRun(t, `
f1 := func(a, b) {
one := func() { return a; };
two := func() { return b; };
return func() { return one() + two(); }
};
f2 := f1(9, 90);
out = f2();
`, nil, 99)
// global function recursion
expectRun(t, `
fib := func(x) {
if x == 0 {
return 0
} else if x == 1 {
return 1
} else {
return fib(x-1) + fib(x-2)
}
}
out = fib(15)`, nil, 610)
// local function recursion
expectRun(t, `
out = func() {
sum := func(x) {
return x == 0 ? 0 : x + sum(x-1)
}
return sum(5)
}()`, nil, 15)
expectError(t, `return 5`, nil, "return not allowed outside function")
// closure and block scopes
expectRun(t, `
func() {
a := 10
func() {
b := 5
if true {
out = a + 5
}
}()
}()`, nil, 15)
expectRun(t, `
func() {
a := 10
b := func() { return 5 }
func() {
if b() {
out = a + b()
}
}()
}()`, nil, 15)
expectRun(t, `
func() {
a := 10
func() {
b := func() { return 5 }
func() {
if true {
out = a + b()
}
}()
}()
}()`, nil, 15)
// function skipping return
expectRun(t, `out = func() {}()`,
nil, tengo.UndefinedValue)
expectRun(t, `out = func(v) { if v { return true } }(1)`,
nil, true)
expectRun(t, `out = func(v) { if v { return true } }(0)`,
nil, tengo.UndefinedValue)
expectRun(t, `out = func(v) { if v { } else { return true } }(1)`,
nil, tengo.UndefinedValue)
expectRun(t, `out = func(v) { if v { return } }(1)`,
nil, tengo.UndefinedValue)
expectRun(t, `out = func(v) { if v { return } }(0)`,
nil, tengo.UndefinedValue)
expectRun(t, `out = func(v) { if v { } else { return } }(1)`,
nil, tengo.UndefinedValue)
expectRun(t, `out = func(v) { for ;;v++ { if v == 3 { return true } } }(1)`,
nil, true)
expectRun(t, `out = func(v) { for ;;v++ { if v == 3 { break } } }(1)`,
nil, tengo.UndefinedValue)
// 'f' in RHS at line 4 must reference global variable 'f'
// See https://github.com/d5/tengo/issues/314
expectRun(t, `
f := func() { return 2 }
out = (func() {
f := f()
return f
})()
`, nil, 2)
}
func TestBlocksInGlobalScope(t *testing.T) {
expectRun(t, `
f := undefined
if true {
a := 1
f = func() {
a = 2
}
}
b := 3
f()
out = b`,
nil, 3)
expectRun(t, `
func() {
f := undefined
if true {
a := 10
f = func() {
a = 20
}
}
b := 5
f()
out = b
}()
`,
nil, 5)
expectRun(t, `
f := undefined
if true {
a := 1
b := 2
f = func() {
a = 3
b = 4
}
}
c := 5
d := 6
f()
out = c + d`,
nil, 11)
expectRun(t, `
fn := undefined
if true {
a := 1
b := 2
if true {
c := 3
d := 4
fn = func() {
a = 5
b = 6
c = 7
d = 8
}
}
}
e := 9
f := 10
fn()
out = e + f`,
nil, 19)
expectRun(t, `
out = 0
func() {
for x in [1, 2, 3] {
out += x
}
}()`,
nil, 6)
expectRun(t, `
out = 0
for x in [1, 2, 3] {
out += x
}`,
nil, 6)
}
func TestIf(t *testing.T) {
expectRun(t, `if (true) { out = 10 }`, nil, 10)
expectRun(t, `if (false) { out = 10 }`, nil, tengo.UndefinedValue)
expectRun(t, `if (false) { out = 10 } else { out = 20 }`, nil, 20)
expectRun(t, `if (1) { out = 10 }`, nil, 10)
expectRun(t, `if (0) { out = 10 } else { out = 20 }`, nil, 20)
expectRun(t, `if (1 < 2) { out = 10 }`, nil, 10)
expectRun(t, `if (1 > 2) { out = 10 }`, nil, tengo.UndefinedValue)
expectRun(t, `if (1 < 2) { out = 10 } else { out = 20 }`, nil, 10)
expectRun(t, `if (1 > 2) { out = 10 } else { out = 20 }`, nil, 20)
expectRun(t, `if (1 < 2) { out = 10 } else if (1 > 2) { out = 20 } else { out = 30 }`,
nil, 10)
expectRun(t, `if (1 > 2) { out = 10 } else if (1 < 2) { out = 20 } else { out = 30 }`,
nil, 20)
expectRun(t, `if (1 > 2) { out = 10 } else if (1 == 2) { out = 20 } else { out = 30 }`,
nil, 30)
expectRun(t, `if (1 > 2) { out = 10 } else if (1 == 2) { out = 20 } else if (1 < 2) { out = 30 } else { out = 40 }`,
nil, 30)
expectRun(t, `if (1 > 2) { out = 10 } else if (1 < 2) { out = 20; out = 21; out = 22 } else { out = 30 }`,
nil, 22)
expectRun(t, `if (1 > 2) { out = 10 } else if (1 == 2) { out = 20 } else { out = 30; out = 31; out = 32}`,
nil, 32)
expectRun(t, `if (1 > 2) { out = 10 } else if (1 < 2) { if (1 == 2) { out = 21 } else { out = 22 } } else { out = 30 }`,
nil, 22)
expectRun(t, `if (1 > 2) { out = 10 } else if (1 < 2) { if (1 == 2) { out = 21 } else if (2 == 3) { out = 22 } else { out = 23 } } else { out = 30 }`,
nil, 23)
expectRun(t, `if (1 > 2) { out = 10 } else if (1 == 2) { if (1 == 2) { out = 21 } else if (2 == 3) { out = 22 } else { out = 23 } } else { out = 30 }`,
nil, 30)
expectRun(t, `if (1 > 2) { out = 10 } else if (1 == 2) { out = 20 } else { if (1 == 2) { out = 31 } else if (2 == 3) { out = 32 } else { out = 33 } }`,
nil, 33)
expectRun(t, `if a:=0; a<1 { out = 10 }`, nil, 10)
expectRun(t, `a:=0; if a++; a==1 { out = 10 }`, nil, 10)
expectRun(t, `
func() {
a := 1
if a++; a > 1 {
out = a
}
}()
`, nil, 2)
expectRun(t, `
func() {
a := 1
if a++; a == 1 {
out = 10
} else {
out = 20
}
}()
`, nil, 20)
expectRun(t, `
func() {
a := 1
func() {
if a++; a > 1 {
a++
}
}()
out = a
}()
`, nil, 3)
// expression statement in init (should not leave objects on stack)
expectRun(t, `a := 1; if a; a { out = a }`, nil, 1)
expectRun(t, `a := 1; if a + 4; a { out = a }`, nil, 1)
// dead code elimination
expectRun(t, `
out = func() {
if false { return 1 }
a := undefined
a = 2
if !a {
b := func() {
return is_callable(a) ? a(8) : a
}()
if is_error(b) {
return b
} else if !is_undefined(b) {
return immutable(b)
}
}
a = 3
if a {
b := func() {
return is_callable(a) ? a(9) : a
}()
if is_error(b) {
return b
} else if !is_undefined(b) {
return immutable(b)
}
}
return a
}()
`, nil, 3)
}
func TestImmutable(t *testing.T) {
// primitive types are already immutable values
// immutable expression has no effects.
expectRun(t, `a := immutable(1); out = a`, nil, 1)
expectRun(t, `a := 5; b := immutable(a); out = b`, nil, 5)
expectRun(t, `a := immutable(1); a = 5; out = a`, nil, 5)
// array
expectError(t, `a := immutable([1, 2, 3]); a[1] = 5`,
nil, "not index-assignable")
expectError(t, `a := immutable(["foo", [1,2,3]]); a[1] = "bar"`,
nil, "not index-assignable")
expectRun(t, `a := immutable(["foo", [1,2,3]]); a[1][1] = "bar"; out = a`,
nil, IARR{"foo", ARR{1, "bar", 3}})
expectError(t, `a := immutable(["foo", immutable([1,2,3])]); a[1][1] = "bar"`,
nil, "not index-assignable")
expectError(t, `a := ["foo", immutable([1,2,3])]; a[1][1] = "bar"`,
nil, "not index-assignable")
expectRun(t, `a := immutable([1,2,3]); b := copy(a); b[1] = 5; out = b`,
nil, ARR{1, 5, 3})
expectRun(t, `a := immutable([1,2,3]); b := copy(a); b[1] = 5; out = a`,
nil, IARR{1, 2, 3})
expectRun(t, `out = immutable([1,2,3]) == [1,2,3]`,
nil, true)
expectRun(t, `out = immutable([1,2,3]) == immutable([1,2,3])`,
nil, true)
expectRun(t, `out = [1,2,3] == immutable([1,2,3])`,
nil, true)
expectRun(t, `out = immutable([1,2,3]) == [1,2]`,
nil, false)
expectRun(t, `out = immutable([1,2,3]) == immutable([1,2])`,
nil, false)
expectRun(t, `out = [1,2,3] == immutable([1,2])`,
nil, false)
expectRun(t, `out = immutable([1, 2, 3, 4])[1]`,
nil, 2)
expectRun(t, `out = immutable([1, 2, 3, 4])[1:3]`,
nil, ARR{2, 3})
expectRun(t, `a := immutable([1,2,3]); a = 5; out = a`,
nil, 5)
expectRun(t, `a := immutable([1, 2, 3]); out = a[5]`,
nil, tengo.UndefinedValue)
// map
expectError(t, `a := immutable({b: 1, c: 2}); a.b = 5`,
nil, "not index-assignable")
expectError(t, `a := immutable({b: 1, c: 2}); a["b"] = "bar"`,
nil, "not index-assignable")
expectRun(t, `a := immutable({b: 1, c: [1,2,3]}); a.c[1] = "bar"; out = a`,
nil, IMAP{"b": 1, "c": ARR{1, "bar", 3}})
expectError(t, `a := immutable({b: 1, c: immutable([1,2,3])}); a.c[1] = "bar"`,
nil, "not index-assignable")
expectError(t, `a := {b: 1, c: immutable([1,2,3])}; a.c[1] = "bar"`,
nil, "not index-assignable")
expectRun(t, `out = immutable({a:1,b:2}) == {a:1,b:2}`,
nil, true)
expectRun(t, `out = immutable({a:1,b:2}) == immutable({a:1,b:2})`,
nil, true)
expectRun(t, `out = {a:1,b:2} == immutable({a:1,b:2})`,
nil, true)
expectRun(t, `out = immutable({a:1,b:2}) == {a:1,b:3}`,
nil, false)
expectRun(t, `out = immutable({a:1,b:2}) == immutable({a:1,b:3})`,
nil, false)
expectRun(t, `out = {a:1,b:2} == immutable({a:1,b:3})`,
nil, false)
expectRun(t, `out = immutable({a:1,b:2}).b`,
nil, 2)
expectRun(t, `out = immutable({a:1,b:2})["b"]`,
nil, 2)
expectRun(t, `a := immutable({a:1,b:2}); a = 5; out = 5`,
nil, 5)
expectRun(t, `a := immutable({a:1,b:2}); out = a.c`,
nil, tengo.UndefinedValue)
expectRun(t, `a := immutable({b: 5, c: "foo"}); out = a.b`,
nil, 5)
expectError(t, `a := immutable({b: 5, c: "foo"}); a.b = 10`,
nil, "not index-assignable")
}
func TestIncDec(t *testing.T) {
expectRun(t, `out = 0; out++`, nil, 1)
expectRun(t, `out = 0; out--`, nil, -1)
expectRun(t, `a := 0; a++; out = a`, nil, 1)
expectRun(t, `a := 0; a++; a--; out = a`, nil, 0)
// this seems strange but it works because 'a += b' is
// translated into 'a = a + b' and string type takes other types for + operator.
expectRun(t, `a := "foo"; a++; out = a`, nil, "foo1")
expectError(t, `a := "foo"; a--`, nil, "invalid operation")
expectError(t, `a++`, nil, "unresolved reference") // not declared
expectError(t, `a--`, nil, "unresolved reference") // not declared
expectError(t, `4++`, nil, "unresolved reference")
}
type StringDict struct {
tengo.ObjectImpl
Value map[string]string
}
func (o *StringDict) String() string { return "" }
func (o *StringDict) TypeName() string {
return "string-dict"
}
func (o *StringDict) IndexGet(index tengo.Object) (tengo.Object, error) {
strIdx, ok := index.(*tengo.String)
if !ok {
return nil, tengo.ErrInvalidIndexType
}
for k, v := range o.Value {
if strings.EqualFold(strIdx.Value, k) {
return &tengo.String{Value: v}, nil
}
}
return tengo.UndefinedValue, nil
}
func (o *StringDict) IndexSet(index, value tengo.Object) error {
strIdx, ok := index.(*tengo.String)
if !ok {
return tengo.ErrInvalidIndexType
}
strVal, ok := tengo.ToString(value)
if !ok {
return tengo.ErrInvalidIndexValueType
}
o.Value[strings.ToLower(strIdx.Value)] = strVal
return nil
}
type StringCircle struct {
tengo.ObjectImpl
Value []string
}
func (o *StringCircle) TypeName() string {
return "string-circle"
}
func (o *StringCircle) String() string {
return ""
}
func (o *StringCircle) IndexGet(index tengo.Object) (tengo.Object, error) {
intIdx, ok := index.(*tengo.Int)
if !ok {
return nil, tengo.ErrInvalidIndexType
}
r := int(intIdx.Value) % len(o.Value)
if r < 0 {
r = len(o.Value) + r
}
return &tengo.String{Value: o.Value[r]}, nil
}
func (o *StringCircle) IndexSet(index, value tengo.Object) error {
intIdx, ok := index.(*tengo.Int)
if !ok {
return tengo.ErrInvalidIndexType
}
r := int(intIdx.Value) % len(o.Value)
if r < 0 {
r = len(o.Value) + r
}
strVal, ok := tengo.ToString(value)
if !ok {
return tengo.ErrInvalidIndexValueType
}
o.Value[r] = strVal
return nil
}
type StringArray struct {
tengo.ObjectImpl
Value []string
}
func (o *StringArray) String() string {
return strings.Join(o.Value, ", ")
}
func (o *StringArray) BinaryOp(
op token.Token,
rhs tengo.Object,
) (tengo.Object, error) {
if rhs, ok := rhs.(*StringArray); ok {
switch op {
case token.Add:
if len(rhs.Value) == 0 {
return o, nil
}
return &StringArray{Value: append(o.Value, rhs.Value...)}, nil
}
}
return nil, tengo.ErrInvalidOperator
}
func (o *StringArray) IsFalsy() bool {
return len(o.Value) == 0
}
func (o *StringArray) Equals(x tengo.Object) bool {
if x, ok := x.(*StringArray); ok {
if len(o.Value) != len(x.Value) {
return false
}
for i, v := range o.Value {
if v != x.Value[i] {
return false
}
}
return true
}
return false
}
func (o *StringArray) Copy() tengo.Object {
return &StringArray{
Value: append([]string{}, o.Value...),
}
}
func (o *StringArray) TypeName() string {
return "string-array"
}
func (o *StringArray) IndexGet(index tengo.Object) (tengo.Object, error) {
intIdx, ok := index.(*tengo.Int)
if ok {
if intIdx.Value >= 0 && intIdx.Value < int64(len(o.Value)) {
return &tengo.String{Value: o.Value[intIdx.Value]}, nil
}
return nil, tengo.ErrIndexOutOfBounds
}
strIdx, ok := index.(*tengo.String)
if ok {
for vidx, str := range o.Value {
if strIdx.Value == str {
return &tengo.Int{Value: int64(vidx)}, nil
}
}
return tengo.UndefinedValue, nil
}
return nil, tengo.ErrInvalidIndexType
}
func (o *StringArray) IndexSet(index, value tengo.Object) error {
strVal, ok := tengo.ToString(value)
if !ok {
return tengo.ErrInvalidIndexValueType
}
intIdx, ok := index.(*tengo.Int)
if ok {
if intIdx.Value >= 0 && intIdx.Value < int64(len(o.Value)) {
o.Value[intIdx.Value] = strVal
return nil
}
return tengo.ErrIndexOutOfBounds
}
return tengo.ErrInvalidIndexType
}
func (o *StringArray) Call(
args ...tengo.Object,
) (ret tengo.Object, err error) {
if len(args) != 1 {
return nil, tengo.ErrWrongNumArguments
}
s1, ok := tengo.ToString(args[0])
if !ok {
return nil, tengo.ErrInvalidArgumentType{
Name: "first",
Expected: "string(compatible)",
Found: args[0].TypeName(),
}
}
for i, v := range o.Value {
if v == s1 {
return &tengo.Int{Value: int64(i)}, nil
}
}
return tengo.UndefinedValue, nil
}
func (o *StringArray) CanCall() bool {
return true
}
func TestIndexable(t *testing.T) {
dict := func() *StringDict {
return &StringDict{Value: map[string]string{"a": "foo", "b": "bar"}}
}
expectRun(t, `out = dict["a"]`,
Opts().Symbol("dict", dict()).Skip2ndPass(), "foo")
expectRun(t, `out = dict["B"]`,
Opts().Symbol("dict", dict()).Skip2ndPass(), "bar")
expectRun(t, `out = dict["x"]`,
Opts().Symbol("dict", dict()).Skip2ndPass(), tengo.UndefinedValue)
expectError(t, `dict[0]`,
Opts().Symbol("dict", dict()).Skip2ndPass(), "invalid index type")
strCir := func() *StringCircle {
return &StringCircle{Value: []string{"one", "two", "three"}}
}
expectRun(t, `out = cir[0]`,
Opts().Symbol("cir", strCir()).Skip2ndPass(), "one")
expectRun(t, `out = cir[1]`,
Opts().Symbol("cir", strCir()).Skip2ndPass(), "two")
expectRun(t, `out = cir[-1]`,
Opts().Symbol("cir", strCir()).Skip2ndPass(), "three")
expectRun(t, `out = cir[-2]`,
Opts().Symbol("cir", strCir()).Skip2ndPass(), "two")
expectRun(t, `out = cir[3]`,
Opts().Symbol("cir", strCir()).Skip2ndPass(), "one")
expectError(t, `cir["a"]`,
Opts().Symbol("cir", strCir()).Skip2ndPass(), "invalid index type")
strArr := func() *StringArray {
return &StringArray{Value: []string{"one", "two", "three"}}
}
expectRun(t, `out = arr["one"]`,
Opts().Symbol("arr", strArr()).Skip2ndPass(), 0)
expectRun(t, `out = arr["three"]`,
Opts().Symbol("arr", strArr()).Skip2ndPass(), 2)
expectRun(t, `out = arr["four"]`,
Opts().Symbol("arr", strArr()).Skip2ndPass(), tengo.UndefinedValue)
expectRun(t, `out = arr[0]`,
Opts().Symbol("arr", strArr()).Skip2ndPass(), "one")
expectRun(t, `out = arr[1]`,
Opts().Symbol("arr", strArr()).Skip2ndPass(), "two")
expectError(t, `arr[-1]`,
Opts().Symbol("arr", strArr()).Skip2ndPass(), "index out of bounds")
}
func TestIndexAssignable(t *testing.T) {
dict := func() *StringDict {
return &StringDict{Value: map[string]string{"a": "foo", "b": "bar"}}
}
expectRun(t, `dict["a"] = "1984"; out = dict["a"]`,
Opts().Symbol("dict", dict()).Skip2ndPass(), "1984")
expectRun(t, `dict["c"] = "1984"; out = dict["c"]`,
Opts().Symbol("dict", dict()).Skip2ndPass(), "1984")
expectRun(t, `dict["c"] = 1984; out = dict["C"]`,
Opts().Symbol("dict", dict()).Skip2ndPass(), "1984")
expectError(t, `dict[0] = "1984"`,
Opts().Symbol("dict", dict()).Skip2ndPass(), "invalid index type")
strCir := func() *StringCircle {
return &StringCircle{Value: []string{"one", "two", "three"}}
}
expectRun(t, `cir[0] = "ONE"; out = cir[0]`,
Opts().Symbol("cir", strCir()).Skip2ndPass(), "ONE")
expectRun(t, `cir[1] = "TWO"; out = cir[1]`,
Opts().Symbol("cir", strCir()).Skip2ndPass(), "TWO")
expectRun(t, `cir[-1] = "THREE"; out = cir[2]`,
Opts().Symbol("cir", strCir()).Skip2ndPass(), "THREE")
expectRun(t, `cir[0] = "ONE"; out = cir[3]`,
Opts().Symbol("cir", strCir()).Skip2ndPass(), "ONE")
expectError(t, `cir["a"] = "ONE"`,
Opts().Symbol("cir", strCir()).Skip2ndPass(), "invalid index type")
strArr := func() *StringArray {
return &StringArray{Value: []string{"one", "two", "three"}}
}
expectRun(t, `arr[0] = "ONE"; out = arr[0]`,
Opts().Symbol("arr", strArr()).Skip2ndPass(), "ONE")
expectRun(t, `arr[1] = "TWO"; out = arr[1]`,
Opts().Symbol("arr", strArr()).Skip2ndPass(), "TWO")
expectError(t, `arr["one"] = "ONE"`,
Opts().Symbol("arr", strArr()).Skip2ndPass(), "invalid index type")
}
func TestInteger(t *testing.T) {
expectRun(t, `out = 5`, nil, 5)
expectRun(t, `out = 10`, nil, 10)
expectRun(t, `out = -5`, nil, -5)
expectRun(t, `out = -10`, nil, -10)
expectRun(t, `out = 5 + 5 + 5 + 5 - 10`, nil, 10)
expectRun(t, `out = 2 * 2 * 2 * 2 * 2`, nil, 32)
expectRun(t, `out = -50 + 100 + -50`, nil, 0)
expectRun(t, `out = 5 * 2 + 10`, nil, 20)
expectRun(t, `out = 5 + 2 * 10`, nil, 25)
expectRun(t, `out = 20 + 2 * -10`, nil, 0)
expectRun(t, `out = 50 / 2 * 2 + 10`, nil, 60)
expectRun(t, `out = 2 * (5 + 10)`, nil, 30)
expectRun(t, `out = 3 * 3 * 3 + 10`, nil, 37)
expectRun(t, `out = 3 * (3 * 3) + 10`, nil, 37)
expectRun(t, `out = (5 + 10 * 2 + 15 /3) * 2 + -10`, nil, 50)
expectRun(t, `out = 5 % 3`, nil, 2)
expectRun(t, `out = 5 % 3 + 4`, nil, 6)
expectRun(t, `out = +5`, nil, 5)
expectRun(t, `out = +5 + -5`, nil, 0)
expectRun(t, `out = 9 + '0'`, nil, '9')
expectRun(t, `out = '9' - 5`, nil, '4')
}
type StringArrayIterator struct {
tengo.ObjectImpl
strArr *StringArray
idx int
}
func (i *StringArrayIterator) TypeName() string {
return "string-array-iterator"
}
func (i *StringArrayIterator) String() string {
return ""
}
func (i *StringArrayIterator) Next() bool {
i.idx++
return i.idx <= len(i.strArr.Value)
}
func (i *StringArrayIterator) Key() tengo.Object {
return &tengo.Int{Value: int64(i.idx - 1)}
}
func (i *StringArrayIterator) Value() tengo.Object {
return &tengo.String{Value: i.strArr.Value[i.idx-1]}
}
func (o *StringArray) Iterate() tengo.Iterator {
return &StringArrayIterator{
strArr: o,
}
}
func (o *StringArray) CanIterate() bool {
return true
}
func TestIterable(t *testing.T) {
strArr := func() *StringArray {
return &StringArray{Value: []string{"one", "two", "three"}}
}
expectRun(t, `for i, s in arr { out += i }`,
Opts().Symbol("arr", strArr()).Skip2ndPass(), 3)
expectRun(t, `for i, s in arr { out += s }`,
Opts().Symbol("arr", strArr()).Skip2ndPass(), "onetwothree")
expectRun(t, `for i, s in arr { out += s + i }`,
Opts().Symbol("arr", strArr()).Skip2ndPass(), "one0two1three2")
}
func TestLogical(t *testing.T) {
expectRun(t, `out = true && true`, nil, true)
expectRun(t, `out = true && false`, nil, false)
expectRun(t, `out = false && true`, nil, false)
expectRun(t, `out = false && false`, nil, false)
expectRun(t, `out = !true && true`, nil, false)
expectRun(t, `out = !true && false`, nil, false)
expectRun(t, `out = !false && true`, nil, true)
expectRun(t, `out = !false && false`, nil, false)
expectRun(t, `out = true || true`, nil, true)
expectRun(t, `out = true || false`, nil, true)
expectRun(t, `out = false || true`, nil, true)
expectRun(t, `out = false || false`, nil, false)
expectRun(t, `out = !true || true`, nil, true)
expectRun(t, `out = !true || false`, nil, false)
expectRun(t, `out = !false || true`, nil, true)
expectRun(t, `out = !false || false`, nil, true)
expectRun(t, `out = 1 && 2`, nil, 2)
expectRun(t, `out = 1 || 2`, nil, 1)
expectRun(t, `out = 1 && 0`, nil, 0)
expectRun(t, `out = 1 || 0`, nil, 1)
expectRun(t, `out = 1 && (0 || 2)`, nil, 2)
expectRun(t, `out = 0 || (0 || 2)`, nil, 2)
expectRun(t, `out = 0 || (0 && 2)`, nil, 0)
expectRun(t, `out = 0 || (2 && 0)`, nil, 0)
expectRun(t, `t:=func() {out = 3; return true}; f:=func() {out = 7; return false}; t() && f()`,
nil, 7)
expectRun(t, `t:=func() {out = 3; return true}; f:=func() {out = 7; return false}; f() && t()`,
nil, 7)
expectRun(t, `t:=func() {out = 3; return true}; f:=func() {out = 7; return false}; f() || t()`,
nil, 3)
expectRun(t, `t:=func() {out = 3; return true}; f:=func() {out = 7; return false}; t() || f()`,
nil, 3)
expectRun(t, `t:=func() {out = 3; return true}; f:=func() {out = 7; return false}; !t() && f()`,
nil, 3)
expectRun(t, `t:=func() {out = 3; return true}; f:=func() {out = 7; return false}; !f() && t()`,
nil, 3)
expectRun(t, `t:=func() {out = 3; return true}; f:=func() {out = 7; return false}; !f() || t()`,
nil, 7)
expectRun(t, `t:=func() {out = 3; return true}; f:=func() {out = 7; return false}; !t() || f()`,
nil, 7)
}
func TestMap(t *testing.T) {
expectRun(t, `
out = {
one: 10 - 9,
two: 1 + 1,
three: 6 / 2
}`, nil, MAP{
"one": 1,
"two": 2,
"three": 3,
})
expectRun(t, `
out = {
"one": 10 - 9,
"two": 1 + 1,
"three": 6 / 2
}`, nil, MAP{
"one": 1,
"two": 2,
"three": 3,
})
expectRun(t, `out = {foo: 5}["foo"]`, nil, 5)
expectRun(t, `out = {foo: 5}["bar"]`, nil, tengo.UndefinedValue)
expectRun(t, `key := "foo"; out = {foo: 5}[key]`, nil, 5)
expectRun(t, `out = {}["foo"]`, nil, tengo.UndefinedValue)
expectRun(t, `
m := {
foo: func(x) {
return x * 2
}
}
out = m["foo"](2) + m["foo"](3)
`, nil, 10)
// map assignment is copy-by-reference
expectRun(t, `m1 := {k1: 1, k2: "foo"}; m2 := m1; m1.k1 = 5; out = m2.k1`,
nil, 5)
expectRun(t, `m1 := {k1: 1, k2: "foo"}; m2 := m1; m2.k1 = 3; out = m1.k1`,
nil, 3)
expectRun(t, `func() { m1 := {k1: 1, k2: "foo"}; m2 := m1; m1.k1 = 5; out = m2.k1 }()`,
nil, 5)
expectRun(t, `func() { m1 := {k1: 1, k2: "foo"}; m2 := m1; m2.k1 = 3; out = m1.k1 }()`,
nil, 3)
}
func TestBuiltin(t *testing.T) {
m := Opts().Module("math",
&tengo.BuiltinModule{
Attrs: map[string]tengo.Object{
"abs": &tengo.UserFunction{
Name: "abs",
Value: func(a ...tengo.Object) (tengo.Object, error) {
v, _ := tengo.ToFloat64(a[0])
return &tengo.Float{Value: math.Abs(v)}, nil
},
},
},
})
// builtin
expectRun(t, `math := import("math"); out = math.abs(1)`, m, 1.0)
expectRun(t, `math := import("math"); out = math.abs(-1)`, m, 1.0)
expectRun(t, `math := import("math"); out = math.abs(1.0)`, m, 1.0)
expectRun(t, `math := import("math"); out = math.abs(-1.0)`, m, 1.0)
}
func TestUserModules(t *testing.T) {
// export none
expectRun(t, `out = import("mod1")`,
Opts().Module("mod1", `fn := func() { return 5.0 }; a := 2`),
tengo.UndefinedValue)
// export values
expectRun(t, `out = import("mod1")`,
Opts().Module("mod1", `export 5`), 5)
expectRun(t, `out = import("mod1")`,
Opts().Module("mod1", `export "foo"`), "foo")
// export compound types
expectRun(t, `out = import("mod1")`,
Opts().Module("mod1", `export [1, 2, 3]`), IARR{1, 2, 3})
expectRun(t, `out = import("mod1")`,
Opts().Module("mod1", `export {a: 1, b: 2}`), IMAP{"a": 1, "b": 2})
// export value is immutable
expectError(t, `m1 := import("mod1"); m1.a = 5`,
Opts().Module("mod1", `export {a: 1, b: 2}`), "not index-assignable")
expectError(t, `m1 := import("mod1"); m1[1] = 5`,
Opts().Module("mod1", `export [1, 2, 3]`), "not index-assignable")
// code after export statement will not be executed
expectRun(t, `out = import("mod1")`,
Opts().Module("mod1", `a := 10; export a; a = 20`), 10)
expectRun(t, `out = import("mod1")`,
Opts().Module("mod1", `a := 10; export a; a = 20; export a`), 10)
// export function
expectRun(t, `out = import("mod1")()`,
Opts().Module("mod1", `export func() { return 5.0 }`), 5.0)
// export function that reads module-global variable
expectRun(t, `out = import("mod1")()`,
Opts().Module("mod1", `a := 1.5; export func() { return a + 5.0 }`), 6.5)
// export function that read local variable
expectRun(t, `out = import("mod1")()`,
Opts().Module("mod1", `export func() { a := 1.5; return a + 5.0 }`), 6.5)
// export function that read free variables
expectRun(t, `out = import("mod1")()`,
Opts().Module("mod1", `export func() { a := 1.5; return func() { return a + 5.0 }() }`), 6.5)
// recursive function in module
expectRun(t, `out = import("mod1")`,
Opts().Module(
"mod1", `
a := func(x) {
return x == 0 ? 0 : x + a(x-1)
}
export a(5)
`), 15)
expectRun(t, `out = import("mod1")`,
Opts().Module(
"mod1", `
export func() {
a := func(x) {
return x == 0 ? 0 : x + a(x-1)
}
return a(5)
}()
`), 15)
// (main) -> mod1 -> mod2
expectRun(t, `out = import("mod1")()`,
Opts().Module("mod1", `export import("mod2")`).
Module("mod2", `export func() { return 5.0 }`),
5.0)
// (main) -> mod1 -> mod2
// -> mod2
expectRun(t, `import("mod1"); out = import("mod2")()`,
Opts().Module("mod1", `export import("mod2")`).
Module("mod2", `export func() { return 5.0 }`),
5.0)
// (main) -> mod1 -> mod2 -> mod3
// -> mod2 -> mod3
expectRun(t, `import("mod1"); out = import("mod2")()`,
Opts().Module("mod1", `export import("mod2")`).
Module("mod2", `export import("mod3")`).
Module("mod3", `export func() { return 5.0 }`),
5.0)
// cyclic imports
// (main) -> mod1 -> mod2 -> mod1
expectError(t, `import("mod1")`,
Opts().Module("mod1", `import("mod2")`).
Module("mod2", `import("mod1")`),
"Compile Error: cyclic module import: mod1\n\tat mod2:1:1")
// (main) -> mod1 -> mod2 -> mod3 -> mod1
expectError(t, `import("mod1")`,
Opts().Module("mod1", `import("mod2")`).
Module("mod2", `import("mod3")`).
Module("mod3", `import("mod1")`),
"Compile Error: cyclic module import: mod1\n\tat mod3:1:1")
// (main) -> mod1 -> mod2 -> mod3 -> mod2
expectError(t, `import("mod1")`,
Opts().Module("mod1", `import("mod2")`).
Module("mod2", `import("mod3")`).
Module("mod3", `import("mod2")`),
"Compile Error: cyclic module import: mod2\n\tat mod3:1:1")
// unknown modules
expectError(t, `import("mod0")`,
Opts().Module("mod1", `a := 5`), "module 'mod0' not found")
expectError(t, `import("mod1")`,
Opts().Module("mod1", `import("mod2")`), "module 'mod2' not found")
// module is immutable but its variables is not necessarily immutable.
expectRun(t, `m1 := import("mod1"); m1.a.b = 5; out = m1.a.b`,
Opts().Module("mod1", `export {a: {b: 3}}`),
5)
// make sure module has same builtin functions
expectRun(t, `out = import("mod1")`,
Opts().Module("mod1", `export func() { return type_name(0) }()`),
"int")
// 'export' statement is ignored outside module
expectRun(t, `a := 5; export func() { a = 10 }(); out = a`,
Opts().Skip2ndPass(), 5)
// 'export' must be in the top-level
expectError(t, `import("mod1")`,
Opts().Module("mod1", `func() { export 5 }()`),
"Compile Error: export not allowed inside function\n\tat mod1:1:10")
expectError(t, `import("mod1")`,
Opts().Module("mod1", `func() { func() { export 5 }() }()`),
"Compile Error: export not allowed inside function\n\tat mod1:1:19")
// module cannot access outer scope
expectError(t, `a := 5; import("mod1")`,
Opts().Module("mod1", `export a`),
"Compile Error: unresolved reference 'a'\n\tat mod1:1:8")
// runtime error within modules
expectError(t, `
a := 1;
b := import("mod1");
b(a)`,
Opts().Module("mod1", `
export func(a) {
a()
}
`), "Runtime Error: not callable: int\n\tat mod1:3:4\n\tat test:4:1")
// module skipping export
expectRun(t, `out = import("mod0")`,
Opts().Module("mod0", ``), tengo.UndefinedValue)
expectRun(t, `out = import("mod0")`,
Opts().Module("mod0", `if 1 { export true }`), true)
expectRun(t, `out = import("mod0")`,
Opts().Module("mod0", `if 0 { export true }`),
tengo.UndefinedValue)
expectRun(t, `out = import("mod0")`,
Opts().Module("mod0", `if 1 { } else { export true }`),
tengo.UndefinedValue)
expectRun(t, `out = import("mod0")`,
Opts().Module("mod0", `for v:=0;;v++ { if v == 3 { export true } } }`),
true)
expectRun(t, `out = import("mod0")`,
Opts().Module("mod0", `for v:=0;;v++ { if v == 3 { break } } }`),
tengo.UndefinedValue)
// duplicate compiled functions
// NOTE: module "mod" has a function with some local variable, and it's
// imported twice by the main script. That causes the same CompiledFunction
// put in constants twice and the Bytecode optimization (removing duplicate
// constants) should still work correctly.
expectRun(t, `
m1 := import("mod")
m2 := import("mod")
out = m1.x
`,
Opts().Module("mod", `
f1 := func(a, b) {
c := a + b + 1
return a + b + 1
}
export { x: 1 }
`),
1)
}
func TestModuleBlockScopes(t *testing.T) {
m := Opts().Module("rand",
&tengo.BuiltinModule{
Attrs: map[string]tengo.Object{
"intn": &tengo.UserFunction{
Name: "abs",
Value: func(a ...tengo.Object) (tengo.Object, error) {
v, _ := tengo.ToInt64(a[0])
return &tengo.Int{Value: rand.Int63n(v)}, nil
},
},
},
})
// block scopes in module
expectRun(t, `out = import("mod1")()`, m.Module(
"mod1", `
rand := import("rand")
foo := func() { return 1 }
export func() {
rand.intn(3)
return foo()
}`), 1)
expectRun(t, `out = import("mod1")()`, m.Module(
"mod1", `
rand := import("rand")
foo := func() { return 1 }
export func() {
rand.intn(3)
if foo() {}
return 10
}
`), 10)
expectRun(t, `out = import("mod1")()`, m.Module(
"mod1", `
rand := import("rand")
foo := func() { return 1 }
export func() {
rand.intn(3)
if true { foo() }
return 10
}
`), 10)
}
func TestBangOperator(t *testing.T) {
expectRun(t, `out = !true`, nil, false)
expectRun(t, `out = !false`, nil, true)
expectRun(t, `out = !0`, nil, true)
expectRun(t, `out = !5`, nil, false)
expectRun(t, `out = !!true`, nil, true)
expectRun(t, `out = !!false`, nil, false)
expectRun(t, `out = !!5`, nil, true)
}
func TestObjectsLimit(t *testing.T) {
testAllocsLimit(t, `5`, 0)
testAllocsLimit(t, `5 + 5`, 1)
testAllocsLimit(t, `a := [1, 2, 3]`, 1)
testAllocsLimit(t, `a := 1; b := 2; c := 3; d := [a, b, c]`, 1)
testAllocsLimit(t, `a := {foo: 1, bar: 2}`, 1)
testAllocsLimit(t, `a := 1; b := 2; c := {foo: a, bar: b}`, 1)
testAllocsLimit(t, `
f := func() {
return 5 + 5
}
a := f() + 5
`, 2)
testAllocsLimit(t, `
f := func() {
return 5 + 5
}
a := f()
`, 1)
testAllocsLimit(t, `
a := []
f := func() {
a = append(a, 5)
}
f()
f()
f()
`, 4)
}
func testAllocsLimit(t *testing.T, src string, limit int64) {
expectRun(t, src,
Opts().Skip2ndPass(), tengo.UndefinedValue) // no limit
expectRun(t, src,
Opts().MaxAllocs(limit).Skip2ndPass(), tengo.UndefinedValue)
expectRun(t, src,
Opts().MaxAllocs(limit+1).Skip2ndPass(), tengo.UndefinedValue)
if limit > 1 {
expectError(t, src,
Opts().MaxAllocs(limit-1).Skip2ndPass(),
"allocation limit exceeded")
}
if limit > 2 {
expectError(t, src,
Opts().MaxAllocs(limit-2).Skip2ndPass(),
"allocation limit exceeded")
}
}
func TestReturn(t *testing.T) {
expectRun(t, `out = func() { return 10; }()`, nil, 10)
expectRun(t, `out = func() { return 10; return 9; }()`, nil, 10)
expectRun(t, `out = func() { return 2 * 5; return 9 }()`, nil, 10)
expectRun(t, `out = func() { 9; return 2 * 5; return 9 }()`, nil, 10)
expectRun(t, `
out = func() {
if (10 > 1) {
if (10 > 1) {
return 10;
}
return 1;
}
}()`, nil, 10)
expectRun(t, `f1 := func() { return 2 * 5; }; out = f1()`, nil, 10)
}
func TestVMScopes(t *testing.T) {
// shadowed global variable
expectRun(t, `
c := 5
if a := 3; a {
c := 6
} else {
c := 7
}
out = c
`, nil, 5)
// shadowed local variable
expectRun(t, `
func() {
c := 5
if a := 3; a {
c := 6
} else {
c := 7
}
out = c
}()
`, nil, 5)
// 'b' is declared in 2 separate blocks
expectRun(t, `
c := 5
if a := 3; a {
b := 8
c = b
} else {
b := 9
c = b
}
out = c
`, nil, 8)
// shadowing inside for statement
expectRun(t, `
a := 4
b := 5
for i:=0;i<3;i++ {
b := 6
for j:=0;j<2;j++ {
b := 7
a = i*j
}
}
out = a`, nil, 2)
// shadowing variable declared in init statement
expectRun(t, `
if a := 5; a {
a := 6
out = a
}`, nil, 6)
expectRun(t, `
a := 4
if a := 5; a {
a := 6
out = a
}`, nil, 6)
expectRun(t, `
a := 4
if a := 0; a {
a := 6
out = a
} else {
a := 7
out = a
}`, nil, 7)
expectRun(t, `
a := 4
if a := 0; a {
out = a
} else {
out = a
}`, nil, 0)
// shadowing function level
expectRun(t, `
a := 5
func() {
a := 6
a = 7
}()
out = a
`, nil, 5)
expectRun(t, `
a := 5
func() {
if a := 7; true {
a = 8
}
}()
out = a
`, nil, 5)
}
func TestSelector(t *testing.T) {
expectRun(t, `a := {k1: 5, k2: "foo"}; out = a.k1`,
nil, 5)
expectRun(t, `a := {k1: 5, k2: "foo"}; out = a.k2`,
nil, "foo")
expectRun(t, `a := {k1: 5, k2: "foo"}; out = a.k3`,
nil, tengo.UndefinedValue)
expectRun(t, `
a := {
b: {
c: 4,
a: false
},
c: "foo bar"
}
out = a.b.c`, nil, 4)
expectRun(t, `
a := {
b: {
c: 4,
a: false
},
c: "foo bar"
}
b := a.x.c`, nil, tengo.UndefinedValue)
expectRun(t, `
a := {
b: {
c: 4,
a: false
},
c: "foo bar"
}
b := a.x.y`, nil, tengo.UndefinedValue)
expectRun(t, `a := {b: 1, c: "foo"}; a.b = 2; out = a.b`,
nil, 2)
expectRun(t, `a := {b: 1, c: "foo"}; a.c = 2; out = a.c`,
nil, 2) // type not checked on sub-field
expectRun(t, `a := {b: {c: 1}}; a.b.c = 2; out = a.b.c`,
nil, 2)
expectRun(t, `a := {b: 1}; a.c = 2; out = a`,
nil, MAP{"b": 1, "c": 2})
expectRun(t, `a := {b: {c: 1}}; a.b.d = 2; out = a`,
nil, MAP{"b": MAP{"c": 1, "d": 2}})
expectRun(t, `func() { a := {b: 1, c: "foo"}; a.b = 2; out = a.b }()`,
nil, 2)
expectRun(t, `func() { a := {b: 1, c: "foo"}; a.c = 2; out = a.c }()`,
nil, 2) // type not checked on sub-field
expectRun(t, `func() { a := {b: {c: 1}}; a.b.c = 2; out = a.b.c }()`,
nil, 2)
expectRun(t, `func() { a := {b: 1}; a.c = 2; out = a }()`,
nil, MAP{"b": 1, "c": 2})
expectRun(t, `func() { a := {b: {c: 1}}; a.b.d = 2; out = a }()`,
nil, MAP{"b": MAP{"c": 1, "d": 2}})
expectRun(t, `func() { a := {b: 1, c: "foo"}; func() { a.b = 2 }(); out = a.b }()`,
nil, 2)
expectRun(t, `func() { a := {b: 1, c: "foo"}; func() { a.c = 2 }(); out = a.c }()`,
nil, 2) // type not checked on sub-field
expectRun(t, `func() { a := {b: {c: 1}}; func() { a.b.c = 2 }(); out = a.b.c }()`,
nil, 2)
expectRun(t, `func() { a := {b: 1}; func() { a.c = 2 }(); out = a }()`,
nil, MAP{"b": 1, "c": 2})
expectRun(t, `func() { a := {b: {c: 1}}; func() { a.b.d = 2 }(); out = a }()`,
nil, MAP{"b": MAP{"c": 1, "d": 2}})
expectRun(t, `
a := {
b: [1, 2, 3],
c: {
d: 8,
e: "foo",
f: [9, 8]
}
}
out = [a.b[2], a.c.d, a.c.e, a.c.f[1]]
`, nil, ARR{3, 8, "foo", 8})
expectRun(t, `
func() {
a := [1, 2, 3]
b := 9
a[1] = b
b = 7 // make sure a[1] has a COPY of value of 'b'
out = a[1]
}()
`, nil, 9)
expectError(t, `a := {b: {c: 1}}; a.d.c = 2`,
nil, "not index-assignable")
expectError(t, `a := [1, 2, 3]; a.b = 2`,
nil, "invalid index type")
expectError(t, `a := "foo"; a.b = 2`,
nil, "not index-assignable")
expectError(t, `func() { a := {b: {c: 1}}; a.d.c = 2 }()`,
nil, "not index-assignable")
expectError(t, `func() { a := [1, 2, 3]; a.b = 2 }()`,
nil, "invalid index type")
expectError(t, `func() { a := "foo"; a.b = 2 }()`,
nil, "not index-assignable")
}
func TestSourceModules(t *testing.T) {
testEnumModule(t, `out = enum.key(0, 20)`, 0)
testEnumModule(t, `out = enum.key(10, 20)`, 10)
testEnumModule(t, `out = enum.value(0, 0)`, 0)
testEnumModule(t, `out = enum.value(10, 20)`, 20)
testEnumModule(t, `out = enum.all([], enum.value)`, true)
testEnumModule(t, `out = enum.all([1], enum.value)`, true)
testEnumModule(t, `out = enum.all([true, 1], enum.value)`, true)
testEnumModule(t, `out = enum.all([true, 0], enum.value)`, false)
testEnumModule(t, `out = enum.all([true, 0, 1], enum.value)`, false)
testEnumModule(t, `out = enum.all(immutable([true, 0, 1]), enum.value)`,
false) // immutable-array
testEnumModule(t, `out = enum.all({}, enum.value)`, true)
testEnumModule(t, `out = enum.all({a:1}, enum.value)`, true)
testEnumModule(t, `out = enum.all({a:true, b:1}, enum.value)`, true)
testEnumModule(t, `out = enum.all(immutable({a:true, b:1}), enum.value)`,
true) // immutable-map
testEnumModule(t, `out = enum.all({a:true, b:0}, enum.value)`, false)
testEnumModule(t, `out = enum.all({a:true, b:0, c:1}, enum.value)`, false)
testEnumModule(t, `out = enum.all(0, enum.value)`,
tengo.UndefinedValue) // non-enumerable: undefined
testEnumModule(t, `out = enum.all("123", enum.value)`,
tengo.UndefinedValue) // non-enumerable: undefined
testEnumModule(t, `out = enum.any([], enum.value)`, false)
testEnumModule(t, `out = enum.any([1], enum.value)`, true)
testEnumModule(t, `out = enum.any([true, 1], enum.value)`, true)
testEnumModule(t, `out = enum.any([true, 0], enum.value)`, true)
testEnumModule(t, `out = enum.any([true, 0, 1], enum.value)`, true)
testEnumModule(t, `out = enum.any(immutable([true, 0, 1]), enum.value)`,
true) // immutable-array
testEnumModule(t, `out = enum.any([false], enum.value)`, false)
testEnumModule(t, `out = enum.any([false, 0], enum.value)`, false)
testEnumModule(t, `out = enum.any({}, enum.value)`, false)
testEnumModule(t, `out = enum.any({a:1}, enum.value)`, true)
testEnumModule(t, `out = enum.any({a:true, b:1}, enum.value)`, true)
testEnumModule(t, `out = enum.any({a:true, b:0}, enum.value)`, true)
testEnumModule(t, `out = enum.any({a:true, b:0, c:1}, enum.value)`, true)
testEnumModule(t, `out = enum.any(immutable({a:true, b:0, c:1}), enum.value)`,
true) // immutable-map
testEnumModule(t, `out = enum.any({a:false}, enum.value)`, false)
testEnumModule(t, `out = enum.any({a:false, b:0}, enum.value)`, false)
testEnumModule(t, `out = enum.any(0, enum.value)`,
tengo.UndefinedValue) // non-enumerable: undefined
testEnumModule(t, `out = enum.any("123", enum.value)`,
tengo.UndefinedValue) // non-enumerable: undefined
testEnumModule(t, `out = enum.chunk([], 1)`, ARR{})
testEnumModule(t, `out = enum.chunk([1], 1)`, ARR{ARR{1}})
testEnumModule(t, `out = enum.chunk([1,2,3], 1)`,
ARR{ARR{1}, ARR{2}, ARR{3}})
testEnumModule(t, `out = enum.chunk([1,2,3], 2)`,
ARR{ARR{1, 2}, ARR{3}})
testEnumModule(t, `out = enum.chunk([1,2,3], 3)`,
ARR{ARR{1, 2, 3}})
testEnumModule(t, `out = enum.chunk([1,2,3], 4)`,
ARR{ARR{1, 2, 3}})
testEnumModule(t, `out = enum.chunk([1,2,3,4], 3)`,
ARR{ARR{1, 2, 3}, ARR{4}})
testEnumModule(t, `out = enum.chunk([], 0)`,
tengo.UndefinedValue) // size=0: undefined
testEnumModule(t, `out = enum.chunk([1], 0)`,
tengo.UndefinedValue) // size=0: undefined
testEnumModule(t, `out = enum.chunk([1,2,3], 0)`,
tengo.UndefinedValue) // size=0: undefined
testEnumModule(t, `out = enum.chunk({a:1,b:2,c:3}, 1)`,
tengo.UndefinedValue) // map: undefined
testEnumModule(t, `out = enum.chunk(0, 1)`,
tengo.UndefinedValue) // non-enumerable: undefined
testEnumModule(t, `out = enum.chunk("123", 1)`,
tengo.UndefinedValue) // non-enumerable: undefined
testEnumModule(t, `out = enum.at([], 0)`,
tengo.UndefinedValue)
testEnumModule(t, `out = enum.at([], 1)`,
tengo.UndefinedValue)
testEnumModule(t, `out = enum.at([], -1)`,
tengo.UndefinedValue)
testEnumModule(t, `out = enum.at(["one"], 0)`,
"one")
testEnumModule(t, `out = enum.at(["one"], 1)`,
tengo.UndefinedValue)
testEnumModule(t, `out = enum.at(["one"], -1)`,
tengo.UndefinedValue)
testEnumModule(t, `out = enum.at(["one","two","three"], 0)`,
"one")
testEnumModule(t, `out = enum.at(["one","two","three"], 1)`,
"two")
testEnumModule(t, `out = enum.at(["one","two","three"], 2)`,
"three")
testEnumModule(t, `out = enum.at(["one","two","three"], -1)`,
tengo.UndefinedValue)
testEnumModule(t, `out = enum.at(["one","two","three"], 3)`,
tengo.UndefinedValue)
testEnumModule(t, `out = enum.at(["one","two","three"], "1")`,
tengo.UndefinedValue) // non-int index: undefined
testEnumModule(t, `out = enum.at({}, "a")`,
tengo.UndefinedValue)
testEnumModule(t, `out = enum.at({a:"one"}, "a")`,
"one")
testEnumModule(t, `out = enum.at({a:"one"}, "b")`,
tengo.UndefinedValue)
testEnumModule(t, `out = enum.at({a:"one",b:"two",c:"three"}, "a")`,
"one")
testEnumModule(t, `out = enum.at({a:"one",b:"two",c:"three"}, "b")`,
"two")
testEnumModule(t, `out = enum.at({a:"one",b:"two",c:"three"}, "c")`,
"three")
testEnumModule(t, `out = enum.at({a:"one",b:"two",c:"three"}, "d")`,
tengo.UndefinedValue)
testEnumModule(t, `out = enum.at({a:"one",b:"two",c:"three"}, 'a')`,
tengo.UndefinedValue) // non-string index: undefined
testEnumModule(t, `out = enum.at(0, 1)`,
tengo.UndefinedValue) // non-enumerable: undefined
testEnumModule(t, `out = enum.at("abc", 1)`,
tengo.UndefinedValue) // non-enumerable: undefined
testEnumModule(t, `out=0; enum.each([],func(k,v){out+=v})`, 0)
testEnumModule(t, `out=0; enum.each([1,2,3],func(k,v){out+=v})`, 6)
testEnumModule(t, `out=0; enum.each([1,2,3],func(k,v){out+=k})`, 3)
testEnumModule(t, `out=0; enum.each({a:1,b:2,c:3},func(k,v){out+=v})`, 6)
testEnumModule(t, `out=""; enum.each({a:1,b:2,c:3},func(k,v){out+=k}); out=len(out)`,
3)
testEnumModule(t, `out=0; enum.each(5,func(k,v){out+=v})`, 0) // non-enumerable: no iteration
testEnumModule(t, `out=0; enum.each("123",func(k,v){out+=v})`, 0) // non-enumerable: no iteration
testEnumModule(t, `out = enum.filter([], enum.value)`,
ARR{})
testEnumModule(t, `out = enum.filter([false,1,2], enum.value)`,
ARR{1, 2})
testEnumModule(t, `out = enum.filter([false,1,0,2], enum.value)`,
ARR{1, 2})
testEnumModule(t, `out = enum.filter({}, enum.value)`,
tengo.UndefinedValue) // non-array: undefined
testEnumModule(t, `out = enum.filter(0, enum.value)`,
tengo.UndefinedValue) // non-array: undefined
testEnumModule(t, `out = enum.filter("123", enum.value)`,
tengo.UndefinedValue) // non-array: undefined
testEnumModule(t, `out = enum.find([], enum.value)`,
tengo.UndefinedValue)
testEnumModule(t, `out = enum.find([0], enum.value)`,
tengo.UndefinedValue)
testEnumModule(t, `out = enum.find([1], enum.value)`, 1)
testEnumModule(t, `out = enum.find([false,0,undefined,1], enum.value)`, 1)
testEnumModule(t, `out = enum.find([1,2,3], enum.value)`, 1)
testEnumModule(t, `out = enum.find({}, enum.value)`,
tengo.UndefinedValue)
testEnumModule(t, `out = enum.find({a:0}, enum.value)`,
tengo.UndefinedValue)
testEnumModule(t, `out = enum.find({a:1}, enum.value)`, 1)
testEnumModule(t, `out = enum.find({a:false,b:0,c:undefined,d:1}, enum.value)`,
1)
//testEnumModule(t, `out = enum.find({a:1,b:2,c:3}, enum.value)`, 1)
testEnumModule(t, `out = enum.find(0, enum.value)`,
tengo.UndefinedValue) // non-enumerable: undefined
testEnumModule(t, `out = enum.find("123", enum.value)`,
tengo.UndefinedValue) // non-enumerable: undefined
testEnumModule(t, `out = enum.find_key([], enum.value)`,
tengo.UndefinedValue)
testEnumModule(t, `out = enum.find_key([0], enum.value)`,
tengo.UndefinedValue)
testEnumModule(t, `out = enum.find_key([1], enum.value)`, 0)
testEnumModule(t, `out = enum.find_key([false,0,undefined,1], enum.value)`,
3)
testEnumModule(t, `out = enum.find_key([1,2,3], enum.value)`, 0)
testEnumModule(t, `out = enum.find_key({}, enum.value)`,
tengo.UndefinedValue)
testEnumModule(t, `out = enum.find_key({a:0}, enum.value)`,
tengo.UndefinedValue)
testEnumModule(t, `out = enum.find_key({a:1}, enum.value)`,
"a")
testEnumModule(t, `out = enum.find_key({a:false,b:0,c:undefined,d:1}, enum.value)`,
"d")
//testEnumModule(t, `out = enum.find_key({a:1,b:2,c:3}, enum.value)`, "a")
testEnumModule(t, `out = enum.find_key(0, enum.value)`,
tengo.UndefinedValue) // non-enumerable: undefined
testEnumModule(t, `out = enum.find_key("123", enum.value)`,
tengo.UndefinedValue) // non-enumerable: undefined
testEnumModule(t, `out = enum.map([], enum.value)`,
ARR{})
testEnumModule(t, `out = enum.map([1,2,3], enum.value)`,
ARR{1, 2, 3})
testEnumModule(t, `out = enum.map([1,2,3], enum.key)`,
ARR{0, 1, 2})
testEnumModule(t, `out = enum.map([1,2,3], func(k,v) { return v*2 })`,
ARR{2, 4, 6})
testEnumModule(t, `out = enum.map({}, enum.value)`,
ARR{})
testEnumModule(t, `out = enum.map({a:1}, func(k,v) { return v*2 })`,
ARR{2})
testEnumModule(t, `out = enum.map(0, enum.value)`,
tengo.UndefinedValue) // non-enumerable: undefined
testEnumModule(t, `out = enum.map("123", enum.value)`,
tengo.UndefinedValue) // non-enumerable: undefined
}
func testEnumModule(t *testing.T, input string, expected interface{}) {
expectRun(t, `enum := import("enum"); `+input,
Opts().Module("enum", stdlib.SourceModules["enum"]),
expected)
}
func TestSrcModEnum(t *testing.T) {
expectRun(t, `
x := import("enum")
out = x.all([1, 2, 3], func(_, v) { return v >= 1 })
`, Opts().Stdlib(), true)
expectRun(t, `
x := import("enum")
out = x.all([1, 2, 3], func(_, v) { return v >= 2 })
`, Opts().Stdlib(), false)
expectRun(t, `
x := import("enum")
out = x.any([1, 2, 3], func(_, v) { return v >= 1 })
`, Opts().Stdlib(), true)
expectRun(t, `
x := import("enum")
out = x.any([1, 2, 3], func(_, v) { return v >= 2 })
`, Opts().Stdlib(), true)
expectRun(t, `
x := import("enum")
out = x.chunk([1, 2, 3], 1)
`, Opts().Stdlib(), ARR{ARR{1}, ARR{2}, ARR{3}})
expectRun(t, `
x := import("enum")
out = x.chunk([1, 2, 3], 2)
`, Opts().Stdlib(), ARR{ARR{1, 2}, ARR{3}})
expectRun(t, `
x := import("enum")
out = x.chunk([1, 2, 3], 3)
`, Opts().Stdlib(), ARR{ARR{1, 2, 3}})
expectRun(t, `
x := import("enum")
out = x.chunk([1, 2, 3], 4)
`, Opts().Stdlib(), ARR{ARR{1, 2, 3}})
expectRun(t, `
x := import("enum")
out = x.chunk([1, 2, 3, 4, 5, 6], 2)
`, Opts().Stdlib(), ARR{ARR{1, 2}, ARR{3, 4}, ARR{5, 6}})
expectRun(t, `
x := import("enum")
out = x.at([1, 2, 3], 0)
`, Opts().Stdlib(), 1)
}
func TestVMStackOverflow(t *testing.T) {
expectError(t, `f := func() { return f() + 1 }; f()`,
nil, "stack overflow")
}
func TestString(t *testing.T) {
expectRun(t, `out = "Hello World!"`, nil, "Hello World!")
expectRun(t, `out = "Hello" + " " + "World!"`, nil, "Hello World!")
expectRun(t, `out = "Hello" == "Hello"`, nil, true)
expectRun(t, `out = "Hello" == "World"`, nil, false)
expectRun(t, `out = "Hello" != "Hello"`, nil, false)
expectRun(t, `out = "Hello" != "World"`, nil, true)
expectRun(t, `out = "Hello" > "World"`, nil, false)
expectRun(t, `out = "World" < "Hello"`, nil, false)
expectRun(t, `out = "Hello" < "World"`, nil, true)
expectRun(t, `out = "World" > "Hello"`, nil, true)
expectRun(t, `out = "Hello" >= "World"`, nil, false)
expectRun(t, `out = "Hello" <= "World"`, nil, true)
expectRun(t, `out = "Hello" >= "Hello"`, nil, true)
expectRun(t, `out = "World" <= "World"`, nil, true)
// index operator
str := "abcdef"
strStr := `"abcdef"`
strLen := 6
for idx := 0; idx < strLen; idx++ {
expectRun(t, fmt.Sprintf("out = %s[%d]", strStr, idx),
nil, str[idx])
expectRun(t, fmt.Sprintf("out = %s[0 + %d]", strStr, idx),
nil, str[idx])
expectRun(t, fmt.Sprintf("out = %s[1 + %d - 1]", strStr, idx),
nil, str[idx])
expectRun(t, fmt.Sprintf("idx := %d; out = %s[idx]", idx, strStr),
nil, str[idx])
}
expectRun(t, fmt.Sprintf("%s[%d]", strStr, -1),
nil, tengo.UndefinedValue)
expectRun(t, fmt.Sprintf("%s[%d]", strStr, strLen),
nil, tengo.UndefinedValue)
// slice operator
for low := 0; low <= strLen; low++ {
expectRun(t, fmt.Sprintf("out = %s[%d:%d]", strStr, low, low),
nil, "")
for high := low; high <= strLen; high++ {
expectRun(t, fmt.Sprintf("out = %s[%d:%d]", strStr, low, high),
nil, str[low:high])
expectRun(t,
fmt.Sprintf("out = %s[0 + %d : 0 + %d]", strStr, low, high),
nil, str[low:high])
expectRun(t,
fmt.Sprintf("out = %s[1 + %d - 1 : 1 + %d - 1]",
strStr, low, high),
nil, str[low:high])
expectRun(t,
fmt.Sprintf("out = %s[:%d]", strStr, high),
nil, str[:high])
expectRun(t,
fmt.Sprintf("out = %s[%d:]", strStr, low),
nil, str[low:])
}
}
expectRun(t, fmt.Sprintf("out = %s[:]", strStr),
nil, str[:])
expectRun(t, fmt.Sprintf("out = %s[:]", strStr),
nil, str)
expectRun(t, fmt.Sprintf("out = %s[%d:]", strStr, -1),
nil, str)
expectRun(t, fmt.Sprintf("out = %s[:%d]", strStr, strLen+1),
nil, str)
expectRun(t, fmt.Sprintf("out = %s[%d:%d]", strStr, 2, 2),
nil, "")
expectError(t, fmt.Sprintf("%s[:%d]", strStr, -1),
nil, "invalid slice index")
expectError(t, fmt.Sprintf("%s[%d:]", strStr, strLen+1),
nil, "invalid slice index")
expectError(t, fmt.Sprintf("%s[%d:%d]", strStr, 0, -1),
nil, "invalid slice index")
expectError(t, fmt.Sprintf("%s[%d:%d]", strStr, 2, 1),
nil, "invalid slice index")
// string concatenation with other types
expectRun(t, `out = "foo" + 1`, nil, "foo1")
// Float.String() returns the smallest number of digits
// necessary such that ParseFloat will return f exactly.
expectRun(t, `out = "foo" + 1.0`, nil, "foo1") // <- note '1' instead of '1.0'
expectRun(t, `out = "foo" + 1.5`, nil, "foo1.5")
expectRun(t, `out = "foo" + true`, nil, "footrue")
expectRun(t, `out = "foo" + 'X'`, nil, "fooX")
expectRun(t, `out = "foo" + error(5)`, nil, "fooerror: 5")
expectRun(t, `out = "foo" + undefined`, nil, "foo<undefined>")
expectRun(t, `out = "foo" + [1,2,3]`, nil, "foo[1, 2, 3]")
// also works with "+=" operator
expectRun(t, `out = "foo"; out += 1.5`, nil, "foo1.5")
// string concats works only when string is LHS
expectError(t, `1 + "foo"`, nil, "invalid operation")
expectError(t, `"foo" - "bar"`, nil, "invalid operation")
}
func TestTailCall(t *testing.T) {
expectRun(t, `
fac := func(n, a) {
if n == 1 {
return a
}
return fac(n-1, n*a)
}
out = fac(5, 1)`, nil, 120)
expectRun(t, `
fac := func(n, a) {
if n == 1 {
return a
}
x := {foo: fac} // indirection for test
return x.foo(n-1, n*a)
}
out = fac(5, 1)`, nil, 120)
expectRun(t, `
fib := func(x, s) {
if x == 0 {
return 0 + s
} else if x == 1 {
return 1 + s
}
return fib(x-1, fib(x-2, s))
}
out = fib(15, 0)`, nil, 610)
expectRun(t, `
fib := func(n, a, b) {
if n == 0 {
return a
} else if n == 1 {
return b
}
return fib(n-1, b, a + b)
}
out = fib(15, 0, 1)`, nil, 610)
// global variable and no return value
expectRun(t, `
out = 0
foo := func(a) {
if a == 0 {
return
}
out += a
foo(a-1)
}
foo(10)`, nil, 55)
expectRun(t, `
f1 := func() {
f2 := 0 // TODO: this might be fixed in the future
f2 = func(n, s) {
if n == 0 { return s }
return f2(n-1, n + s)
}
return f2(5, 0)
}
out = f1()`, nil, 15)
// tail-call replacing loop
// without tail-call optimization, this code will cause stack overflow
expectRun(t, `
iter := func(n, max) {
if n == max {
return n
}
return iter(n+1, max)
}
out = iter(0, 9999)
`, nil, 9999)
expectRun(t, `
c := 0
iter := func(n, max) {
if n == max {
return
}
c++
iter(n+1, max)
}
iter(0, 9999)
out = c
`, nil, 9999)
}
// tail call with free vars
func TestTailCallFreeVars(t *testing.T) {
expectRun(t, `
func() {
a := 10
f2 := 0
f2 = func(n, s) {
if n == 0 {
return s + a
}
return f2(n-1, n+s)
}
out = f2(5, 0)
}()`, nil, 25)
}
func TestSpread(t *testing.T) {
expectRun(t, `
f := func(...a) {
return append(a, 3)
}
out = f([1, 2]...)
`, nil, ARR{1, 2, 3})
expectRun(t, `
f := func(a, ...b) {
return append([a], append(b, 3)...)
}
out = f([1, 2]...)
`, nil, ARR{1, 2, 3})
expectRun(t, `
f := func(a, ...b) {
return append(append([a], b), 3)
}
out = f(1, [2]...)
`, nil, ARR{1, ARR{2}, 3})
expectRun(t, `
f1 := func(...a){
return append([3], a...)
}
f2 := func(a, ...b) {
return f1(append([a], b...)...)
}
out = f2([1, 2]...)
`, nil, ARR{3, 1, 2})
expectRun(t, `
f := func(a, ...b) {
return func(...a) {
return append([3], append(a, 4)...)
}(a, b...)
}
out = f([1, 2]...)
`, nil, ARR{3, 1, 2, 4})
expectRun(t, `
f := func(a, ...b) {
c := append(b, 4)
return func(){
return append(append([a], b...), c...)
}()
}
out = f(1, immutable([2, 3])...)
`, nil, ARR{1, 2, 3, 2, 3, 4})
expectError(t, `func(a) {}([1, 2]...)`, nil,
"Runtime Error: wrong number of arguments: want=1, got=2")
expectError(t, `func(a, b, c) {}([1, 2]...)`, nil,
"Runtime Error: wrong number of arguments: want=3, got=2")
}
func expectRun(
t *testing.T,
input string,
opts *testopts,
expected interface{},
) {
if opts == nil {
opts = Opts()
}
symbols := opts.symbols
modules := opts.modules
maxAllocs := opts.maxAllocs
expectedObj := toObject(expected)
if symbols == nil {
symbols = make(map[string]tengo.Object)
}
symbols[testOut] = objectZeroCopy(expectedObj)
// first pass: run the code normally
{
// parse
file := parse(t, input)
if file == nil {
return
}
// compiler/VM
res, trace, err := traceCompileRun(file, symbols, modules, maxAllocs)
require.NoError(t, err, "\n"+strings.Join(trace, "\n"))
require.Equal(t, expectedObj, res[testOut],
"\n"+strings.Join(trace, "\n"))
}
// second pass: run the code as import module
if !opts.skip2ndPass {
file := parse(t, `out = import("__code__")`)
if file == nil {
return
}
expectedObj := toObject(expected)
switch eo := expectedObj.(type) {
case *tengo.Array:
expectedObj = &tengo.ImmutableArray{Value: eo.Value}
case *tengo.Map:
expectedObj = &tengo.ImmutableMap{Value: eo.Value}
}
modules.AddSourceModule("__code__",
[]byte(fmt.Sprintf("out := undefined; %s; export out", input)))
res, trace, err := traceCompileRun(file, symbols, modules, maxAllocs)
require.NoError(t, err, "\n"+strings.Join(trace, "\n"))
require.Equal(t, expectedObj, res[testOut],
"\n"+strings.Join(trace, "\n"))
}
}
func expectError(
t *testing.T,
input string,
opts *testopts,
expected string,
) {
if opts == nil {
opts = Opts()
}
symbols := opts.symbols
modules := opts.modules
maxAllocs := opts.maxAllocs
expected = strings.TrimSpace(expected)
if expected == "" {
panic("expected must not be empty")
}
// parse
program := parse(t, input)
if program == nil {
return
}
// compiler/VM
_, trace, err := traceCompileRun(program, symbols, modules, maxAllocs)
require.Error(t, err, "\n"+strings.Join(trace, "\n"))
require.True(t, strings.Contains(err.Error(), expected),
"expected error string: %s, got: %s\n%s",
expected, err.Error(), strings.Join(trace, "\n"))
}
func expectErrorIs(
t *testing.T,
input string,
opts *testopts,
expected error,
) {
if opts == nil {
opts = Opts()
}
symbols := opts.symbols
modules := opts.modules
maxAllocs := opts.maxAllocs
// parse
program := parse(t, input)
if program == nil {
return
}
// compiler/VM
_, trace, err := traceCompileRun(program, symbols, modules, maxAllocs)
require.Error(t, err, "\n"+strings.Join(trace, "\n"))
require.True(t, errors.Is(err, expected),
"expected error is: %s, got: %s\n%s",
expected.Error(), err.Error(), strings.Join(trace, "\n"))
}
func expectErrorAs(
t *testing.T,
input string,
opts *testopts,
expected interface{},
) {
if opts == nil {
opts = Opts()
}
symbols := opts.symbols
modules := opts.modules
maxAllocs := opts.maxAllocs
// parse
program := parse(t, input)
if program == nil {
return
}
// compiler/VM
_, trace, err := traceCompileRun(program, symbols, modules, maxAllocs)
require.Error(t, err, "\n"+strings.Join(trace, "\n"))
require.True(t, errors.As(err, expected),
"expected error as: %v, got: %v\n%s",
expected, err, strings.Join(trace, "\n"))
}
type vmTracer struct {
Out []string
}
func (o *vmTracer) Write(p []byte) (n int, err error) {
o.Out = append(o.Out, string(p))
return len(p), nil
}
func traceCompileRun(
file *parser.File,
symbols map[string]tengo.Object,
modules *tengo.ModuleMap,
maxAllocs int64,
) (res map[string]tengo.Object, trace []string, err error) {
var v *tengo.VM
defer func() {
if e := recover(); e != nil {
err = fmt.Errorf("panic: %v", e)
// stack trace
var stackTrace []string
for i := 2; ; i += 1 {
_, file, line, ok := _runtime.Caller(i)
if !ok {
break
}
stackTrace = append(stackTrace,
fmt.Sprintf(" %s:%d", file, line))
}
trace = append(trace,
fmt.Sprintf("[Error Trace]\n\n %s\n",
strings.Join(stackTrace, "\n ")))
}
}()
globals := make([]tengo.Object, tengo.GlobalsSize)
symTable := tengo.NewSymbolTable()
for name, value := range symbols {
sym := symTable.Define(name)
// should not store pointer to 'value' variable
// which is re-used in each iteration.
valueCopy := value
globals[sym.Index] = valueCopy
}
for idx, fn := range tengo.GetAllBuiltinFunctions() {
symTable.DefineBuiltin(idx, fn.Name)
}
tr := &vmTracer{}
c := tengo.NewCompiler(file.InputFile, symTable, nil, modules, tr)
err = c.Compile(file)
trace = append(trace,
fmt.Sprintf("\n[Compiler Trace]\n\n%s",
strings.Join(tr.Out, "")))
if err != nil {
return
}
bytecode := c.Bytecode()
bytecode.RemoveDuplicates()
trace = append(trace, fmt.Sprintf("\n[Compiled Constants]\n\n%s",
strings.Join(bytecode.FormatConstants(), "\n")))
trace = append(trace, fmt.Sprintf("\n[Compiled Instructions]\n\n%s\n",
strings.Join(bytecode.FormatInstructions(), "\n")))
v = tengo.NewVM(bytecode, globals, maxAllocs)
err = v.Run()
{
res = make(map[string]tengo.Object)
for name := range symbols {
sym, depth, ok := symTable.Resolve(name, false)
if !ok || depth != 0 {
err = fmt.Errorf("symbol not found: %s", name)
return
}
res[name] = globals[sym.Index]
}
trace = append(trace, fmt.Sprintf("\n[Globals]\n\n%s",
strings.Join(formatGlobals(globals), "\n")))
}
if err == nil && !v.IsStackEmpty() {
err = errors.New("non empty stack after execution")
}
return
}
func formatGlobals(globals []tengo.Object) (formatted []string) {
for idx, global := range globals {
if global == nil {
return
}
formatted = append(formatted, fmt.Sprintf("[% 3d] %s (%s|%p)",
idx, global.String(), reflect.TypeOf(global).Elem().Name(), global))
}
return
}
func parse(t *testing.T, input string) *parser.File {
testFileSet := parser.NewFileSet()
testFile := testFileSet.AddFile("test", -1, len(input))
p := parser.NewParser(testFile, []byte(input), nil)
file, err := p.ParseFile()
require.NoError(t, err)
return file
}
func errorObject(v interface{}) *tengo.Error {
return &tengo.Error{Value: toObject(v)}
}
func toObject(v interface{}) tengo.Object {
switch v := v.(type) {
case tengo.Object:
return v
case string:
return &tengo.String{Value: v}
case int64:
return &tengo.Int{Value: v}
case int: // for convenience
return &tengo.Int{Value: int64(v)}
case bool:
if v {
return tengo.TrueValue
}
return tengo.FalseValue
case rune:
return &tengo.Char{Value: v}
case byte: // for convenience
return &tengo.Char{Value: rune(v)}
case float64:
return &tengo.Float{Value: v}
case []byte:
return &tengo.Bytes{Value: v}
case MAP:
objs := make(map[string]tengo.Object)
for k, v := range v {
objs[k] = toObject(v)
}
return &tengo.Map{Value: objs}
case ARR:
var objs []tengo.Object
for _, e := range v {
objs = append(objs, toObject(e))
}
return &tengo.Array{Value: objs}
case IMAP:
objs := make(map[string]tengo.Object)
for k, v := range v {
objs[k] = toObject(v)
}
return &tengo.ImmutableMap{Value: objs}
case IARR:
var objs []tengo.Object
for _, e := range v {
objs = append(objs, toObject(e))
}
return &tengo.ImmutableArray{Value: objs}
}
panic(fmt.Errorf("unknown type: %T", v))
}
func objectZeroCopy(o tengo.Object) tengo.Object {
switch o.(type) {
case *tengo.Int:
return &tengo.Int{}
case *tengo.Float:
return &tengo.Float{}
case *tengo.Bool:
return &tengo.Bool{}
case *tengo.Char:
return &tengo.Char{}
case *tengo.String:
return &tengo.String{}
case *tengo.Array:
return &tengo.Array{}
case *tengo.Map:
return &tengo.Map{}
case *tengo.Undefined:
return tengo.UndefinedValue
case *tengo.Error:
return &tengo.Error{}
case *tengo.Bytes:
return &tengo.Bytes{}
case *tengo.ImmutableArray:
return &tengo.ImmutableArray{}
case *tengo.ImmutableMap:
return &tengo.ImmutableMap{}
case nil:
panic("nil")
default:
panic(fmt.Errorf("unknown object type: %s", o.TypeName()))
}
}
Reference in a new issue View git blame Copy permalink