def generate_first_move( self, tiles: List[Tile], board_state: BoardState ) -> Result[Tuple[BoardPosition, Tile, PortID]]: if self.first: if self.crash: raise Exception("Crash!") else: return error("Error!") return FirstS().generate_first_move(tiles, board_state)
def test_referee_crashing_player() -> None: cp_exception_init = CrashingPlayer(True, True) cp_error_init = CrashingPlayer(False, True) cp_exception_inter = CrashingPlayer(True, False) cp_error_inter = CrashingPlayer(False, False) p = Player(FirstS()) ref = make_ref() assert ref.set_players([ cp_error_init, cp_exception_init, cp_error_inter, cp_exception_inter, p ]).assert_value() == ["white", "black", "red", "green", "blue"] ref.set_tile_iterator(deterministic_tile_iterator()) r = ref.run_game() assert r.is_ok() assert r.value() == ([{"blue"}], {"green", "red", "black", "white"})
def test_set_players_error() -> None: ref = make_ref() r = ref.set_players([]) assert r.is_error() assert r.error() == "there must be between 3 and 5 players, not 0." r = ref.set_players([Player(FirstS())] * 6) assert r.is_error() assert r.error() == "there must be between 3 and 5 players, not 6." r = ref.set_players([Player(FirstS())] * 4) assert r.is_error() assert ( r.error() == "the given set of players contains duplicates (or players that do not implement __hash__, __eq__)" ) r = ref.set_players([Player(FirstS()), Player(FirstS()), Player(FirstS())]) assert r.is_ok() assert r.value() == ["white", "black", "red"] r = ref.set_players([Player(FirstS()), Player(FirstS()), Player(FirstS())]) assert r.is_error() assert r.error() == "players have already been set for this game."
def test_player_calls_observers() -> None: bs = BoardState() lo = LoggingPlayerObserver() p = Player(FirstS()) p.add_observer(lo) p.set_color("red") assert lo.set_colors == ["red"] p.set_color("green") assert lo.set_colors == ["red", "green"] assert p.generate_first_move( [index_to_tile(3), index_to_tile(4), index_to_tile(5)], bs).is_ok() assert lo.initial_move_offereds == [ ([index_to_tile(3), index_to_tile(4), index_to_tile(5)], bs) ] assert lo.initial_move_playeds == [( [index_to_tile(3), index_to_tile(4), index_to_tile(5)], bs, InitialMove(BoardPosition(1, 0), index_to_tile(5), Port.RightTop, "green"), )] assert p.generate_move([index_to_tile(10), index_to_tile(11)], bs).is_ok() assert lo.intermediate_move_offereds == [ ([index_to_tile(10), index_to_tile(11)], bs) ] assert lo.intermediate_move_playeds == [( [index_to_tile(10), index_to_tile(11)], bs, IntermediateMove(index_to_tile(10), "green"), )] gr = ([{"red"}, {"black", "green"}], {"white"}) p.game_result(gr) # type: ignore assert lo.game_results == [gr]
def test_admin_crashing_player() -> None: admin = Administrator(SimpleBracketStrategy()) cp_exception_init = CrashingPlayer(True, True) assert admin.add_player(cp_exception_init).is_ok() cp_error_init = CrashingPlayer(False, True) assert admin.add_player(cp_error_init).is_ok() cp_exception_inter = CrashingPlayer(True, False) assert admin.add_player(cp_exception_inter).is_ok() cp_error_inter = CrashingPlayer(False, False) assert admin.add_player(cp_error_inter).is_ok() p = Player(FirstS()) r = admin.add_player(p) assert r.is_ok() real_player_pid = r.value() winners_r = admin.run_tournament() assert winners_r.is_ok() real_winners = winners_r.value()[0][0] assert real_winners == {real_player_pid}
def make_players(num_players: int) -> List[PlayerInterface]: return [Player(FirstS()) for _ in range(num_players)]
def test_silenced_wrapper_class() -> None: p = Player(FirstS()) assert f_player(p).is_ok() # Adding the wrapper class doesn't cause type errors assert f_player(silenced_object(p)).is_ok()