func TestComposeContains(t *testing.T) { expr := ast.NewNestedFunction("contains", ast.NewNestedFunction("toLower", ast.NewStringVar()), ast.NewNestedFunction("toLower", ast.NewStringConst("TheStreet")), ) b, err := NewBool(expr) if err != nil { panic(err) } f, err := NewBoolFunc(b) if err != nil { panic(err) } r, err := f.Eval(debug.NewStringValue("TheStreet")) if err != nil { panic(err) } if r != true { t.Fatalf("expected true") } r, err = f.Eval(debug.NewStringValue("ThatStreet")) if err != nil { panic(err) } if r != false { t.Fatalf("expected false") } if strings.Contains(funcs.Sprint(f.(*composedBool).Func), "toLower(`TheStreet`)") { t.Fatalf("trimming did not work") } }
func TestNoTrim(t *testing.T) { expr := ast.NewNestedFunction("eq", ast.NewNestedFunction("elem", ast.NewStringList( ast.NewNestedFunction("print", ast.NewStringVar(), ), ), ast.NewIntConst(0), ), ast.NewStringConst("abc"), ) b, err := NewBool(expr) if err != nil { panic(err) } f, err := NewBoolFunc(b) if err != nil { panic(err) } str := funcs.Sprint(f.(*composedBool).Func) if str == "false" { t.Fatalf("too much trimming") } t.Logf("trimmed = %s", str) r, err := f.Eval(debug.NewStringValue("abc")) if err != nil { panic(err) } if r != true { t.Fatalf("expected true") } }
func TestList(t *testing.T) { expr := ast.NewNestedFunction("eq", ast.NewNestedFunction("elem", ast.NewStringList( ast.NewStringConst("abc"), ), ast.NewIntConst(0), ), ast.NewStringConst("abc"), ) b, err := NewBool(expr) if err != nil { panic(err) } f, err := NewBoolFunc(b) if err != nil { panic(err) } str := funcs.Sprint(f.(*composedBool).Func) if str != "->true" { t.Fatalf("not enough trimming on %s", str) } r, err := f.Eval(nil) if err != nil { panic(err) } if r != true { t.Fatalf("expected true") } }
func TestComposeListInt64(t *testing.T) { expr := ast.NewNestedFunction("eq", ast.NewNestedFunction("elem", ast.NewNestedFunction("print", ast.NewIntList( ast.NewIntConst(1), ast.NewIntConst(2), ), ), ast.NewIntConst(1), ), ast.NewIntConst(2), ) b, err := NewBool(expr) if err != nil { panic(err) } f, err := NewBoolFunc(b) if err != nil { panic(err) } r, err := f.Eval(nil) if err != nil { panic(err) } if r != true { t.Fatalf("expected true") } t.Logf("%s", funcs.Sprint(f.(*composedBool).Func)) }
func TestComposeListBool(t *testing.T) { expr := ast.NewNestedFunction("eq", ast.NewNestedFunction("length", ast.NewBoolList( ast.NewTrue(), ast.NewFalse(), ), ), ast.NewIntConst(2), ) b, err := NewBool(expr) if err != nil { panic(err) } f, err := NewBoolFunc(b) if err != nil { panic(err) } r, err := f.Eval(nil) if err != nil { panic(err) } if r != true { t.Fatalf("expected true") } str := funcs.Sprint(f.(*composedBool).Func) if str != "->true" { t.Fatalf("trimming did not work: %s", str) } }
func TestComposeStringEq(t *testing.T) { expr := ast.NewNestedFunction("eq", ast.NewNestedFunction("toLower", ast.NewStringVar()), ast.NewNestedFunction("toLower", ast.NewStringConst("TheStreet")), ) b, err := NewBool(expr) if err != nil { panic(err) } f, err := NewBoolFunc(b) if err != nil { panic(err) } r, err := f.Eval(debug.NewStringValue("TheStreet")) if err != nil { panic(err) } if r != true { t.Fatalf("expected true") } }
//ConvertBuiltInIntoFunction converts a BuiltIn Expr into a Function Expr. func ConvertBuiltInIntoFunction(e *ast.Expr) (*ast.Expr, error) { if e.BuiltIn == nil { return e, nil } s := e.GetBuiltIn().GetSymbol().GetValue() right := e.GetBuiltIn().GetExpr().Clone() typ, err := Which(right) if err != nil { return nil, err } if types.IsList(typ) { typ = types.ListToSingle(typ) } left := ast.NewVar(typ) funcName := ast.BuiltInFunctionName(s) e2 := ast.NewNestedFunction(funcName, left, right) if funcName == "regex" { e2 = ast.NewNestedFunction(funcName, right, ast.NewVar(types.SINGLE_STRING)) } else if funcName == "type" { e2 = ast.NewNestedFunction(funcName, right) } return e2, nil }
func TestConst(t *testing.T) { expr := ast.NewNestedFunction("regex", ast.NewStringVar(), ast.NewStringConst("ab"), ) b, err := NewBool(expr) if err != nil { panic(err) } _, err = NewBoolFunc(b) if err == nil { t.Fatalf("expected error") } if !strings.Contains(err.Error(), "regex has constant") || !strings.Contains(err.Error(), "has a variable parameter") { t.Fatalf("expected more specific error %s", err.Error()) } }
func TestTrimInit(t *testing.T) { expr := ast.NewNestedFunction("regex", ast.NewStringConst(".*"), ast.NewStringConst("ab"), ) b, err := NewBool(expr) if err != nil { panic(err) } f, err := NewBoolFunc(b) if err != nil { panic(err) } r, err := f.Eval(nil) if err != nil { panic(err) } if r != true { t.Fatalf("expected true") } }
func TestComposeRegex(t *testing.T) { expr := ast.NewNestedFunction("regex", ast.NewStringConst("ab"), ast.NewStringVar(), ) b, err := NewBool(expr) if err != nil { panic(err) } f, err := NewBoolFunc(b) if err != nil { panic(err) } r, err := f.Eval(debug.NewStringValue("a")) if err != nil { panic(err) } if r != false { t.Fatalf("expected false") } }