go-pkg/expr
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

New test on the tilde operator. Now it is based on simple-var-store

Browse Source
This commit is contained in:
Celestino Amoroso 2024-03-28 06:30:45 +01:00
parent 37f0de5902
commit d20027296c
1 changed files with 30 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
parser_test.go
View File

@ -11,58 +11,7 @@ import (
"testing"
)
type testContext struct {
store map[string]any
}
func newTestContext() *testContext {
return &testContext{
store: make(map[string]any),
}
}
func (ctx *testContext) GetValue(varName string) (v any, exists bool) {
v, exists = ctx.store[varName]
return
}
func (ctx *testContext) SetValue(varName string, value any) {
ctx.store[varName] = value
}
func (ctx *testContext) GetFuncInfo(name string) (f exprFunc) {
if name == "ADD" {
f = &testAddFunc{}
}
return
}
func (ctx *testContext) Call(name string, args []any) (result any, err error) {
if name == "ADD" {
funcObj := &testAddFunc{}
result, err = funcObj.Invoke(ctx, args)
} else {
err = fmt.Errorf("unknown function %q", name)
}
return
}
type testAddFunc struct {
}
func (self *testAddFunc) Name() string {
return "ADD"
}
func (self *testAddFunc) MinArgs() int {
return 1
}
func (self *testAddFunc) MaxArgs() int {
return -1
}
func (self *testAddFunc) Invoke(ctx exprContext, args []any) (result any, err error) {
func addFunc(ctx exprContext, name string, args []any) (result any, err error) {
var sumAsFloat = false
var floatSum float64 = 0.0
var intSum int64 = 0
@ -101,9 +50,15 @@ func TestParser(t *testing.T) {
wantErr error
}
ctx := newTestContext()
// ctx := newTestContext()
ctx := NewSimpleFuncStore()
ctx.SetValue("var1", int64(123))
ctx.SetValue("var2", "abc")
ctx.addFunc("add", addFunc)
// inputs1 := []inputType{
// {`add(1,2,3)`, int64(6), nil},
// }
inputs := []inputType{
/* 1 */ {`1+/*5*/2`, int64(3), nil},
@ -139,7 +94,7 @@ func TestParser(t *testing.T) {
/* 31 */ {"(1+1)*5", int64(10), nil},
/* 32 */ {"200 / (1+1) - 1", int64(99), nil},
/* 33 */ {`add(1,2,3)`, int64(6), nil},
/* 34 */ {`mul(1,2,3)`, nil, errors.New(`unknown function "MUL"`)},
/* 34 */ {`mul(1,2,3)`, nil, errors.New(`unknown function "mul"`)},
/* 35 */ {`add(1+4,3+2,5*(3-2))`, int64(15), nil},
/* 36 */ {`add(add(1+4),3+2,5*(3-2))`, int64(15), nil},
/* 37 */ {`add(add(1+4),/*3+2,*/5*(3-2))`, int64(10), nil},
@ -191,8 +146,18 @@ func TestParser(t *testing.T) {
/* 83 */ {`5 % (-2)`, int64(1), nil},
/* 84 */ {`-5 % 2`, int64(-1), nil},
/* 85 */ {`5 % 2.0`, nil, errors.New(`left operand '5' [int64] is not compatible with right operand '2' [float64] with respect to operator "%"`)},
/* 86 */ {`"a" < "b" AND NOT (2 < 1)`, true, nil},
/* 87 */ {`"a" < "b" AND NOT (2 == 1)`, true, nil},
/* 88 */ {`"a" < "b" AND ~ 2 == 1`, true, nil},
/* 89 */ {`~ 2 > 1`, false, nil},
/* 90 */ {`~ true && true`, false, nil},
/* 91 */ {`~ false || true`, true, nil},
/* 92 */ {`~ (false || true)`, false, nil},
}
succeeded := 0
failed := 0
parser := NewParser(ctx)
for i, input := range inputs {
var expr *ast
@ -208,18 +173,29 @@ func TestParser(t *testing.T) {
r := strings.NewReader(input.source)
scanner := NewScanner(r, DefaultTranslations())
good := true
if expr, gotErr = parser.parse(scanner); gotErr == nil {
gotResult, gotErr = expr.eval(ctx)
}
if gotResult != input.wantResult {
t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
good = false
}
if gotErr != input.wantErr {
if input.wantErr == nil || gotErr == nil || (gotErr.Error() != input.wantErr.Error()) {
t.Errorf("%d: %q -> err = <%v>, want <%v>", i+1, input.source, gotErr, input.wantErr)
good = false
}
}
if good {
succeeded++
} else {
failed++
}
}
t.Log(fmt.Sprintf("test count: %d, succeeded count: %d, failed count: %d", len(inputs), succeeded, failed))
}