fix: flipped values for assert and code refactoring

go.mod

@@ -1,3 +1,11 @@
 module parser
 
 go 1.23.2
+
+require github.com/stretchr/testify v1.9.0
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -0,0 +1,9 @@
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

parser/assert.go

@@ -15,14 +15,16 @@ func (as *AssertStatement) TokenLiteral() string { return as.Token.Lexeme }
 func (as *AssertStatement) Evaluate() (float64, error) {
 	value, err := as.Expression.Evaluate()
 	if err != nil {
-		return 0, err
+		return -1, err
 	}
 
-	if value != 1 {
-		return value, nil
+	fmt.Println("Assert value:", value)
+
+	if value != 0 {
+		return value, fmt.Errorf("assertion failed: %s", as.Expression.String())
 	}
 
-	return 1, nil
+	return value, nil
 }
 
 func (as *AssertStatement) String() string {

parser/infix_expression.go

@@ -5,8 +5,8 @@ import (
 	"parser/constants"
 )
 
-type // InfixExpression is for expressions like 5 + 5, 3 * 3, etc.
-InfixExpression struct {
+// InfixExpression is for expressions like 5 + 5, 3 * 3, etc.
+type InfixExpression struct {
 	Token    constants.Token
 	Operator string
 	Left     Expression
@@ -18,15 +18,13 @@ func (ie *InfixExpression) TokenLiteral() string { return ie.Token.Lexeme }
 func (ie *InfixExpression) Evaluate() (float64, error) {
 	left, err := ie.Left.Evaluate()
 	if err != nil {
-		return 0, err
+		return -1, err
 	}
-	fmt.Println("Left: ", left)
 
 	right, err := ie.Right.Evaluate()
 	if err != nil {
-		return 0, err
+		return -1, err
 	}
-	fmt.Println("Right: ", right)
 
 	fmt.Printf("Evaluating: %s %s %s\n", ie.Left.String(), ie.Operator, ie.Right.String())
 
@@ -45,9 +43,9 @@ func (ie *InfixExpression) Evaluate() (float64, error) {
 		}
 	case "==":
 		if left == right {
-			return 1, nil
-		} else {
 			return 0, nil
+		} else {
+			return 1, nil
 		}
 	case "<=":
 		if left != right {

parser/parser.go

@@ -244,17 +244,3 @@ func (p *Parser) curPrecedence() int {
 	}
 	return LOWEST
 }
-
-func (p *Program) Evaluate() (float64, error) {
-	var result float64
-	var err error
-	for i, stmt := range p.Statements {
-		fmt.Printf("Evaluating statement %d: %s\n", i, stmt.String())
-
-		result, err = stmt.Evaluate()
-		if err != nil {
-			return 0, err
-		}
-	}
-	return result, nil
-}

parser/parser_test.go

@@ -3,42 +3,52 @@ package parser
 import (
 	"parser/lexer"
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 type ParserTestCase struct {
 	input    string
 	expected float64
+	succeed  bool
 }
 
 func TestParser(t *testing.T) {
 	testCases := []ParserTestCase{
 		{
 			input:    "assert !(1 * 5) == 0",
-			expected: 1,
+			expected: 0,
+			succeed: true,
 		},
 		{
 			input:    "assert 1 + 2 * 3 == 5",
-			expected: 0,
+			expected: 1,
+			succeed:  false,
 		},
 		{
 			input:    "assert 1 + 2 * 3 == 7",
-			expected: 1,
+			expected: 0,
+			succeed: true,
 		},
 		{
 			input:    "assert (1 + 2) * 3 == 9",
-			expected: 1,
+			expected: 0,
+			succeed: true,
 		},
 		{
 			input:    "assert 1 + 2 == (1 / 2) * 6",
-			expected: 1,
+			expected: 0,
+			succeed: true,
 		},
 		{
 			input:    "assert 1 + 2 * 3",
 			expected: 7,
+			succeed: false,
 		},
 		{
 			input:    "assert (2 + 2) * 3",
 			expected: 12,
+			succeed: false,
 		},
 	}
 
@@ -54,10 +64,11 @@ func TestParser(t *testing.T) {
 		}
 
 		result, err := program.Evaluate()
-		if err != nil {
-			t.Errorf("Evaluation error: %s", err)
-		} else if result != testCase.expected {
-			t.Errorf("Expected %v, got %v", testCase.expected, result)
+		if testCase.succeed {
+			require.NoError(t, err)
+		} else {
+			require.Error(t, err)
 		}
+		require.Equal(t, testCase.expected, result)
 	}
 }

parser/prefix_expression.go

@@ -13,6 +13,7 @@ type PrefixExpression struct {
 
 func (pe *PrefixExpression) TokenLiteral() string { return pe.Token.Lexeme }
 
+// todo: verify if this is correct
 func (pe *PrefixExpression) Evaluate() (float64, error) {
 	right, err := pe.Right.Evaluate()
 	if err != nil {

parser/program.go

@@ -1,5 +1,10 @@
 package parser
 
+import (
+	"fmt"
+	"strings"
+)
+
 type Program struct {
 	Statements []Statement
 }
@@ -9,4 +14,22 @@ func (p *Program) TokenLiteral() string {
 		return p.Statements[0].TokenLiteral()
 	}
 	return ""
-}
+}
+
+func (p *Program) Evaluate() (float64, error) {
+	var result float64
+	var err error
+	for i, stmt := range p.Statements {
+		fmt.Printf("Evaluating statement %d: %s\n", i, stmt.String())
+
+		result, err = stmt.Evaluate()
+		if err != nil {
+			if strings.Contains(err.Error(), "assertion failed") {
+				return result, err
+			}
+
+			return -1, err
+		}
+	}
+	return result, nil
+}