runtime_test.go

package gates

import (
	"context"
	"io/ioutil"
	"strings"
	"testing"

	"github.com/stretchr/testify/assert"
)

type panicErr struct {
	message string
}

func (p *panicErr) Error() string {
	if p.message != "" {
		return p.message
	}
	return "assertion failed"
}

func mustRunStringWithGlobal(s string, global map[string]Value) Value {
	r := New()
	for k, v := range global {
		r.Global().Set(k, v)
	}
	value, err := r.RunString(s)
	if err != nil {
		panic(err)
	}
	return value
}

func mustRunString(s string) Value {
	return mustRunStringWithGlobal(s, nil)
}

func assertValue(t *testing.T, expected, actual Value) {
	if !expected.SameAs(actual) {
		t.Errorf("%#v != %#v", actual, expected)
	}
}

func TestRunString(t *testing.T) {
	assertValue(t, Int(34), mustRunString("4 + 5 * 6"))
	assertValue(t, Float(0.5), mustRunString("1 / 2"))
	assertValue(t, String("he he"), mustRunString(`"he\x20" + "he"`))
	assertValue(t, Float(1.5), mustRunString(`0 && true || 1.5`))
	assertValue(t, True, mustRunString(`!(0 && true)`))
	assertValue(t, True, mustRunString(`1 == "1"`))
	assertValue(t, True, mustRunString(`"hehe" != ("1" == true)`))
	assertValue(t, True, mustRunString("1.1 >= 1"))
	assertValue(t, True, mustRunString(`"abc" > "aba"`))
	assertValue(t, String("hehe"), mustRunString(`null + "hehe"`))

	assertValue(t, Int(42), mustRunStringWithGlobal(`a.b["c"]`, map[string]Value{
		"a": ref(getterFunc(func(r *Runtime, v Value) Value {
			return Map(map[string]Value{
				"c": Int(42),
			})
		})),
	}))

	assertValue(t, Int(42), mustRunStringWithGlobal(`a[1*2]`, map[string]Value{
		"a": NewArray([]Value{Int(40), Int(41), Int(42)}),
	}))

	assertValue(t, Int(4), mustRunString(`("he" + "he").length`))
	assertValue(t, String("e"), mustRunString(`"hehe"[1]`))
	assertValue(t, Null, mustRunString(`"hehe"[-1]`))
	assertValue(t, Null, mustRunString(`"hehe"[4]`))

	assertValue(t, Float(3), mustRunStringWithGlobal(`add(1, 2)`, map[string]Value{
		"add": FunctionFunc(func(fc FunctionCall) Value {
			var result float64
			for _, arg := range fc.Args() {
				result += arg.ToFloat()
			}
			return Float(result)
		}),
	}))

	assertValue(t, True, mustRunString(`[] == []`))
	assertValue(t, True, mustRunString(`[1] == [1]`))
	assertValue(t, False, mustRunString(`[1] == [1, 2]`))
	assertValue(t, True, mustRunString(`{} == {}`))
	assertValue(t, True, mustRunString(`{ a: 1 } == { a: 1 }`))
	assertValue(t, False, mustRunString(`{ a: 1 } == { a: 1, b: 2 }`))

	assertValue(t, Int(42), mustRunString(`[0, 42][1]`))
	assertValue(t, String("bar"), mustRunString(`({foo: "bar"}).foo`))
	assertValue(t, String("bar"), mustRunString(`({"foo": "bar"}).foo`))
	assertValue(t, String("bar"), mustRunString(`({["foo"]: "bar", bar: "baz"}).foo`))

	assertValue(t, Int(42), mustRunString(`function (a, b) {
		return function (c) { return a + c; }(b + 1);
	}(1, 40)`))

	assertValue(t, Null, mustRunString(`function () {}()`))
	assertValue(t, Null, mustRunString(`function () { return; }()`))
	assertValue(t, Null, mustRunString(`function (a) { return a; }()`))

	assertValue(t, Int(89), mustRunString(`
		(function (x) {
			return function (f) {
				return function (n) {
					return f(x(x)(f))(n);
				};
			};
		})(function (x) {
			return function (f) {
				return function (n) {
					return f(x(x)(f))(n);
				};
			};
		})(function (f) {
			return function (n) {
				return (n == 0 || n == 1) && 1 || f(n - 2) + f(n - 1);
			};
		})(10)
	`))
}

