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,108 +1,105 @@
 package reader
 
 import (
-	// "maze-solver/maze"
+	"maze-solver/utils"
-	// "maze-solver/utils"
+	"reflect"
-	// "reflect"
 	"testing"
 )
 
 func TestTextReadTrivial(t *testing.T) {
-	/*
+	tests := []struct {
-		tests := []struct {
+		name     string
-			name     string
+		filename string
-			filename string
+		pathChar byte
-			pathChar byte
+		wallChar byte
-			wallChar byte
+		expected *RawMaze
-			expected *maze.RawMaze
+	}{
-		}{
+		{
-			{
+			"Trivial",
-				"Trivial",
+			"../../assets/trivial.txt",
-				"../../assets/trivial.txt",
+			' ',
-				' ',
+			'#',
-				'#',
+			&RawMaze{
-				&maze.RawMaze{
+				Width:  5,
-					PathChar: ' ',
+				Height: 3,
-					WallChar: '#',
+				Data: [][]byte{
-					Data: []string{
+					{0b_00100_000},
-						"## ##",
+					{0b_01110_000},
-						"#   #",
+					{0b_00010_000},
-						"### #",
-					},
 				},
 			},
-			{
+		},
-				"Trivial Bigger",
+		{
-				"../../assets/trivial-bigger.txt",
+			"Trivial Bigger",
-				' ',
+			"../../assets/trivial-bigger.txt",
-				'#',
+			' ',
-				&maze.RawMaze{
+			'#',
-					PathChar: ' ',
+			&RawMaze{
-					WallChar: '#',
+				Width:  7,
-					Data: []string{
+				Height: 5,
-						"### ###",
+				Data: [][]byte{
-						"### ###",
+					{0b_0001000_0},
-						"#     #",
+					{0b_0001000_0},
-						"##### #",
+					{0b_0111110_0},
-						"##### #",
+					{0b_0000010_0},
-					},
+					{0b_0000010_0},
 				},
 			},
-			{
+		},
-				"Bigger Staggered",
+		{
-				"../../assets/trivial-bigger-staggered.txt",
+			"Bigger Staggered",
-				' ',
+			"../../assets/trivial-bigger-staggered.txt",
-				'#',
+			' ',
-				&maze.RawMaze{
+			'#',
-					PathChar: ' ',
+			&RawMaze{
-					WallChar: '#',
+				Width:  7,
-					Data: []string{
+				Height: 5,
-						"### ###",
+				Data: [][]byte{
-						"### ###",
+					{0b_0001000_0},
-						"#     #",
+					{0b_0001000_0},
-						"#### ##",
+					{0b_0111110_0},
-						"#### ##",
+					{0b_0000100_0},
-					},
+					{0b_0000100_0},
 				},
 			},
-			{
+		},
-				"Normal",
+		{
-				"../../assets/normal.txt",
+			"Normal",
-				' ',
+			"../../assets/normal.txt",
-				'#',
+			' ',
-				&maze.RawMaze{
+			'#',
-					PathChar: ' ',
+			&RawMaze{
-					WallChar: '#',
+				Width:  11,
-					Data: []string{
+				Height: 11,
-						"##### #####",
+				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},
 				},
 			},
+		},
+	}
+
+	for _, test := range tests {
+		reader := TextReader{
+			Filename: test.filename,
+			PathChar: test.pathChar,
+			WallChar: test.wallChar,
 		}
 
-		for _, test := range tests {
+		got, err := reader.Read()
-			reader := TextReader{
+		utils.Check(err, "Couldn't read file %q", reader.Filename)
-				Filename: test.filename,
-				PathChar: test.pathChar,
-				WallChar: test.wallChar,
-			}
 
-			got, err := reader.Read()
+		if !reflect.DeepEqual(got, test.expected) {
-			utils.Check(err, "Couldn't read file %q", reader.Filename)
+			t.Fatalf("%s: lexed mazes do not match\nGot: %v\nWant: %v", test.name, got, test.expected)
-
-			if !reflect.DeepEqual(got, test.expected) {
-				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...)
+	}
+}