def test_only_one_input(self): """ Tests if we get get standard board if we only have one input """ b_std = cs.Board() b = cs.Board([(1, 4), (5, 16)]) assert b.board == b_std.board
def test_only_goal_input(self): """ Tests if we get get standard board and goal, if we only have one input """ b_std = cs.Board() b = cs.Board(goal=89) assert b.board == b_std.board
def test_position_adjustment(self): """Tests if position_adjustment returns the correct adjustment for different positions""" b = cs.Board() assert b.position_adjustment(2) == 0 assert b.position_adjustment(49) == 79 - 49 assert b.position_adjustment(33) == 3 - 33
def test_default_board(self): """ Testing if the default board is right """ b = cs.Board() assert b.ladders == { 1: 40, 8: 10, 36: 52, 43: 62, 49: 79, 65: 82, 68: 85 } assert b.chutes == { 24: 5, 33: 3, 42: 30, 56: 37, 64: 27, 74: 12, 87: 70 } assert b.goal == 90
def test_goal_reached(self): """ Checking if the goal is reached, we get True. """ b = cs.Board() goal = b.goal_reached(90) assert goal
def test_std_goal_is_not_same_as_30(self): """ Tests that standard goal is not 30 """ goal = 30 b = cs.Board(goal=goal) assert b.goal != goal
def test_goal_is_same_as_given(self): """ Tests that goal position is the same as the given input goal. """ goal = 30 b = cs.Board(ladders=[(1, 4)], chutes=[(9, 2)], goal=goal) assert b.goal == goal
def test_constructor_named(self): """Constructor with kw args works.""" b = cs.Board() s = cs.Simulation(player_field=[cs.Player, cs.Player], board=b, seed=123, randomize_players=True) assert isinstance(s, cs.Simulation)
def test_move(self): board = cs.Board() player = cs.LazyPlayer(board) for _ in range(10): player.move() assert player.number_of_moves == 10
def test_start_of_chute(self): board = cs.Board() player = cs.ResilientPlayer(board) for step in range(50): player.move() assert player.position not in board.snakes_and_ladders.keys()
def test_position_adjustment(self): """ Testing if the number of positions the player must move forward (in case of a ladder) is correct. """ b = cs.Board() pos = b.position_adjustment(1) assert pos == 39
def test_position_not_equal_one(self): board = cs.Board() player = cs.LazyPlayer(board) for _ in range(50): player.move() assert 1 <= player.position
def test_position_adjustment_returns_0_on_regular_spot(self): """ Tests that position_adjustment returns 0 when player doesn't land on a chute or ladder """ b = cs.Board() position = 2 zero = b.position_adjustment(position) assert zero == 0
def test_move(): """ Tests whether the player has moved a position """ player = sa.Player(sa.Board()) first_pos = player.position player.move() second_pos = player.position assert first_pos != second_pos
def test_position(self): board = cs.Board() player = cs.LazyPlayer(board) start_pos = player.position player.move() end_pos = player.position assert start_pos is not end_pos
def test_move(self): b = cs.Board() lazy_player = cs.LazyPlayer(b, dropped_steps=1) lazy_player.position = 34 random.seed(1) lazy_player.move() random.seed(1) lazy_player.move() assert lazy_player.position == 53
def test_move(self): """Tests if the players in Player Class takes the right amounts of moves""" board = cs.Board() player = cs.Player(board) for _ in range(10): player.move() assert player.number_of_moves == 10
def test_position_not_equal_one(self): """Test that the players position is not less than 1 after moving, since this is not possible""" board = cs.Board() player = cs.Player(board) for _ in range(50): player.move() assert 1 <= player.position
def test_move(self): """Tests that resilient player moves as it should.""" b = cs.Board() resilient_player = cs.ResilientPlayer(b, extra_steps=5) resilient_player.position = 22 random.seed(1) resilient_player.move() random.seed(1) resilient_player.move() assert resilient_player.position == 12
def test_position(self): """Tests that the player actually moves, when function move is called upon. So start position can not be equal to end position """ board = cs.Board() player = cs.Player(board) start_pos = player.position player.move() end_pos = player.position assert start_pos is not end_pos
def test_start_of_chute(self): """Test that the players position canĀ“t be the start point of a snake or a ladder, since the player is supposed to interact with these. """ board = cs.Board() player = cs.ResilientPlayer(board) for step in range(50): player.move() assert player.position not in board.snakes_and_ladders.keys()
def test_lazy_player_not_stepped_back(self): """We test here if the lazy player ever step back, except when take a chute""" chute = [5, 3, 30, 37, 27, 12, 70] game_ended, prev_position, stepped_back = False, 0, False p = cs.LazyPlayer(cs.Board()) while not game_ended: prev_position = p.position p.move() if p.position not in chute and p.position < prev_position: stepped_back, game_ended = True, True game_ended = p.board.goal_reached(p.position) assert not stepped_back
def test_move_resilientplayer(self): """ Resilient player can move. """ b = cs.Board() p = cs.ResilientPlayer(b) p.move() assert p.player_position > 0 assert p.player_position not in b.chutes.keys() and b.ladders.keys() position1 = p.player_position p.move() assert p.player_position != position1
def test_move_lazyplayer(self): """ Lazy player can move. """ b = cs.Board() p = cs.LazyPlayer(b) p.move() assert p.player_position > 0 assert p.player_position not in b.chutes.keys() and b.ladders.keys() position1 = p.player_position p.move() assert p.player_position != position1
def test_move(self): """Tests if turns is increased by one, and position is changed after move.""" b = cs.Board() p = cs.Player(b) turns_before = p.turns position_before = p.position p.move() assert p.turns == turns_before + 1 assert p.position != position_before p.position = 22 random.seed(1) p.move() random.seed(1) p.move() assert p.position == 7
def test_resilient_player_got_chute(self): """We test here if the chute and slided in ResilientPlayer(Board()) are functioning""" chute = [5, 3, 30, 37, 27, 12, 70] got_chute, game_ended, position, slided = False, False, 0, False while not got_chute: p = cs.ResilientPlayer(cs.Board()) while not game_ended: if position in chute and slided: got_chute, game_ended = True, True else: p.move() position, slided = p.position, p.slided game_ended = p.board.goal_reached(position) game_ended = False if not got_chute else True assert position in chute assert slided
def test_lazy_player_got_ladder(self): """We test here if the ladder and climbed in LazyPlayer(Board()) are functioning""" ladder = [40, 10, 52, 62, 79, 82, 85] got_ladder, game_ended, position, climbed = \ False, False, 0, False while not got_ladder: p = cs.LazyPlayer(cs.Board()) while not game_ended: if position in ladder and climbed: got_ladder, game_ended = True, True else: p.move() position, climbed = p.position, p.climbed game_ended = p.board.goal_reached(position) game_ended = False if not got_ladder else True assert position in ladder assert climbed
def test_move(self): """LazyPlayer can move.""" b = cs.Board() p = cs.LazyPlayer(b) p.move()
def test_constructor(self): """LazyPlayer can be constructed.""" b = cs.Board() p = cs.LazyPlayer(b, dropped_steps=3) assert isinstance(p, cs.LazyPlayer) assert isinstance(p, cs.Player)
def test_move(self): """ResilientPlayer can move.""" b = cs.Board() p = cs.ResilientPlayer(b) p.move()