Beispiel #1
0
func TestComposeNot(t *testing.T) {
	expr := &ast.Expr{
		Function: &ast.Function{
			Name: "not",
			Params: []*ast.Expr{
				{
					Terminal: &ast.Terminal{
						BoolValue: proto.Bool(false),
					},
				},
			},
		},
	}
	b, err := NewBool(expr)
	if err != nil {
		panic(err)
	}
	r, err := b.Eval(nil)
	if err != nil {
		panic(err)
	}
	if r != true {
		t.Fatalf("expected true")
	}
	str := funcs.Sprint(b.Func)
	if str != "true" {
		t.Fatalf("trimming did not work: %s", str)
	}
}
Beispiel #2
0
func TestComposeContains(t *testing.T) {
	expr := &ast.Expr{
		Function: &ast.Function{
			Name: "contains",
			Params: []*ast.Expr{
				{
					Function: &ast.Function{
						Name: "nfkc",
						Params: []*ast.Expr{
							{
								Terminal: &ast.Terminal{
									Variable: &ast.Variable{
										Name: "a.a.a",
										Type: types.SINGLE_STRING,
									},
								},
							},
						},
					},
				},
				{
					Function: &ast.Function{
						Name: "nfkc",
						Params: []*ast.Expr{
							{
								Terminal: &ast.Terminal{
									StringValue: proto.String("TheStreet"),
								},
							},
						},
					},
				},
			},
		},
	}
	b, err := NewBool(expr)
	if err != nil {
		panic(err)
	}
	r, err := b.Eval(serialize.NewStringValue("TheStreet"))
	if err != nil {
		panic(err)
	}
	if r != true {
		t.Fatalf("expected true")
	}
	r, err = b.Eval(serialize.NewStringValue("ThatStreet"))
	if err != nil {
		panic(err)
	}
	if r != false {
		t.Fatalf("expected false")
	}
	if strings.Contains(funcs.Sprint(b.Func), "nfkc(`TheStreet`)") {
		t.Fatalf("trimming did not work")
	}
}
Beispiel #3
0
func TestList(t *testing.T) {
	expr := &ast.Expr{
		Function: &ast.Function{
			Name: "eq",
			Params: []*ast.Expr{
				{
					Function: &ast.Function{
						Name: "elem",
						Params: []*ast.Expr{
							{
								List: &ast.List{
									Type: types.LIST_STRING,
									Elems: []*ast.Expr{
										{
											Terminal: &ast.Terminal{
												StringValue: proto.String("abc"),
											},
										},
									},
								},
							},
							{
								Terminal: &ast.Terminal{
									Int64Value: proto.Int64(0),
								},
							},
						},
					},
				},
				{
					Terminal: &ast.Terminal{
						StringValue: proto.String("abc"),
					},
				},
			},
		},
	}
	b, err := NewBool(expr)
	if err != nil {
		panic(err)
	}
	str := funcs.Sprint(b.Func)
	if str != "true" {
		t.Fatalf("not enough trimming on %s", str)
	}
	r, err := b.Eval(nil)
	if err != nil {
		panic(err)
	}
	if r != true {
		t.Fatalf("expected true")
	}
}
Beispiel #4
0
func TestComposeListBool(t *testing.T) {
	expr := &ast.Expr{
		Function: &ast.Function{
			Name: "eq",
			Params: []*ast.Expr{
				{
					Function: &ast.Function{
						Name: "length",
						Params: []*ast.Expr{
							{
								List: &ast.List{
									Type: types.LIST_BOOL,
									Elems: []*ast.Expr{
										{
											Terminal: &ast.Terminal{
												BoolValue: proto.Bool(true),
											},
										},
										{
											Terminal: &ast.Terminal{
												BoolValue: proto.Bool(false),
											},
										},
									},
								},
							},
						},
					},
				},
				{
					Terminal: &ast.Terminal{
						Int64Value: proto.Int64(2),
					},
				},
			},
		},
	}
	b, err := NewBool(expr)
	if err != nil {
		panic(err)
	}
	r, err := b.Eval(nil)
	if err != nil {
		panic(err)
	}
	if r != true {
		t.Fatalf("expected true")
	}
	str := funcs.Sprint(b.Func)
	if str != "true" {
		t.Fatalf("trimming did not work: %s", str)
	}
}
Beispiel #5
0
func TestNoTrim(t *testing.T) {
	expr := &ast.Expr{
		Function: &ast.Function{
			Name: "eq",
			Params: []*ast.Expr{
				{
					Function: &ast.Function{
						Name: "elem",
						Params: []*ast.Expr{
							{
								List: &ast.List{
									Type: types.LIST_STRING,
									Elems: []*ast.Expr{
										{
											Function: &ast.Function{
												Name: "print",
												Params: []*ast.Expr{
													{
														Terminal: &ast.Terminal{
															Variable: &ast.Variable{
																Name: "a.a.a",
																Type: types.SINGLE_STRING,
															},
														},
													},
												},
											},
										},
									},
								},
							},
							{
								Terminal: &ast.Terminal{
									Int64Value: proto.Int64(0),
								},
							},
						},
					},
				},
				{
					Terminal: &ast.Terminal{
						StringValue: proto.String("abc"),
					},
				},
			},
		},
	}
	b, err := NewBool(expr)
	if err != nil {
		panic(err)
	}
	str := funcs.Sprint(b.Func)
	if str == "false" {
		t.Fatalf("too much trimming")
	}
	t.Logf("trimmed = %s", str)
	r, err := b.Eval(serialize.NewStringValue("abc"))
	if err != nil {
		panic(err)
	}
	if r != true {
		t.Fatalf("expected true")
	}
}
Beispiel #6
0
func TestComposeListInt64(t *testing.T) {
	expr := &ast.Expr{
		Function: &ast.Function{
			Name: "eq",
			Params: []*ast.Expr{
				{
					Function: &ast.Function{
						Name: "elem",
						Params: []*ast.Expr{
							{
								Function: &ast.Function{
									Name: "print",
									Params: []*ast.Expr{
										{
											List: &ast.List{
												Type: types.LIST_INT64,
												Elems: []*ast.Expr{
													{
														Terminal: &ast.Terminal{
															Int64Value: proto.Int64(1),
														},
													},
													{
														Terminal: &ast.Terminal{
															Int64Value: proto.Int64(2),
														},
													},
												},
											},
										},
									},
								},
							},
							{
								Terminal: &ast.Terminal{
									Int64Value: proto.Int64(1),
								},
							},
						},
					},
				},
				{
					Terminal: &ast.Terminal{
						Int64Value: proto.Int64(2),
					},
				},
			},
		},
	}
	b, err := NewBool(expr)
	if err != nil {
		panic(err)
	}
	r, err := b.Eval(nil)
	if err != nil {
		panic(err)
	}
	if r != true {
		t.Fatalf("expected true")
	}
	t.Logf("%s", funcs.Sprint(b.Func))
}