// testNoSeedsCantReach is a simulateTestCaseGenerator which generates a test // case where the other mancala.Player has no seeds and the current // mancala.Player doesn't have a move which will give the other mancala.Player // seeds. func testNoSeedsCantReach(player mancala.PlayerIndex) simulateTestCase { grid := mancala.Grid{} grid[player] = mancala.Row{0, 0, 1, 1, 0, 0} board := mancala.NewInitializedBoard(0, 0, grid) player1Score := 0 player2Score := 0 if player == mancala.Player1 { player1Score += 2 } else { player2Score += 2 } advancedBoard := mancala.NewInitializedBoard( player1Score, player2Score, mancala.Grid{}, ) return simulateTestCase{ referee: mancala.NewInitializedReferee( []mancala.Board{}, board, ), move: 2, expectedBoard: advancedBoard, expectedErr: nil, } }
// testCaptureLoop is a simulateTestCaseGenerator which generates a test case // where the current mancala.Player captures after looping around the // mancala.Board. func testCaptureLoop(player mancala.PlayerIndex) simulateTestCase { grid := mancala.Grid{} grid[player] = mancala.Row{17, 0, 0, 0, 0, 0} grid[player.Other()] = mancala.Row{} board := mancala.NewInitializedBoard(0, 0, grid) expectedGrid := mancala.Grid{} expectedGrid[player] = mancala.Row{0, 2, 2, 2, 2, 2} expectedGrid[player.Other()] = mancala.Row{0, 1, 1, 1, 1, 1} player1Score := 0 player2Score := 0 if player == mancala.Player1 { player1Score += 2 } else { player2Score += 2 } expectedBoard := mancala.NewInitializedBoard( player1Score, player2Score, expectedGrid, ) return simulateTestCase{ referee: mancala.NewInitializedReferee( []mancala.Board{}, board, ), move: 0, expectedBoard: expectedBoard, expectedErr: nil, } }
// testAlreadySeenBoard is a simulateTestCaseGenerator which generates a test // case where the current mancala.Board is in the mancala.Referee's // mancala.Board history. func testAlreadySeenBoard(player mancala.PlayerIndex) simulateTestCase { seenGrid := mancala.Grid{} seenGrid[player] = mancala.Row{0, 1, 1, 1, 1, 1} seenGrid[player.Other()] = mancala.Row{1, 0, 0, 0, 0, 0} grid := mancala.Grid{} grid[player] = mancala.Row{5, 0, 0, 0, 0, 0} grid[player.Other()] = mancala.Row{1, 0, 0, 0, 0, 0} referee := mancala.NewInitializedReferee( []mancala.Board{mancala.NewInitializedBoard(0, 0, seenGrid)}, mancala.NewInitializedBoard(0, 0, grid), ) player1Score := 0 player2Score := 0 if player == mancala.Player1 { player1Score += 5 player2Score++ } else { player2Score += 5 player1Score++ } expectedBoard := mancala.NewInitializedBoard( player1Score, player2Score, mancala.Grid{}, ) return simulateTestCase{ referee: referee, move: 0, expectedBoard: expectedBoard, expectedErr: nil, } }
// NewState creates a State with the given parent State and Information. func NewState(parent *State, information Information) *State { parentBoardHistory := parent.referee.BoardHistory() referee := mancala.NewInitializedReferee( parentBoardHistory, information.Board(), ) return &State{ parent: parent, referee: referee, information: information, } }
// TestRefereeBoardHistory tests that mancala.Referee::BoardHistory returns the // mancala.Referee's mancala.Board history. func TestRefereeBoardHistory(t *testing.T) { t.Parallel() actual := mancala.NewInitializedReferee( []mancala.Board{mancala.NewBoard()}, mancala.NewBoard(), ).BoardHistory() expected := []mancala.Board{mancala.NewBoard()} if !reflect.DeepEqual(actual, expected) { t.Errorf( "referee.BoardHistory() = %v, want %v", actual, expected, ) } }
// testCaptureAllHouses is a simulateTestCaseGenerator which generates a test // case where the current mancala.Player captures all of the other // mancala.Player's houses from the end of the other mancala.Player's row to the // beginning. func testCaptureAllHouses(player mancala.PlayerIndex) simulateTestCase { grid := mancala.Grid{} grid[player] = mancala.Row{0, 0, 0, 0, 0, 6} grid[player.Other()] = mancala.Row{1, 1, 1, 1, 1, 1} board := mancala.NewInitializedBoard(0, 0, grid) expectedGrid := mancala.Grid{} expectedGrid[player] = mancala.Row{} expectedGrid[player.Other()] = mancala.Row{2, 2, 2, 2, 2, 2} expectedBoard := mancala.NewInitializedBoard(0, 0, expectedGrid) return simulateTestCase{ referee: mancala.NewInitializedReferee( []mancala.Board{}, board, ), move: 5, expectedBoard: expectedBoard, expectedErr: nil, } }
// testSowLoopToStart is a simulateTestCaseGenerator which generates a test case // where the current mancala.Player sows in a loop around the mancala.Board just // past the house the mancala.Player started sowing from. func testSowLoopToStart(player mancala.PlayerIndex) simulateTestCase { grid := mancala.Grid{} grid[player] = mancala.Row{0, 0, 0, 0, 0, 45} grid[player.Other()] = mancala.Row{} board := mancala.NewInitializedBoard(0, 0, grid) expectedGrid := mancala.Grid{} expectedGrid[player] = mancala.Row{4, 4, 4, 4, 4, 0} expectedGrid[player.Other()] = mancala.Row{5, 4, 4, 4, 4, 4} expectedBoard := mancala.NewInitializedBoard(0, 0, expectedGrid) return simulateTestCase{ referee: mancala.NewInitializedReferee( []mancala.Board{}, board, ), move: 5, expectedBoard: expectedBoard, expectedErr: nil, } }
// testSowToOtherSide is a simulateTestCaseGenerator which generates a test case // where the current mancala.Player sows to the middle of the other // mancala.Player's mancala.Row. func testSowToOtherSide(player mancala.PlayerIndex) simulateTestCase { grid := mancala.Grid{} grid[player] = mancala.Row{0, 0, 6, 0, 0, 0} grid[player.Other()] = mancala.Row{} board := mancala.NewInitializedBoard(0, 0, grid) expectedGrid := mancala.Grid{} expectedGrid[player] = mancala.Row{0, 0, 0, 1, 1, 1} expectedGrid[player.Other()] = mancala.Row{1, 1, 1, 0, 0, 0} expectedBoard := mancala.NewInitializedBoard(0, 0, expectedGrid) return simulateTestCase{ referee: mancala.NewInitializedReferee( []mancala.Board{}, board, ), move: 2, expectedBoard: expectedBoard, expectedErr: nil, } }
// testNoSeeds is a simulateTestCaseGenerator which generates a test case where // the other mancala.Player has no seeds and the current mancala.Player has a // move which will give the other mancala.Player seeds and doesn't make it. func testNoSeedsCanReach(player mancala.PlayerIndex) simulateTestCase { grid := mancala.Grid{} grid[player] = mancala.Row{1, 0, 0, 0, 0, 1} board := mancala.NewInitializedBoard(0, 0, grid) return simulateTestCase{ referee: mancala.NewInitializedReferee( []mancala.Board{}, board, ), move: 0, expectedBoard: board, expectedErr: fmt.Errorf( "moves exist which can give %v seeds but move at %d "+ "doesn't", player.Other(), 0, ), } }
// testNoSeeds is a simulateTestCaseGenerator which generates a test case where // the current mancala.Player tries to sow from a house with no seeds. func testNoSeeds(player mancala.PlayerIndex) simulateTestCase { return simulateTestCase{ referee: mancala.NewInitializedReferee( []mancala.Board{}, mancala.Board{}, ), move: 0, expectedBoard: mancala.NewInitializedBoard( 0, 0, mancala.Grid{}, ), expectedErr: fmt.Errorf( "house at board.RowFor(%v)[%d] has 0 seeds", player, 0, ), } }
// TestFinishInitializedGame tests that mancala.FinishInitializedGame returns // the correct mancala.Result from an already in progress mancala.Game described // by a shortPlayer. func TestFinishInitializedGame(t *testing.T) { t.Parallel() turnOffSet := 10 player1 := newShortPlayer(mancala.Player1 + turnOffSet) player2 := newShortPlayer(mancala.Player2 + turnOffSet) referee := mancala.NewInitializedReferee( []mancala.Board{}, mancala.NewInitializedBoard( 2, 15, mancala.Grid{ mancala.Row{0, 2, 1, 1, 1, 1}, mancala.Row{1, 10, 4, 0, 1, 9}, }, ), ) actual := mancala.FinishInitializedGame( referee, player1, player2, mancala.Player2, turnOffSet+1, ) expected := mancala.NewResult( player1.expectedBoard(), player1.expectedWinner(), player1.expectedMoveCount(), player1.expectedLastMove(), nil, ) if actual != expected { t.Errorf( "FinishInitializedGame(\n\t%v,\n\t%v,\n\t%v,\n\t%v,\n)"+ " = \n%v, want \n%v", referee, player1, player2, mancala.Player2, actual, expected, ) } }
// TestGameIsOver tests that mancala.Game::IsOver returns whether or not a // mancala.Game is over for the possible ways an Oware game can end. func TestGameIsOver(t *testing.T) { t.Parallel() actual := mancala.NewGame(errPlayer{}, errPlayer{}).IsOver() expected := false if actual != expected { t.Errorf( "game.IsOver() = %v, want %v with no win", actual, expected, ) } actual = mancala.NewInitializedGame( mancala.NewInitializedReferee( []mancala.Board{}, mancala.NewInitializedBoard( (mancala.DefaultSeedCount/2)+1, (mancala.DefaultSeedCount/2)-1, mancala.Grid{}, ), ), errPlayer{}, errPlayer{}, mancala.Player1, 0, ).IsOver() expected = true if actual != expected { t.Errorf( "game.IsOver() = %v, want %v with player 1 win", actual, expected, ) } actual = mancala.NewInitializedGame( mancala.NewInitializedReferee( []mancala.Board{}, mancala.NewInitializedBoard( (mancala.DefaultSeedCount/2)-1, (mancala.DefaultSeedCount/2)+1, mancala.Grid{}, ), ), errPlayer{}, errPlayer{}, mancala.Player2, 0, ).IsOver() expected = true if actual != expected { t.Errorf( "game.IsOver() = %v, want %v with player 2 win", actual, expected, ) } actual = mancala.NewInitializedGame( mancala.NewInitializedReferee( []mancala.Board{}, mancala.NewInitializedBoard( mancala.DefaultSeedCount/2, mancala.DefaultSeedCount/2, mancala.Grid{}, ), ), errPlayer{}, errPlayer{}, -1, 0, ).IsOver() expected = true if actual != expected { t.Errorf( "game.IsOver() = %v, want %v with tie", actual, expected, ) } errGame := mancala.NewGame(errPlayer{}, errPlayer{}) errGame.PlayMove() actual = errGame.IsOver() expected = true if actual != expected { t.Errorf( "game.IsOver() = %v, want %v with error", actual, expected, ) } }