tmp

internal/rule/factory.go

@@ -63,10 +63,9 @@ func (e *expressionTreeFactory) CreateExpressionTree(tokens []Token) (expression
 // 13. While there are operators on the stack, pop them to the queue
 
 func reversePolishNotationSort(tokens []Token) []Token {
-	var (
-		operatorStack arraystack.Stack
-		outputTokens  []Token
-	)
+
+	var outputTokens []Token
+	operatorStack := arraystack.New()
 
 	for _, token := range tokens {
 		if isOperator(token) {
@@ -100,7 +99,10 @@ func reversePolishNotationSort(tokens []Token) []Token {
 		if token.Name == tokenRParen {
 			var lParen *Token
 			for !operatorStack.Empty() || lParen == nil {
-				v, _ := operatorStack.Pop()
+				v, ok := operatorStack.Pop()
+				if !ok {
+					continue
+				}
 
 				vt := v.(Token)
 

internal/rule/factory_test.go

@@ -1,6 +1,9 @@
 package rule
 
-import "testing"
+import (
+	"reflect"
+	"testing"
+)
 
 func Test_isOperator(t *testing.T) {
 	type args struct {
@@ -86,3 +89,70 @@ func Test_isTokenWithGreaterPrecedenceFromThePrecedenceSlices(t *testing.T) {
 		})
 	}
 }
+
+func Test_reversePolishNotationSort(t *testing.T) {
+	type args struct {
+		tokens []Token
+	}
+	tests := []struct {
+		name string
+		args args
+		want []Token
+	}{
+		{
+			name: "tokens should be ordered",
+			args: args{
+				tokens: []Token{
+					{
+						Name:  tokenFunction,
+						Value: "LEN",
+					},
+					{
+						Name:  tokenLParen,
+						Value: tokenLParen,
+					},
+					{
+						Name:  tokenVariable,
+						Value: "p",
+					},
+					{
+						Name:  tokenDot,
+						Value: ".",
+					},
+					{
+						Name:  tokenField,
+						Value: "headers",
+					},
+					{
+						Name:  tokenRParen,
+						Value: tokenRParen,
+					},
+					{
+						Name:  tokenSpace,
+						Value: tokenSpace,
+					},
+					{
+						Name:  tokenMoreThan,
+						Value: tokenMoreThan,
+					},
+					{
+						Name:  tokenSpace,
+						Value: tokenSpace,
+					},
+					{
+						Name:  tokenNumber,
+						Value: "5",
+					},
+				},
+			},
+			want: nil,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := reversePolishNotationSort(tt.args.tokens); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("reversePolishNotationSort() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}