func Test_SequenceAction_create(t *testing.T) {
rt := &Runtime{}
action := NewSequenceAction()
assert.Equal(t, 0, len(action.subactions))
// Execute() on an empty SequenceAction does nothing, silently
assert.Nil(t, action.Execute(rt))
// action 1 is a bare string: "ls -lR foo/bar"
cmd := dsl.NewASTString("\"ls -lR foo/bar\"")
action.AddCommand(cmd)
// action 2: a = "foo"
assign := dsl.NewASTAssignment(
"a",
dsl.NewASTString("foo"))
action.AddAssignment(assign)
// action 3: remove("*.o")
fcall := dsl.NewASTFunctionCall(
dsl.NewASTString("remove"),
[]dsl.ASTExpression{dsl.NewASTString("\"*.c\"")})
action.AddFunctionCall(fcall)
assert.Equal(t, 3, len(action.subactions))
assert.Equal(t,
"ls -lR foo/bar",
action.subactions[0].(*CommandAction).raw.ValueString())
}
func Test_evaluate_list(t *testing.T) {
rt := minimalRuntime()
rt.stack.Assign("blop", types.MakeFuString("bar"))
elements := []dsl.ASTExpression{
dsl.NewASTString("\"foo\""),
dsl.NewASTName("blop"),
dsl.NewASTString("\"baz\""),
}
astlist := dsl.NewASTList(elements)
actual, errs := rt.evaluate(astlist)
testutils.NoErrors(t, errs)
expect := types.MakeStringList("foo", "bar", "baz")
assert.Equal(t, expect, actual)
}
func Test_prepareCall(t *testing.T) {
// this is never going to be called, so it's OK that it's nil
var fn_dummy func(argsource types.ArgSource) (types.FuObject, []error)
var dummy1, dummy2 types.FuCallable
dummy1 = types.NewFixedFunction("dummy1", 0, fn_dummy)
dummy2 = types.NewFixedFunction("dummy1", 1, fn_dummy)
rt := minimalRuntime()
ns := rt.Namespace()
ns.Assign("dummy1", dummy1)
ns.Assign("dummy2", dummy2)
ns.Assign("x", types.MakeFuString("whee!"))
noargs := []dsl.ASTExpression{}
onearg := []dsl.ASTExpression{dsl.NewASTString("\"meep\"")}
var astcall *dsl.ASTFunctionCall
var callable types.FuCallable
var args RuntimeArgs
var errs []error
// correct (no args) call to dummy1()
astcall = dsl.NewASTFunctionCall(dsl.NewASTName("dummy1"), noargs)
callable, args, errs = rt.prepareCall(astcall)
assert.Equal(t, 0, len(errs))
assert.Equal(t, dummy1, callable)
assert.Equal(t, []types.FuObject{}, args.Args())
// and to dummy2()
astcall = dsl.NewASTFunctionCall(dsl.NewASTName("dummy2"), onearg)
callable, args, errs = rt.prepareCall(astcall)
assert.Equal(t, 0, len(errs))
assert.Equal(t, dummy2, callable)
assert.Equal(t, []types.FuObject{types.MakeFuString("meep")}, args.Args())
// attempt to call dummy2() incorrectly (1 arg, but it's an undefined name)
astcall = dsl.NewASTFunctionCall(
dsl.NewASTName("dummy2"),
[]dsl.ASTExpression{dsl.NewASTName("bogus")})
callable, _, errs = rt.prepareCall(astcall)
assert.Equal(t, 1, len(errs))
assert.Equal(t, "name not defined: 'bogus'", errs[0].Error())
// attempt to call non-existent function
astcall = dsl.NewASTFunctionCall(dsl.NewASTName("bogus"), noargs)
callable, _, errs = rt.prepareCall(astcall)
assert.Nil(t, callable)
assert.Equal(t, 1, len(errs))
assert.Equal(t, "name not defined: 'bogus'", errs[0].Error())
// attempt to call something that is not a function
astcall = dsl.NewASTFunctionCall(dsl.NewASTName("x"), noargs)
callable, _, errs = rt.prepareCall(astcall)
assert.Nil(t, callable)
assert.Equal(t, 1, len(errs))
assert.Equal(t, "not a function or method: 'x'", errs[0].Error())
}
func Test_evaluate_list_errors(t *testing.T) {
rt := minimalRuntime()
rt.stack.Assign("src", types.MakeFuString("foo.c"))
elements := []dsl.ASTExpression{
dsl.NewASTString("\"whee!\""),
dsl.NewASTName("bogus"),
dsl.NewASTName("src"),
dsl.NewASTString("\"bop\""),
dsl.NewASTName("morebogus"),
}
astlist := dsl.NewASTList(elements)
actual, errs := rt.evaluate(astlist)
if len(errs) != 2 {
t.Fatalf("expected 2 errors, but got %d: %v", len(errs), errs)
}
assert.Equal(t, "name not defined: 'bogus'", errs[0].Error())
assert.Equal(t, "name not defined: 'morebogus'", errs[1].Error())
assert.Nil(t, actual)
}
func stringnode(value string) *dsl.ASTString {
// NewASTString takes a token, which comes quoted
value = "\"" + value + "\""
return dsl.NewASTString(value)
}