fix: hash.keys() sometime fail test because map[string]interface{} do…

…n't maintain position of their keys

evaluator/hash_test.go

@@ -1,6 +1,7 @@
 package evaluator
 
 import (
+	"fmt"
 	"ninja/object"
 	"testing"
 )
@@ -227,10 +228,6 @@ func TestHashMethod(t *testing.T) {
 			`{}.keys()`,
 			object.Array{Elements: []object.Object{}},
 		},
-		{
-			`{"a": 1, "b": true}.keys()`,
-			object.Array{Elements: []object.Object{&object.String{Value: "a"}, &object.String{Value: "b"}}},
-		},
 		{
 			`{}.has("a")`,
 			false,
@@ -245,10 +242,51 @@ func TestHashMethod(t *testing.T) {
 		},
 	}
 
-	for _, tt := range tests {
-		evaluated := testEval(tt.input, t)
+	for i, tt := range tests {
+		t.Run(fmt.Sprintf("TestHashMethod_%d", i), func(t *testing.T) {
+			evaluated := testEval(tt.input, t)
 
-		testObjectLiteral(t, evaluated, tt.expected)
+			testObjectLiteral(t, evaluated, tt.expected)
+		})
+	}
+}
+
+func TestHashHasKeyMethod(t *testing.T) {
+	input := `{"a": 1, "b": true}.keys()`
+	slicesContain := []string{"a", "b"}
+
+	contain := func(slice []string, input string) bool {
+		for _, v := range slice {
+			if v == input {
+				return true
+			}
+		}
+		return false
+	}
+
+	evaluated := testEval(input, t)
+
+	arr, ok := evaluated.(*object.Array)
+	if !ok {
+		t.Fatalf("expect to be an array. Got: %T", evaluated)
+	}
+
+	stringPos1, ok := arr.Elements[0].(*object.String)
+	if !ok {
+		t.Fatalf("expect index 0 be a string. Got: %T", evaluated)
+	}
+
+	stringPos2, ok := arr.Elements[0].(*object.String)
+	if !ok {
+		t.Fatalf("expect index 0 be a string. Got: %T", evaluated)
+	}
+
+	if !contain(slicesContain, stringPos1.Value) {
+		t.Fatalf("hash.keys() don't contain %v. Got: %v", slicesContain, stringPos1)
+	}
+
+	if !contain(slicesContain, stringPos2.Value) {
+		t.Fatalf("hash.keys() don't contain %v. Got: %v", slicesContain, stringPos2)
 	}
 }
 

lexer/lexer.go

@@ -26,30 +26,6 @@ func New(in io.Reader) *Lexer {
 	return l
 }
 
-func (l *Lexer) readChar() {
-
-	if l.readPosition >= len(l.input) {
-		l.ch = 0
-	} else {
-		l.ch = l.input[l.readPosition]
-	}
-
-	l.position = l.readPosition
-	l.readPosition += 1
-
-	l.keepTrackLineAndCharPosition()
-
-}
-
-func (l *Lexer) keepTrackLineAndCharPosition() {
-	if l.ch == '\n' {
-		l.lineNumber += 1
-		l.characterPositionInLine = 0
-	} else {
-		l.characterPositionInLine += 1
-	}
-}
-
 func (l *Lexer) NextToken() token.Token {
 	var tok token.Token
 	l.skipWhitespace()
@@ -165,6 +141,31 @@ func (l *Lexer) NextToken() token.Token {
 	return tok
 }
 
+func (l *Lexer) readChar() {
+
+	if l.readPosition >= len(l.input) {
+		l.ch = 0
+	} else {
+		l.ch = l.input[l.readPosition]
+	}
+
+	l.position = l.readPosition
+	l.readPosition += 1
+
+	l.keepTrackLineAndCharPosition()
+}
+
+// keepTrackLineAndCharPosition is a method which keep tracking where position of
+// pointer of lexer is point at.
+func (l *Lexer) keepTrackLineAndCharPosition() {
+	if l.ch == '\n' {
+		l.lineNumber += 1
+		l.characterPositionInLine = 0
+	} else {
+		l.characterPositionInLine += 1
+	}
+}
+
 func (l *Lexer) newToken(tokenType token.TokenType, ch []byte) token.Token {
 	location := token.Location{Line: l.lineNumber + 1, Offset: l.characterPositionInLine}
 	return token.Token{Type: tokenType, Literal: ch, Location: location}

object/hash.go

@@ -53,9 +53,11 @@ func hashKeys(keys map[HashKey]HashPair, args ...Object) Object {
 	if len(args) != 0 {
 		return NewErrorFormat("hash.keys() expect 0 arguments. Got: %s", InspectArguments(args...))
 	}
-	elements := []Object{}
+	elements := make([]Object, len(keys))
+	i := 0
 	for _, pair := range keys {
-		elements = append(elements, pair.Key)
+		elements[i] = pair.Key
+		i++
 	}
 
 	return &Array{Elements: elements}