func TestRunProgramStackOverflow(t *testing.T) {
	src := `
		(function (x) {
			return function (f) {
				return function () {
					return f(x(x)(f))();
				};
			};
		})(function (x) {
			return function (f) {
				return function () {
					return f(x(x)(f))();
				};
			};
		})(function (f) {
			return function () {
				return f();
			};
		})()
	`

	r := New()
	_, err := r.RunString(src)
	if err != ErrStackOverflow {
		t.Errorf("stack overflow expected")
	}
}

func TestRunExamples(t *testing.T) {
	fileInfo, err := ioutil.ReadDir("examples/")
	if err != nil {
		t.Error(err)
		return
	}
	for _, f := range fileInfo {
		if f.IsDir() {
			continue
		}
		name := f.Name()
		if !strings.HasSuffix(name, ".gates") {
			continue
		}

		s, err := ioutil.ReadFile("examples/" + name)
		if err != nil {
			t.Error(err)
			continue
		}
		r := New()
		g := r.Global()
		_assert := FunctionFunc(func(fc FunctionCall) Value {
			args := fc.Args()
			argc := len(args)
			if argc < 1 {
				panic(&panicErr{message: "assert takes at least 1 arguments"})
			}
			if !args[0].ToBool() {
				if argc < 2 {
					panic(&panicErr{})
				}
				panic(&panicErr{message: args[1].ToString()})
			}
			return True
		})
		g.Set("assert", _assert)
		g.Set("assert_eq", CurriedFunctionFunc(2, func(fc FunctionCall) Value {
			args := fc.Args()
			argc := len(args)
			if argc < 2 {
				panic(&panicErr{message: "assert_eq takes 2 arguments"})
			}
			message := String(args[0].ToString() + " expected, got " + args[1].ToString())
			return r.Call(_assert, Bool(args[0].Equals(args[1])), message)
		}))
		g.Set("assert_ne", CurriedFunctionFunc(2, func(fc FunctionCall) Value {
			args := fc.Args()
			argc := len(args)
			if argc < 2 {
				panic(&panicErr{message: "assert_ne takes 2 arguments"})
			}
			message := String(args[0].ToString() + " not expected")
			return r.Call(_assert, Bool(!args[0].Equals(args[1])), message)
		}))
		_, err = r.RunString(string(s))
		if err != nil {
			t.Error(err)
		}
	}
}

func TestExceedInstructionLimit(t *testing.T) {
	src := `
	(function (x) {
		return function (f) {
			return function () {
				return f(x(x)(f))();
			};
		};
	})(function (x) {
		return function (f) {
			return function () {
				return f(x(x)(f))();
			};
		};
	})(function (f) {
		return function () {
			return f();
		};
	})()
`

	r := New()
	r.SetCyclesLimit(5)
	_, err := r.RunString(src)
	if err != ErrCyclesLimitExceeded {
		t.Errorf("cycles limit exceeded expected")
	}
}

func TestValueNotAssigned(t *testing.T) {
	r := New()
	src := `(() => {
	  let f, f1;
	  f1 = n => { return f1; };
	  return f;
	})()`
	x, err := r.RunString(src)
	assert.NoError(t, err)
	assert.Equal(t, nil, x.ToNative())
}

func BenchmarkRunProgram(b *testing.B) {
	program, err := Compile(`"hello"[0] + 1 && false`)
	if err != nil {
		panic(err)
	}

	ctx := context.Background()
	b.ResetTimer()
	b.RunParallel(func(pb *testing.PB) {
		r := New()
		for pb.Next() {
			r.RunProgram(ctx, program)
		}
	})
}