616 lines
13 KiB
Go
616 lines
13 KiB
Go
package parser
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
|
|
"code.jmug.me/jmug/interpreter-in-go/pkg/ast"
|
|
"code.jmug.me/jmug/interpreter-in-go/pkg/lexer"
|
|
)
|
|
|
|
func TestLetStatements(t *testing.T) {
|
|
input := `
|
|
let x = 5;
|
|
let y = 10;
|
|
let foobar = 838383;
|
|
`
|
|
l := lexer.New(input)
|
|
p := New(l)
|
|
|
|
program := p.ParseProgram()
|
|
checkParserErrors(t, p)
|
|
if program == nil {
|
|
t.Fatalf("ParseProgram() returned nil")
|
|
}
|
|
if len(program.Statements) != 3 {
|
|
t.Fatalf("program.Statements does not contain 3 statements. got=%d",
|
|
len(program.Statements))
|
|
}
|
|
|
|
tests := []struct {
|
|
expectedIdentifier string
|
|
}{
|
|
{"x"},
|
|
{"y"},
|
|
{"foobar"},
|
|
}
|
|
|
|
for i, tt := range tests {
|
|
stmt := program.Statements[i]
|
|
if !testLetStatement(t, stmt, tt.expectedIdentifier) {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func testLetStatement(t *testing.T, s ast.Statement, name string) bool {
|
|
if s.TokenLiteral() != "let" {
|
|
t.Errorf("s.TokenLiteral not 'let'. got=%q", s.TokenLiteral())
|
|
return false
|
|
}
|
|
|
|
letStmt, ok := s.(*ast.LetStatement)
|
|
if !ok {
|
|
t.Errorf("s not *ast.LetStatement. got=%T", s)
|
|
return false
|
|
}
|
|
|
|
if letStmt.Name.Value != name {
|
|
t.Errorf("letStmt.Name.Value not '%s'. got=%s", name, letStmt.Name.Value)
|
|
return false
|
|
}
|
|
|
|
if letStmt.Name.TokenLiteral() != name {
|
|
t.Errorf("letStmt.Name.TokenLiteral() not '%s'. got=%s",
|
|
name, letStmt.Name.TokenLiteral())
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
func TestReturnStatements(t *testing.T) {
|
|
input := `
|
|
return 5;
|
|
return 10;
|
|
return 993322;
|
|
`
|
|
l := lexer.New(input)
|
|
p := New(l)
|
|
|
|
program := p.ParseProgram()
|
|
checkParserErrors(t, p)
|
|
|
|
if len(program.Statements) != 3 {
|
|
t.Fatalf("program.Statements does not contain 3 statements. got=%d",
|
|
len(program.Statements))
|
|
}
|
|
|
|
for _, stmt := range program.Statements {
|
|
returnStmt, ok := stmt.(*ast.ReturnStatement)
|
|
if !ok {
|
|
t.Errorf("stmt not *ast.ReturnStatement. got=%T", stmt)
|
|
continue
|
|
}
|
|
if returnStmt.TokenLiteral() != "return" {
|
|
t.Errorf("returnStmt.TokenLiteral not 'return', got %q",
|
|
returnStmt.TokenLiteral())
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestIdentifierExpressions(t *testing.T) {
|
|
input := "foobar;"
|
|
l := lexer.New(input)
|
|
p := New(l)
|
|
program := p.ParseProgram()
|
|
checkParserErrors(t, p)
|
|
if len(program.Statements) != 1 {
|
|
t.Fatalf("program has not enough statements. got=%d",
|
|
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])
|
|
}
|
|
|
|
ident, ok := stmt.Expression.(*ast.Identifier)
|
|
if !ok {
|
|
t.Fatalf("exp not *ast.Identifier. got=%T", stmt.Expression)
|
|
}
|
|
if ident.Value != "foobar" {
|
|
t.Errorf("ident.Value not %s. got=%s", "foobar", ident.Value)
|
|
}
|
|
if ident.TokenLiteral() != "foobar" {
|
|
t.Errorf("ident.TokenLiteral not %s. got=%s", "foobar",
|
|
ident.TokenLiteral())
|
|
}
|
|
}
|
|
|
|
func TestIntegerLiteralExpression(t *testing.T) {
|
|
input := "5;"
|
|
|
|
l := lexer.New(input)
|
|
p := New(l)
|
|
program := p.ParseProgram()
|
|
checkParserErrors(t, p)
|
|
|
|
if len(program.Statements) != 1 {
|
|
t.Fatalf("program has not enough statements. got=%d",
|
|
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])
|
|
}
|
|
|
|
literal, ok := stmt.Expression.(*ast.IntegerLiteral)
|
|
if !ok {
|
|
t.Fatalf("exp not *ast.IntegerLiteral. got=%T", stmt.Expression)
|
|
}
|
|
if literal.Value != 5 {
|
|
t.Errorf("literal.Value not %d. got=%d", 5, literal.Value)
|
|
}
|
|
if literal.TokenLiteral() != "5" {
|
|
t.Errorf("literal.TokenLiteral not %s. got=%s", "5",
|
|
literal.TokenLiteral())
|
|
}
|
|
}
|
|
|
|
func TestParsingPrefixExpressions(t *testing.T) {
|
|
prefixTests := []struct {
|
|
input string
|
|
operator string
|
|
value any
|
|
}{
|
|
{"!5;", "!", 5},
|
|
{"-15;", "-", 15},
|
|
{"!true;", "!", true},
|
|
{"!false;", "!", false},
|
|
}
|
|
|
|
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 !testLiteralExpression(t, exp.Right, tt.value) {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// parser/parser_test.go
|
|
|
|
func TestParsingInfixExpressions(t *testing.T) {
|
|
infixTests := []struct {
|
|
input string
|
|
leftValue any
|
|
operator string
|
|
rightValue any
|
|
}{
|
|
{"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},
|
|
{"true == true", true, "==", true},
|
|
{"true != false", true, "!=", false},
|
|
{"false == false", false, "==", false},
|
|
}
|
|
|
|
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])
|
|
}
|
|
|
|
if !testInfixExpression(t, stmt.Expression, tt.leftValue, tt.operator, 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)))",
|
|
},
|
|
{
|
|
"true",
|
|
"true",
|
|
},
|
|
{
|
|
"false",
|
|
"false",
|
|
},
|
|
{
|
|
"3 > 5 == false",
|
|
"((3 > 5) == false)",
|
|
},
|
|
{
|
|
"3 < 5 == true",
|
|
"((3 < 5) == true)",
|
|
},
|
|
{
|
|
"1 + (2 + 3) + 4",
|
|
"((1 + (2 + 3)) + 4)",
|
|
},
|
|
{
|
|
"(5 + 5) * 2",
|
|
"((5 + 5) * 2)",
|
|
},
|
|
{
|
|
"2 / (5 + 5)",
|
|
"(2 / (5 + 5))",
|
|
},
|
|
{
|
|
"-(5 + 5)",
|
|
"(-(5 + 5))",
|
|
},
|
|
{
|
|
"!(true == true)",
|
|
"(!(true == true))",
|
|
},
|
|
}
|
|
|
|
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 TestBooleanExpression(t *testing.T) {
|
|
tests := []struct {
|
|
input string
|
|
expectedBoolean bool
|
|
}{
|
|
{"true;", true},
|
|
{"false;", false},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
l := lexer.New(tt.input)
|
|
p := New(l)
|
|
program := p.ParseProgram()
|
|
checkParserErrors(t, p)
|
|
|
|
if len(program.Statements) != 1 {
|
|
t.Fatalf("program has not enough statements. got=%d",
|
|
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])
|
|
}
|
|
|
|
boolean, ok := stmt.Expression.(*ast.Boolean)
|
|
if !ok {
|
|
t.Fatalf("exp not *ast.Boolean. got=%T", stmt.Expression)
|
|
}
|
|
if boolean.Value != tt.expectedBoolean {
|
|
t.Errorf("boolean.Value not %t. got=%t", tt.expectedBoolean,
|
|
boolean.Value)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestIfExpression(t *testing.T) {
|
|
input := `if (x < y) { x }`
|
|
|
|
l := lexer.New(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.IfExpression)
|
|
if !ok {
|
|
t.Fatalf("stmt.Expression is not ast.IfExpression. got=%T",
|
|
stmt.Expression)
|
|
}
|
|
|
|
if !testInfixExpression(t, exp.Condition, "x", "<", "y") {
|
|
return
|
|
}
|
|
|
|
if len(exp.Consequence.Statements) != 1 {
|
|
t.Errorf("consequence is not 1 statements. got=%d\n",
|
|
len(exp.Consequence.Statements))
|
|
}
|
|
|
|
consequence, ok := exp.Consequence.Statements[0].(*ast.ExpressionStatement)
|
|
if !ok {
|
|
t.Fatalf("Statements[0] is not ast.ExpressionStatement. got=%T",
|
|
exp.Consequence.Statements[0])
|
|
}
|
|
|
|
if !testIdentifier(t, consequence.Expression, "x") {
|
|
return
|
|
}
|
|
|
|
if exp.Alternative != nil {
|
|
t.Errorf("exp.Alternative.Statements was not nil. got=%+v", exp.Alternative)
|
|
}
|
|
}
|
|
|
|
func TestIfElseExpression(t *testing.T) {
|
|
input := `if (x < y) { x } else { y }`
|
|
|
|
l := lexer.New(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.IfExpression)
|
|
if !ok {
|
|
t.Fatalf("stmt.Expression is not ast.IfExpression. got=%T",
|
|
stmt.Expression)
|
|
}
|
|
|
|
if !testInfixExpression(t, exp.Condition, "x", "<", "y") {
|
|
return
|
|
}
|
|
|
|
if len(exp.Consequence.Statements) != 1 {
|
|
t.Errorf("consequence is not 1 statements. got=%d\n",
|
|
len(exp.Consequence.Statements))
|
|
}
|
|
|
|
consequence, ok := exp.Consequence.Statements[0].(*ast.ExpressionStatement)
|
|
if !ok {
|
|
t.Fatalf("Statements[0] of consequence is not ast.ExpressionStatement. got=%T",
|
|
exp.Consequence.Statements[0])
|
|
}
|
|
|
|
if !testIdentifier(t, consequence.Expression, "x") {
|
|
return
|
|
}
|
|
|
|
if len(exp.Alternative.Statements) != 1 {
|
|
t.Errorf("alternative is not 1 statement. got=%d\n",
|
|
len(exp.Alternative.Statements))
|
|
}
|
|
|
|
alternative, ok := exp.Alternative.Statements[0].(*ast.ExpressionStatement)
|
|
if !ok {
|
|
t.Fatalf("Statements[0] of alternative is not ast.ExpressionStatement. got=%T",
|
|
exp.Alternative.Statements[0])
|
|
}
|
|
if !testIdentifier(t, alternative.Expression, "y") {
|
|
return
|
|
}
|
|
}
|
|
func testIdentifier(t *testing.T, exp ast.Expression, value string) bool {
|
|
ident, ok := exp.(*ast.Identifier)
|
|
if !ok {
|
|
t.Errorf("exp not *ast.Identifier. got=%T", exp)
|
|
return false
|
|
}
|
|
|
|
if ident.Value != value {
|
|
t.Errorf("ident.Value not %s. got=%s", value, ident.Value)
|
|
return false
|
|
}
|
|
|
|
if ident.TokenLiteral() != value {
|
|
t.Errorf("ident.TokenLiteral not %s. got=%s", value,
|
|
ident.TokenLiteral())
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
func testBooleanLiteral(t *testing.T, exp ast.Expression, value bool) bool {
|
|
bo, ok := exp.(*ast.Boolean)
|
|
if !ok {
|
|
t.Errorf("exp not *ast.Boolean. got=%T", exp)
|
|
return false
|
|
}
|
|
|
|
if bo.Value != value {
|
|
t.Errorf("bo.Value not %t. got=%t", value, bo.Value)
|
|
return false
|
|
}
|
|
|
|
if bo.TokenLiteral() != fmt.Sprintf("%t", value) {
|
|
t.Errorf("bo.TokenLiteral not %t. got=%s",
|
|
value, bo.TokenLiteral())
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
func testLiteralExpression(
|
|
t *testing.T,
|
|
exp ast.Expression,
|
|
expected any,
|
|
) bool {
|
|
switch v := expected.(type) {
|
|
case int:
|
|
return testIntegerLiteral(t, exp, int64(v))
|
|
case int64:
|
|
return testIntegerLiteral(t, exp, v)
|
|
case string:
|
|
return testIdentifier(t, exp, v)
|
|
case bool:
|
|
return testBooleanLiteral(t, exp, v)
|
|
}
|
|
t.Errorf("type of exp not handled. got=%T", exp)
|
|
return false
|
|
}
|
|
|
|
func testInfixExpression(t *testing.T, exp ast.Expression, left any,
|
|
operator string, right any) bool {
|
|
|
|
opExp, ok := exp.(*ast.InfixExpression)
|
|
if !ok {
|
|
t.Errorf("exp is not ast.InfixExpression. got=%T(%s)", exp, exp)
|
|
return false
|
|
}
|
|
|
|
if !testLiteralExpression(t, opExp.Left, left) {
|
|
return false
|
|
}
|
|
|
|
if opExp.Operator != operator {
|
|
t.Errorf("exp.Operator is not '%s'. got=%q", operator, opExp.Operator)
|
|
return false
|
|
}
|
|
|
|
if !testLiteralExpression(t, opExp.Right, right) {
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
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 checkParserErrors(t *testing.T, p *Parser) {
|
|
errors := p.Errors()
|
|
if len(errors) == 0 {
|
|
return
|
|
}
|
|
|
|
t.Errorf("parser has %d errors", len(errors))
|
|
for _, msg := range errors {
|
|
t.Errorf("parser error: %q", msg)
|
|
}
|
|
t.FailNow()
|
|
}
|