add tuples tests

core/parser_test.go

@@ -1,9 +1,8 @@
 package core
 
 import (
-	"fmt"
+	"math/big"
 	"strconv"
-	"strings"
 	"testing"
 )
 
@@ -651,6 +650,57 @@ func GetTokenTestData() map[string]TokenTestData {
 				0, 0,
 			},
 		},
+		"single_tuple": {
+			[]Token{
+				NewToken(TokenOpenParenthesis, 0, 0, 0, "("),
+				NewToken(TokenInteger, 0, 0, 0, "1"),
+				NewToken(TokenComma, 0, 0, 0, ","),
+				NewToken(TokenCloseParenthesis, 0, 0, 0, ")"),
+				NewToken(TokenEOF, 0, 0, 0, ""),
+			},
+			&BlockNode{
+				[]Node{
+					&TupleNode{
+						[]Node{
+							&IntegerNode{
+								big.NewInt(1),
+								0, 0,
+							},
+						},
+						0, 0,
+					},
+				},
+				0, 0,
+			},
+		},
+		"tuple": {
+			[]Token{
+				NewToken(TokenOpenParenthesis, 0, 0, 0, "("),
+				NewToken(TokenInteger, 0, 0, 0, "1"),
+				NewToken(TokenComma, 0, 0, 0, ","),
+				NewToken(TokenInteger, 0, 0, 0, "2"),
+				NewToken(TokenCloseParenthesis, 0, 0, 0, ")"),
+				NewToken(TokenEOF, 0, 0, 0, ""),
+			},
+			&BlockNode{
+				[]Node{
+					&TupleNode{
+						[]Node{
+							&IntegerNode{
+								big.NewInt(1),
+								0, 0,
+							},
+							&IntegerNode{
+								big.NewInt(2),
+								0, 0,
+							},
+						},
+						0, 0,
+					},
+				},
+				0, 0,
+			},
+		},
 	}
 }
 
@@ -834,110 +884,24 @@ func NodeEquality(t *testing.T, n1 Node, n2 Node) {
 			NodeEquality(t, v1, l2.items[i])
 		}
 
+	case TupleNodeType:
+		t1 := n1.(*TupleNode)
+		t2 := n2.(*TupleNode)
+
+		if len(t1.items) != len(t2.items) {
+			t.Fatalf("tuple item count does not match")
+		}
+
+		for i, v1 := range t1.items {
+			t.Logf("Checking item %d", i)
+			NodeEquality(t, v1, t2.items[i])
+		}
+
 	default:
 		panic("unimplemented node equality")
 	}
 }
 
-func SerializeTokens(tokens []Token) string {
-	out := strings.Builder{}
-	level := 0
-
-	for _, token := range tokens {
-		switch token.Type {
-		case TokenPlus:
-			out.WriteString(" + ")
-		case TokenMinus:
-			out.WriteString(" - ")
-		case TokenStar:
-			out.WriteString("*")
-		case TokenSlash:
-			out.WriteString("/")
-		case TokenBang:
-			out.WriteString("!")
-		case TokenSemicolon:
-			out.WriteString(";")
-		case TokenFloat:
-			out.WriteString(token.Lexeme)
-		case TokenString:
-			out.WriteString(fmt.Sprintf("\"%s\"", token.Lexeme))
-		case TokenName:
-			out.WriteString(token.Lexeme)
-		case TokenOpenParenthesis:
-			out.WriteString("(")
-		case TokenCloseParenthesis:
-			out.WriteString(")")
-		case TokenOpenBracket:
-			out.WriteString("[")
-		case TokenCloseBracket:
-			out.WriteString("]")
-		case TokenOpenBrace:
-			out.WriteString("{")
-			level = level + 1
-		case TokenCloseBrace:
-			out.WriteString("}")
-			level = level - 1
-		case TokenTrue:
-			out.WriteString("true")
-		case TokenFalse:
-			out.WriteString("false")
-		case TokenNil:
-			out.WriteString("nil")
-		case TokenFunc:
-			out.WriteString("fn")
-		case TokenReturn:
-			out.WriteString("return ")
-		case TokenWhile:
-			out.WriteString("while ")
-		case TokenVar:
-			out.WriteString("var ")
-		case TokenIf:
-			out.WriteString("if ")
-		case TokenElse:
-			out.WriteString(" else ")
-		case TokenImport:
-			out.WriteString("import ")
-		case TokenComma:
-			out.WriteString(", ")
-		case TokenDot:
-			out.WriteString(".")
-		case TokenColon:
-			out.WriteString(": ")
-		case TokenAssign:
-			out.WriteString(" = ")
-		case TokenDeclare:
-			out.WriteString(" := ")
-		case TokenBangEquals:
-			out.WriteString(" != ")
-		case TokenEquals:
-			out.WriteString(" == ")
-		case TokenGreaterThan:
-			out.WriteString(" > ")
-		case TokenLessThan:
-			out.WriteString(" < ")
-		case TokenGreaterThanOrEqual:
-			out.WriteString(" >= ")
-		case TokenLessThanOrEqual:
-			out.WriteString(" <= ")
-		case TokenDoubleAmpersand:
-			out.WriteString(" && ")
-		case TokenDoublePipe:
-			out.WriteString(" || ")
-		case TokenBreakpoint:
-			out.WriteString("breakpoint")
-		case TokenEOF:
-			out.WriteString(fmt.Sprintf("<error: \"%s\">", token.Lexeme))
-		case TokenHexadecimal:
-			out.WriteString(token.Lexeme)
-		case TokenPipe:
-			out.WriteString(" | ")
-		case TokenError:
-		}
-	}
-
-	return out.String()
-}
-
 func TestParser_Parse(t *testing.T) {
 	t.Logf("Getting test data")
 	tokenData := GetTokenTestData()

core/values_test.go

@@ -96,6 +96,19 @@ func CompareValues(t *testing.T, got Value, want Value) {
 			CompareValues(t, v, m.Members[k])
 		}
 
+	case TupleValueType:
+		n := got.(*TupleValue)
+		m := want.(*TupleValue)
+
+		if len(n.Items) != len(m.Items) {
+			t.Fatalf("tuple item count mismatch: got %d items, want %d items", len(n.Items), len(m.Items))
+		}
+
+		for i, v := range n.Items {
+			t.Logf("comparing tuple item #%d", i)
+			CompareValues(t, v, m.Items[i])
+		}
+
 	default:
 		panic("unimplemented comparison")
 	}

core/vm_test.go

@@ -2,6 +2,7 @@ package core
 
 import (
 	"fmt"
+	"math/big"
 	"testing"
 )
 
@@ -615,6 +616,28 @@ func GetExecutionTestData() map[string]struct {
 			},
 			[]map[string]Value{},
 		},
+		"form_tuple": {
+			&Chunk{
+				Bytecode: []Bytecode{
+					InstructionConstant, 0,
+					InstructionConstant, 1,
+					InstructionFormTuple, 0, 2,
+				},
+				Constants: []Value{
+					&IntegerValue{big.NewInt(1)},
+					&IntegerValue{big.NewInt(2)},
+				},
+			},
+			[]Value{
+				&TupleValue{
+					Items: []Value{
+						&IntegerValue{big.NewInt(1)},
+						&IntegerValue{big.NewInt(2)},
+					},
+				},
+			},
+			[]map[string]Value{},
+		},
 	}
 }