From 05626592208f56d88523887e2b80c0514f8ac210 Mon Sep 17 00:00:00 2001
From: Alexander Kiryukhin <a.kiryukhin@mail.ru>
Date: Mon, 13 Jun 2022 04:31:31 +0300
Subject: initial

---
 lexpr_test.go | 176 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 176 insertions(+)
 create mode 100644 lexpr_test.go

(limited to 'lexpr_test.go')

diff --git a/lexpr_test.go b/lexpr_test.go
new file mode 100644
index 0000000..b811957
--- /dev/null
+++ b/lexpr_test.go
@@ -0,0 +1,176 @@
+package lexpr
+
+import (
+	"context"
+	"reflect"
+	"testing"
+)
+
+func TestLexpr_Eval(t *testing.T) {
+	type fields struct {
+		operators map[string]Operator
+		functions map[string]func(ts *TokenStack) error
+		variables map[string]any
+	}
+	type args struct {
+		expression string
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		want    any
+		wantErr bool
+	}{
+		{
+			name: "simple math",
+			fields: fields{
+				operators: Operators,
+				functions: Functions,
+				variables: map[string]any{},
+			},
+			args:    args{expression: "2 + 2 * 2"},
+			want:    6,
+			wantErr: false,
+		},
+		{
+			name: "complex equal",
+			fields: fields{
+				operators: Operators,
+				functions: Functions,
+				variables: map[string]any{},
+			},
+			args:    args{expression: "min(3, 2) * max(10, 20) == 40"},
+			want:    1,
+			wantErr: false,
+		},
+		{
+			name: "complex neql",
+			fields: fields{
+				operators: Operators,
+				functions: Functions,
+				variables: map[string]any{},
+			},
+			args:    args{expression: "min(3, 2) * max(10, 20) != 40"},
+			want:    0,
+			wantErr: false,
+		},
+		{
+			name: "variables",
+			fields: fields{
+				operators: Operators,
+				functions: Functions,
+				variables: map[string]any{
+					"svar": "test",
+					"ivar": int(123),
+					"fvar": 321.0,
+				},
+			},
+			args: args{
+				expression: "len(svar) + ivar + fvar",
+			},
+			want:    448,
+			wantErr: false,
+		},
+		{
+			name: "invalid1",
+			fields: fields{
+				operators: Operators,
+				functions: Functions,
+				variables: map[string]any{},
+			},
+			args:    args{expression: ")("},
+			want:    nil,
+			wantErr: true,
+		},
+		{
+			name: "invalid2",
+			fields: fields{
+				operators: Operators,
+				functions: Functions,
+				variables: map[string]any{},
+			},
+			args:    args{expression: "var1 + var2"},
+			want:    nil,
+			wantErr: true,
+		},
+		{
+			name: "invalid3",
+			fields: fields{
+				operators: Operators,
+				functions: Functions,
+				variables: map[string]any{},
+			},
+			args:    args{expression: "3 @ 4"},
+			want:    nil,
+			wantErr: true,
+		},
+		{
+			name: "dot notation",
+			fields: fields{
+				operators: Operators,
+				functions: Functions,
+				variables: map[string]any{
+					"j": `{ "one" : { "four": {"five": "six"} }, "two": "three" }`,
+				},
+			},
+			args: args{
+				expression: `j.one.four.five`,
+			},
+			want:    `six`,
+			wantErr: false,
+		},
+		{
+			name: "dot notation with arrays",
+			fields: fields{
+				operators: Operators,
+				functions: Functions,
+				variables: map[string]any{
+					"j": `{ "one" : { "four": ["five", "six", "seven"] }, "two": "three" }`,
+				},
+			},
+			args: args{
+				expression: `j.one.four.1`,
+			},
+			want:    `six`,
+			wantErr: false,
+		},
+		{
+			name: "dot notation with arrays and variables",
+			fields: fields{
+				operators: Operators,
+				functions: Functions,
+				variables: map[string]any{
+					"j":    `{ "one" : { "four": ["five", "six", "seven"] }, "two": "three" }`,
+					"key1": "one",
+					"key2": 1,
+				},
+			},
+			args: args{
+				expression: `j.key1.four.key2`,
+			},
+			want:    `six`,
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			l := &Lexpr{
+				operators: tt.fields.operators,
+				functions: tt.fields.functions,
+				variables: tt.fields.variables,
+			}
+			gotCh := l.Eval(context.Background(), tt.args.expression)
+			res := <-gotCh
+			got := res.Value
+			err := res.Error
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Lexpr.Eval() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("Lexpr.Eval() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
-- 
cgit v1.2.3