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()