Forgot to put the width and height of the maze

when I parsed it, oops (and now it's tested)

io/reader/strings_test.go

@@ -1,6 +1,7 @@
 package reader
 
 import (
+	"maze-solver/utils"
 	"testing"
 )
 
@@ -111,13 +112,13 @@ func TestStringsReader(t *testing.T) {
 		}
 		got, _ := reader.Read()
 
-		assertEqual(t, got.Width, test.width, "%s: width of raw maze don't match", test.name)
+		utils.AssertEqual(t, got.Width, test.width, "%s: width of raw maze don't match", test.name)
-		assertEqual(t, got.Height, test.height, "%s: height of raw maze don't match", test.name)
+		utils.AssertEqual(t, got.Height, test.height, "%s: height of raw maze don't match", test.name)
-		assertEqual(t, len(got.Data), len(test.expected), "%s: don't have the same number of rows", test.name)
+		utils.AssertEqual(t, len(got.Data), len(test.expected), "%s: don't have the same number of rows", test.name)
 
 		for y, line_exp := range test.expected {
 			line_got := got.Data[y]
-			assertEqual(t, len(line_got), len(line_exp), "%s (line %v): don't have same number of chunks, %v, want %v", test.name, y)
+			utils.AssertEqual(t, len(line_got), len(line_exp), "%s (line %v): don't have same number of chunks, %v, want %v", test.name, y)
 
 			for i, chunk_exp := range line_exp {
 				chunk_got := line_got[i]
@@ -128,10 +129,3 @@ func TestStringsReader(t *testing.T) {
 		}
 	}
 }
-
-func assertEqual[T comparable](t *testing.T, got T, want T, msg string, args ...any) {
-	args = append(args, got, want)
-	if got != want {
-		t.Fatalf(msg+"\nGot: %v, Want: %v", args...)
-	}
-}

io/reader/text_test.go

@@ -1,33 +1,31 @@
 package reader
 
 import (
-	// "maze-solver/maze"
+	"maze-solver/utils"
-	// "maze-solver/utils"
+	"reflect"
-	// "reflect"
 	"testing"
 )
 
 func TestTextReadTrivial(t *testing.T) {
-	/*
 	tests := []struct {
 		name     string
 		filename string
 		pathChar byte
 		wallChar byte
-			expected *maze.RawMaze
+		expected *RawMaze
 	}{
 		{
 			"Trivial",
 			"../../assets/trivial.txt",
 			' ',
 			'#',
-				&maze.RawMaze{
+			&RawMaze{
-					PathChar: ' ',
+				Width:  5,
-					WallChar: '#',
+				Height: 3,
-					Data: []string{
+				Data: [][]byte{
-						"## ##",
+					{0b_00100_000},
-						"#   #",
+					{0b_01110_000},
-						"### #",
+					{0b_00010_000},
 				},
 			},
 		},
@@ -36,15 +34,15 @@ func TestTextReadTrivial(t *testing.T) {
 			"../../assets/trivial-bigger.txt",
 			' ',
 			'#',
-				&maze.RawMaze{
+			&RawMaze{
-					PathChar: ' ',
+				Width:  7,
-					WallChar: '#',
+				Height: 5,
-					Data: []string{
+				Data: [][]byte{
-						"### ###",
+					{0b_0001000_0},
-						"### ###",
+					{0b_0001000_0},
-						"#     #",
+					{0b_0111110_0},
-						"##### #",
+					{0b_0000010_0},
-						"##### #",
+					{0b_0000010_0},
 				},
 			},
 		},
@@ -53,15 +51,15 @@ func TestTextReadTrivial(t *testing.T) {
 			"../../assets/trivial-bigger-staggered.txt",
 			' ',
 			'#',
-				&maze.RawMaze{
+			&RawMaze{
-					PathChar: ' ',
+				Width:  7,
-					WallChar: '#',
+				Height: 5,
-					Data: []string{
+				Data: [][]byte{
-						"### ###",
+					{0b_0001000_0},
-						"### ###",
+					{0b_0001000_0},
-						"#     #",
+					{0b_0111110_0},
-						"#### ##",
+					{0b_0000100_0},
-						"#### ##",
+					{0b_0000100_0},
 				},
 			},
 		},
@@ -70,21 +68,21 @@ func TestTextReadTrivial(t *testing.T) {
 			"../../assets/normal.txt",
 			' ',
 			'#',
-				&maze.RawMaze{
+			&RawMaze{
-					PathChar: ' ',
+				Width:  11,
-					WallChar: '#',
+				Height: 11,
-					Data: []string{
+				Data: [][]byte{
-						"##### #####",
+					{0b_00000100, 0b000_00000},
-						"#     #   #",
+					{0b_01111101, 0b110_00000},
-						"##### ### #",
+					{0b_00000100, 0b010_00000},
-						"#   #     #",
+					{0b_01110111, 0b110_00000},
-						"# # ##### #",
+					{0b_01010000, 0b010_00000},
-						"# #       #",
+					{0b_01011111, 0b110_00000},
-						"### ### # #",
+					{0b_00010001, 0b010_00000},
-						"#   #   # #",
+					{0b_01110111, 0b010_00000},
-						"# ####### #",
+					{0b_01000000, 0b010_00000},
-						"#     #   #",
+					{0b_01111101, 0b110_00000},
-						"##### #####",
+					{0b_00000100, 0b000_00000},
 				},
 			},
 		},
@@ -104,5 +102,4 @@ func TestTextReadTrivial(t *testing.T) {
 			t.Fatalf("%s: lexed mazes do not match\nGot: %v\nWant: %v", test.name, got, test.expected)
 		}
 	}
-	*/
 }

maze/maze.go

@@ -20,7 +20,7 @@ func NewNode(coords Coordinates) *Node {
 }
 
 type Maze struct {
-	Width, Height uint
+	Width, Height int
 	Nodes         []*Node
 }
 

maze/parser/parser.go

@@ -8,13 +8,18 @@ import (
 
 func Parse(reader reader.Reader) (*maze.Maze, error) {
 	nodesByCoord := make(map[maze.Coordinates]*maze.Node)
-	ret := &maze.Maze{}
 
 	raw_maze, err := reader.Read()
 	if err != nil {
 		return nil, err
 	}
 
+	ret := &maze.Maze{
+		Width:  raw_maze.Width,
+		Height: raw_maze.Height,
+		Nodes:  []*maze.Node{},
+	}
+
 	y := 0
 	// Parse first line to get entrance
 	for x := 0; x < raw_maze.Width-1; x++ {

maze/parser/parser_test.go

@@ -51,6 +51,9 @@ func TestTextReadTrivial(t *testing.T) {
 	got, err := Parse(reader)
 	utils.Check(err, "Couldn't create maze from %q", reader.Filename)
 
+	utils.AssertEqual(t, got.Width, 5, "Normal: width differ")
+	utils.AssertEqual(t, got.Height, 3, "Normal: height differ")
+
 	if len(nodes) != len(got.Nodes) {
 		t.Fatalf("Didn't get the same size of nodes: %v, want %v", len(got.Nodes), len(nodes))
 	}
@@ -113,6 +116,9 @@ func TestTextReadTrivialBigger(t *testing.T) {
 	got, err := Parse(reader)
 	utils.Check(err, "Couldn't create maze from %q", reader.Filename)
 
+	utils.AssertEqual(t, got.Width, 7, "Normal: width differ")
+	utils.AssertEqual(t, got.Height, 5, "Normal: height differ")
+
 	if len(nodes) != len(got.Nodes) {
 		t.Fatalf("Didn't get the same size of nodes: %v, want %v", len(got.Nodes), len(nodes))
 	}
@@ -180,6 +186,9 @@ func TestTextReadTrivialBiggerStaggered(t *testing.T) {
 	got, err := Parse(reader)
 	utils.Check(err, "Couldn't create maze from %q", reader.Filename)
 
+	utils.AssertEqual(t, got.Width, 7, "Normal: width differ")
+	utils.AssertEqual(t, got.Height, 5, "Normal: height differ")
+
 	if len(nodes) != len(got.Nodes) {
 		t.Fatalf("Didn't get the same size of nodes: %v, want %v", len(got.Nodes), len(nodes))
 	}
@@ -334,6 +343,9 @@ func TestTextReadNormal(t *testing.T) {
 	got, err := Parse(reader)
 	utils.Check(err, "Couldn't create maze from %q", reader.Filename)
 
+	utils.AssertEqual(t, got.Width, 11, "Normal: width differ")
+	utils.AssertEqual(t, got.Height, 11, "Normal: height differ")
+
 	if len(nodes) != len(got.Nodes) {
 		for i, node := range got.Nodes {
 			fmt.Printf("%v: %v\n", i, node)

utils/utils.go

@@ -2,6 +2,7 @@ package utils
 
 import (
 	"log"
+	"testing"
 
 	"golang.org/x/exp/constraints"
 )
@@ -19,3 +20,10 @@ func Min[T constraints.Ordered](a, b T) T {
 	}
 	return b
 }
+
+func AssertEqual[T comparable](t *testing.T, got T, want T, msg string, args ...any) {
+	args = append(args, got, want)
+	if got != want {
+		t.Fatalf(msg+"\nGot: %v, Want: %v", args...)
+	}
+}