mirror of
https://github.com/robertkrimen/otto
synced 2025-10-12 20:27:30 +08:00
1fe0007dcb
* add benchmarks and tests for native function calls * improve conversion of various native function parameters * add support for more types of native function parameters * improve performance of most parameter types
1367 lines
23 KiB
Go
1367 lines
23 KiB
Go
package otto
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
func BenchmarkNativeCallWithString(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 string) {})
|
|
s, _ := vm.Compile("test.js", `x("zzz")`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithFloat32(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 float32) {})
|
|
s, _ := vm.Compile("test.js", `x(1.1)`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithFloat64(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 float64) {})
|
|
s, _ := vm.Compile("test.js", `x(1.1)`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithInt(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 int) {})
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithUint(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 uint) {})
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithInt8(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 int8) {})
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithUint8(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 uint8) {})
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithInt16(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 int16) {})
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithUint16(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 uint16) {})
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithInt32(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 int32) {})
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithUint32(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 uint32) {})
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithInt64(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 int64) {})
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithUint64(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 uint64) {})
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithStringInt(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 string, a2 int) {})
|
|
s, _ := vm.Compile("test.js", `x("zzz", 1)`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithIntVariadic0(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a ...int) {})
|
|
s, _ := vm.Compile("test.js", `x()`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithIntVariadic1(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a ...int) {})
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithIntVariadic3(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a ...int) {})
|
|
s, _ := vm.Compile("test.js", `x(1, 2, 3)`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithIntVariadic10(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a ...int) {})
|
|
s, _ := vm.Compile("test.js", `x(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithIntArray0(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a []int) {})
|
|
s, _ := vm.Compile("test.js", `x([])`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithIntArray1(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a []int) {})
|
|
s, _ := vm.Compile("test.js", `x([1])`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithIntArray3(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a []int) {})
|
|
s, _ := vm.Compile("test.js", `x([1, 2, 3])`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithIntArray10(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a []int) {})
|
|
s, _ := vm.Compile("test.js", `x([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithIntVariadicArray0(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a ...int) {})
|
|
s, _ := vm.Compile("test.js", `x([])`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithIntVariadicArray1(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a ...int) {})
|
|
s, _ := vm.Compile("test.js", `x([1])`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithIntVariadicArray3(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a ...int) {})
|
|
s, _ := vm.Compile("test.js", `x([1, 2, 3])`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithIntVariadicArray10(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a ...int) {})
|
|
s, _ := vm.Compile("test.js", `x([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithStringIntVariadic0(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 string, a2 ...int) {})
|
|
s, _ := vm.Compile("test.js", `x("a")`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithStringIntVariadic1(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 string, a2 ...int) {})
|
|
s, _ := vm.Compile("test.js", `x("a", 1)`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithStringIntVariadic3(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 string, a2 ...int) {})
|
|
s, _ := vm.Compile("test.js", `x("a", 1, 2, 3)`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithStringIntVariadic10(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 string, a2 ...int) {})
|
|
s, _ := vm.Compile("test.js", `x("a", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithStringIntVariadicArray0(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 string, a2 ...int) {})
|
|
s, _ := vm.Compile("test.js", `x("a", [])`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithStringIntVariadicArray1(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 string, a2 ...int) {})
|
|
s, _ := vm.Compile("test.js", `x("a", [1])`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithStringIntVariadicArray3(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 string, a2 ...int) {})
|
|
s, _ := vm.Compile("test.js", `x("a", [1, 2, 3])`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithStringIntVariadicArray10(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a1 string, a2 ...int) {})
|
|
s, _ := vm.Compile("test.js", `x("a", [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithMap(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a map[string]string) {})
|
|
s, _ := vm.Compile("test.js", `x({a: "b", c: "d"})`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithMapVariadic(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a ...map[string]string) {})
|
|
s, _ := vm.Compile("test.js", `x({a: "b", c: "d"}, {w: "x", y: "z"})`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithMapVariadicArray(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a ...map[string]string) {})
|
|
s, _ := vm.Compile("test.js", `x([{a: "b", c: "d"}, {w: "x", y: "z"}])`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithFunction(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a func()) {})
|
|
s, _ := vm.Compile("test.js", `x(function() {})`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithFunctionInt(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a func(int)) {})
|
|
s, _ := vm.Compile("test.js", `x(function(n) {})`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkNativeCallWithFunctionString(b *testing.B) {
|
|
vm := New()
|
|
vm.Set("x", func(a func(string)) {})
|
|
s, _ := vm.Compile("test.js", `x(function(n) {})`)
|
|
for i := 0; i < b.N; i++ {
|
|
vm.Run(s)
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithString(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 string) {
|
|
if a1 != "zzz" {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x("zzz")`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithFloat32(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 float32) {
|
|
if a1 != 1.1 {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x(1.1)`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithFloat64(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 float64) {
|
|
if a1 != 1.1 {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x(1.1)`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithInt(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 int) {
|
|
if a1 != 1 {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithUint(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 uint) {
|
|
if a1 != 1 {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithInt8(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 int8) {
|
|
if a1 != 1 {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithUint8(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 uint8) {
|
|
if a1 != 1 {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithInt16(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 int16) {
|
|
if a1 != 1 {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithUint16(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 uint16) {
|
|
if a1 != 1 {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithInt32(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 int32) {
|
|
if a1 != 1 {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithUint32(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 uint32) {
|
|
if a1 != 1 {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithInt64(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 int64) {
|
|
if a1 != 1 {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithUint64(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 uint64) {
|
|
if a1 != 1 {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithStringInt(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 string, a2 int) {
|
|
if a1 != "zzz" || a2 != 1 {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x("zzz", 1)`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithIntVariadic0(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a ...int) {
|
|
if !reflect.DeepEqual(a, []int{}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x()`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithIntVariadic1(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a ...int) {
|
|
if !reflect.DeepEqual(a, []int{1}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x(1)`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithIntVariadic3(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a ...int) {
|
|
if !reflect.DeepEqual(a, []int{1, 2, 3}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x(1, 2, 3)`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithIntVariadic10(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a ...int) {
|
|
if !reflect.DeepEqual(a, []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithIntArray0(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a []int) {
|
|
if !reflect.DeepEqual(a, []int{}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x([])`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithIntArray1(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a []int) {
|
|
if !reflect.DeepEqual(a, []int{1}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x([1])`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithIntArray3(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a []int) {
|
|
if !reflect.DeepEqual(a, []int{1, 2, 3}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x([1, 2, 3])`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithIntArray10(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a []int) {
|
|
if !reflect.DeepEqual(a, []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithIntVariadicArray0(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a ...int) {
|
|
if !reflect.DeepEqual(a, []int{}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x([])`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithIntVariadicArray1(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a ...int) {
|
|
if !reflect.DeepEqual(a, []int{1}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x([1])`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithIntVariadicArray3(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a ...int) {
|
|
if !reflect.DeepEqual(a, []int{1, 2, 3}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x([1, 2, 3])`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithIntVariadicArray10(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a ...int) {
|
|
if !reflect.DeepEqual(a, []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithStringIntVariadic0(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 string, a2 ...int) {
|
|
if a1 != "a" || !reflect.DeepEqual(a2, []int{}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x("a")`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithStringIntVariadic1(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 string, a2 ...int) {
|
|
if a1 != "a" || !reflect.DeepEqual(a2, []int{1}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x("a", 1)`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithStringIntVariadic3(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 string, a2 ...int) {
|
|
if a1 != "a" || !reflect.DeepEqual(a2, []int{1, 2, 3}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x("a", 1, 2, 3)`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithStringIntVariadic10(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 string, a2 ...int) {
|
|
if a1 != "a" || !reflect.DeepEqual(a2, []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x("a", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithStringIntVariadicArray0(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 string, a2 ...int) {
|
|
if a1 != "a" || !reflect.DeepEqual(a2, []int{}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x("a", [])`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithStringIntVariadicArray1(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 string, a2 ...int) {
|
|
if a1 != "a" || !reflect.DeepEqual(a2, []int{1}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x("a", [1])`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithStringIntVariadicArray3(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 string, a2 ...int) {
|
|
if a1 != "a" || !reflect.DeepEqual(a2, []int{1, 2, 3}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x("a", [1, 2, 3])`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithStringIntVariadicArray10(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a1 string, a2 ...int) {
|
|
if a1 != "a" || !reflect.DeepEqual(a2, []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x("a", [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithMap(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a map[string]string) {
|
|
if !reflect.DeepEqual(a, map[string]string{"a": "b", "c": "d"}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x({a: "b", c: "d"})`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithMapVariadic(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a ...map[string]string) {
|
|
if !reflect.DeepEqual(a, []map[string]string{{"a": "b", "c": "d"}, {"w": "x", "y": "z"}}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x({a: "b", c: "d"}, {w: "x", y: "z"})`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithMapVariadicArray(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(a ...map[string]string) {
|
|
if !reflect.DeepEqual(a, []map[string]string{{"a": "b", "c": "d"}, {"w": "x", "y": "z"}}) {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x([{a: "b", c: "d"}, {w: "x", y: "z"}])`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithFunctionVoidBool(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(fn func() bool) {
|
|
if !fn() {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x(function() { return true; })`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithFunctionIntInt(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(fn func(int) int) {
|
|
if fn(5) != 5 {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x(function(n) { return n; })`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestNativeCallWithFunctionStringString(t *testing.T) {
|
|
vm := New()
|
|
|
|
called := false
|
|
|
|
vm.Set("x", func(fn func(string) string) {
|
|
if fn("zzz") != "zzz" {
|
|
t.Fail()
|
|
}
|
|
|
|
called = true
|
|
})
|
|
|
|
s, _ := vm.Compile("test.js", `x(function(n) { return n; })`)
|
|
|
|
if _, err := vm.Run(s); err != nil {
|
|
t.Logf("err should have been nil; was %s\n", err.Error())
|
|
t.Fail()
|
|
}
|
|
|
|
if !called {
|
|
t.Fail()
|
|
}
|
|
}
|