rework using table tests

.tool-versions

@@ -1,2 +1 @@
-golang        1.20.2
 golangci-lint 1.51.2

lib.go

@@ -7,6 +7,8 @@ import (
 	"strconv"
 )
 
+// CheckGuess checks the guess against the random value and returns a status message alongside
+// a win boolean.
 func CheckGuess(guess, random int) (string, bool) {
 	if guess == random {
 		return "Good job!", true

lib_test.go

@@ -19,69 +19,59 @@ Then, the app prompts the player again, etc.
 */
 
 func TestCheckGuess(t *testing.T) {
-	t.Run("guess is lower than random", func(t *testing.T) {
+	tests := []struct {
-		random := 63
+		name       string
-		guess := 50
+		random     int
-		wantStatus := "Try higher."
+		guess      int
-
+		wantStatus string
-		assertCheckGuess(t, guess, random, wantStatus, false)
+	}{
-	})
+		{"guess is lower than random", 50, 34, "Try higher."},
-	t.Run("guess is higher than random", func(t *testing.T) {
+		{"guess is higher than random", 50, 63, "Nope, lower."},
-		random := 34
+		{"guess is equal to random", 50, 50, "Good job!"},
-		guess := 50
-		wantStatus := "Nope, lower."
-
-		assertCheckGuess(t, guess, random, wantStatus, false)
-	})
-	t.Run("guess is equal to random", func(t *testing.T) {
-		random := 50
-		guess := 50
-		wantStatus := "Good job!"
-
-		assertCheckGuess(t, guess, random, wantStatus, true)
-	})
 	}
-
+	for _, tt := range tests {
-func assertCheckGuess(t testing.TB, guess, random int, wantStatus string, wantWon bool) {
+		t.Run(tt.name, func(t *testing.T) {
-	t.Helper()
+			status, won := CheckGuess(tt.guess, tt.random)
-	status, won := CheckGuess(guess, random)
+			if status != tt.wantStatus {
-	if status != wantStatus {
+				t.Errorf("got %q want %q", status, tt.wantStatus)
-		t.Errorf("got %q want %q", status, wantStatus)
 			}
-	if won != wantWon {
+			if tt.guess == tt.random && !won {
-		t.Errorf("got %v want %v", won, wantWon)
+				t.Error("want won")
+			}
+		})
 	}
 }
 
 func TestLoopUntilFound(t *testing.T) {
-	t.Run("found on first try", func(t *testing.T) {
+	tests := []struct {
-		inputs := []int{37}
+		name   string
-		random := 37
+		inputs []int
-		want := []string{
+		random int
-			"your guess: ",
+		want   []string
-			"Good job!",
+	}{
-			"You got it right in 1 try.",
+		{
-		}
+			"found on first try",
-
+			[]int{37},
-		assertLoopUntilFound(t, inputs, random, want)
+			37,
-	})
+			[]string{"your guess: ", "Good job!", "You got it right in 1 try."},
-	t.Run("found on second try", func(t *testing.T) {
+		},
-		inputs := []int{50, 37}
+		{
-		random := 37
+			"found on second try",
-		want := []string{
+			[]int{50, 37},
+			37,
+			[]string{
 				"your guess: ",
 				"Nope, lower.",
 				"your guess: ",
 				"Good job!",
 				"You got it right in 2 tries.",
-		}
+			},
-
+		},
-		assertLoopUntilFound(t, inputs, random, want)
+		{
-	})
+			"found after many tries",
-	t.Run("found after many tries", func(t *testing.T) {
+			[]int{50, 25, 32, 37},
-		inputs := []int{50, 25, 32, 37}
+			37,
-		random := 37
+			[]string{
-		want := []string{
 				"your guess: ",
 				"Nope, lower.",
 				"your guess: ",
@@ -91,30 +81,29 @@ func TestLoopUntilFound(t *testing.T) {
 				"your guess: ",
 				"Good job!",
 				"You got it right in 4 tries.",
+			},
+		},
 	}
 
-		assertLoopUntilFound(t, inputs, random, want)
+	for _, tt := range tests {
-	})
+		t.Run(tt.name, func(t *testing.T) {
-}
+			inputs := convertIntInputsToStrings(tt.inputs)
-
-func assertLoopUntilFound(t testing.TB, intInputs []int, random int, outputs []string) {
-	t.Helper()
-
-	inputs := convertIntInputsToStrings(intInputs)
 			inputs = append(inputs, "")
 			inputBuffer := strings.NewReader(strings.Join(inputs, "\n"))
 
-	outputs = append(outputs, "")
+			wants := append(tt.want, "")
-	want := strings.Join(outputs, "\n")
+			want := strings.Join(wants, "\n")
 
 			outputBuffer := bytes.Buffer{}
 
-	LoopUntilFound(&outputBuffer, inputBuffer, random)
+			LoopUntilFound(&outputBuffer, inputBuffer, tt.random)
 
 			got := outputBuffer.String()
 			if got != want {
 				t.Errorf("got %q want %q", got, want)
 			}
+		})
+	}
 }
 
 func convertIntInputsToStrings(inputs []int) []string {