add prefix, and infix operators

parser/parser_test.go

@@ -4,8 +4,193 @@ import (
 	"monkey/ast"
 	"monkey/lexer"
 	"testing"
+	"fmt"
 )
 
+func TestParsingInfixExpressions(t *testing.T) {
+    infixTests := []struct {
+        input      string
+        leftValue  int64
+        operator   string
+        rightValue int64
+    }{
+        {"5 + 5;", 5, "+", 5},
+        {"5 - 5;", 5, "-", 5},
+        {"5 * 5;", 5, "*", 5},
+        {"5 / 5;", 5, "/", 5},
+        {"5 > 5;", 5, ">", 5},
+        {"5 < 5;", 5, "<", 5},
+        {"5 == 5;", 5, "==", 5},
+        {"5 != 5;", 5, "!=", 5},
+    }
+
+    for _, tt := range infixTests {
+        l := lexer.New(tt.input)
+        p := New(l)
+        program := p.ParseProgram()
+        checkParserErrors(t, p)
+
+        if len(program.Statements) != 1 {
+            t.Fatalf("program.Statements does not contain %d statements. got=%d\n",
+                1, len(program.Statements))
+        }
+
+        stmt, ok := program.Statements[0].(*ast.ExpressionStatement)
+        if !ok {
+            t.Fatalf("program.Statements[0] is not ast.ExpressionStatement. got=%T",
+                program.Statements[0])
+        }
+
+        exp, ok := stmt.Expression.(*ast.InfixExpression)
+        if !ok {
+            t.Fatalf("exp is not ast.InfixExpression. got=%T", stmt.Expression)
+        }
+
+        if !testIntegerLiteral(t, exp.Left, tt.leftValue) {
+            return
+        }
+
+        if exp.Operator != tt.operator {
+            t.Fatalf("exp.Operator is not '%s'. got=%s",
+                tt.operator, exp.Operator)
+        }
+
+        if !testIntegerLiteral(t, exp.Right, tt.rightValue) {
+            return
+        }
+    }
+}
+
+func TestOperatorPrecedenceParsing(t *testing.T) {
+    tests := []struct {
+        input    string
+        expected string
+    }{
+        {
+            "-a * b",
+            "((-a) * b)",
+        },
+        {
+            "!-a",
+            "(!(-a))",
+        },
+        {
+            "a + b + c",
+            "((a + b) + c)",
+        },
+        {
+            "a + b - c",
+            "((a + b) - c)",
+        },
+        {
+            "a * b * c",
+            "((a * b) * c)",
+        },
+        {
+            "a * b / c",
+            "((a * b) / c)",
+        },
+        {
+            "a + b / c",
+            "(a + (b / c))",
+        },
+        {
+            "a + b * c + d / e - f",
+            "(((a + (b * c)) + (d / e)) - f)",
+        },
+        {
+            "3 + 4; -5 * 5",
+            "(3 + 4)((-5) * 5)",
+        },
+        {
+            "5 > 4 == 3 < 4",
+            "((5 > 4) == (3 < 4))",
+        },
+        {
+            "5 < 4 != 3 > 4",
+            "((5 < 4) != (3 > 4))",
+        },
+        {
+            "3 + 4 * 5 == 3 * 1 + 4 * 5",
+            "((3 + (4 * 5)) == ((3 * 1) + (4 * 5)))",
+        },
+    }
+
+    for _, tt := range tests {
+        l := lexer.New(tt.input)
+        p := New(l)
+        program := p.ParseProgram()
+        checkParserErrors(t, p)
+
+        actual := program.String()
+        if actual != tt.expected {
+            t.Errorf("expected=%q, got=%q", tt.expected, actual)
+        }
+    }
+}
+
+func TestParsingPrefixExpressions(t *testing.T) {
+    prefixTests := []struct {
+        input        string
+        operator     string
+        integerValue int64
+    }{
+        {"!5;", "!", 5},
+        {"-15;", "-", 15},
+    }
+
+    for _, tt := range prefixTests {
+        l := lexer.New(tt.input)
+        p := New(l)
+        program := p.ParseProgram()
+        checkParserErrors(t, p)
+
+        if len(program.Statements) != 1 {
+            t.Fatalf("program.Statements does not contain %d statements. got=%d\n",
+                1, len(program.Statements))
+        }
+
+        stmt, ok := program.Statements[0].(*ast.ExpressionStatement)
+        if !ok {
+            t.Fatalf("program.Statements[0] is not ast.ExpressionStatement. got=%T",
+                program.Statements[0])
+        }
+
+        exp, ok := stmt.Expression.(*ast.PrefixExpression)
+        if !ok {
+            t.Fatalf("stmt is not ast.PrefixExpression. got=%T", stmt.Expression)
+        }
+        if exp.Operator != tt.operator {
+            t.Fatalf("exp.Operator is not '%s'. got=%s",
+                tt.operator, exp.Operator)
+        }
+        if !testIntegerLiteral(t, exp.Right, tt.integerValue) {
+            return
+        }
+    }
+}
+
+func testIntegerLiteral(t *testing.T, il ast.Expression, value int64) bool {
+    integ, ok := il.(*ast.IntegerLiteral)
+    if !ok {
+        t.Errorf("il not *ast.IntegerLiteral. got=%T", il)
+        return false
+    }
+
+    if integ.Value != value {
+        t.Errorf("integ.Value not %d. got=%d", value, integ.Value)
+        return false
+    }
+
+    if integ.TokenLiteral() != fmt.Sprintf("%d", value) {
+        t.Errorf("integ.TokenLiteral not %d. got=%s", value,
+            integ.TokenLiteral())
+        return false
+    }
+
+    return true
+}
+
 func TestLetStatements(t *testing.T) {
 	input := `
 let x = 5;