def test_set_names_and_ranks():
table = Table()
table.init_round(0, 0, 0, 0, 0, [])
values = [
{
"name": "NoName",
"rank": "新人"
},
{
"name": "o2o2",
"rank": "3級"
},
{
"name": "shimmmmm",
"rank": "三段"
},
{
"name": "川海老",
"rank": "9級"
},
]
table.set_players_names_and_ranks(values)
assert table.get_player(0).name == "NoName"
assert table.get_player(0).rank == "新人"
assert table.get_player(3).name == "川海老"
assert table.get_player(3).rank == "9級"
def test_init_round():
table = Table()
round_wind_number = 4
count_of_honba_sticks = 2
count_of_riichi_sticks = 3
dora_indicator = 126
dealer = 3
scores = [250, 250, 250, 250]
table.init_round(round_wind_number, count_of_honba_sticks,
count_of_riichi_sticks, dora_indicator, dealer, scores)
assert table.round_wind_number == round_wind_number
assert table.count_of_honba_sticks == count_of_honba_sticks
assert table.count_of_riichi_sticks == count_of_riichi_sticks
assert table.dora_indicators[0] == dora_indicator
assert table.get_player(dealer).is_dealer is True
assert table.get_player(dealer).scores == 25000
dealer = 2
table.player.in_tempai = True
table.player.in_riichi = True
table.init_round(round_wind_number, count_of_honba_sticks,
count_of_riichi_sticks, dora_indicator, dealer, scores)
# test that we reinit round properly
assert table.get_player(3).is_dealer is False
assert table.player.in_tempai is False
assert table.player.in_riichi is False
assert table.get_player(dealer).is_dealer is True
def test_init_round(self):
table = Table()
round_number = 4
count_of_honba_sticks = 2
count_of_riichi_sticks = 3
dora_indicator = 126
dealer = 3
scores = [250, 250, 250, 250]
table.init_round(round_number, count_of_honba_sticks,
count_of_riichi_sticks, dora_indicator, dealer,
scores)
self.assertEqual(table.round_number, round_number)
self.assertEqual(table.count_of_honba_sticks, count_of_honba_sticks)
self.assertEqual(table.count_of_riichi_sticks, count_of_riichi_sticks)
self.assertEqual(table.dora_indicators[0], dora_indicator)
self.assertEqual(table.get_player(dealer).is_dealer, True)
self.assertEqual(table.get_player(dealer).scores, 25000)
dealer = 2
table.player.in_tempai = True
table.player.in_riichi = True
table.init_round(round_number, count_of_honba_sticks,
count_of_riichi_sticks, dora_indicator, dealer,
scores)
# test that we reinit round properly
self.assertEqual(table.get_player(3).is_dealer, False)
self.assertEqual(table.player.in_tempai, False)
self.assertEqual(table.player.in_riichi, False)
self.assertEqual(table.get_player(dealer).is_dealer, True)
def test_detect_enemy_tempai_and_riichi(self):
table = Table()
self.assertEqual(EnemyAnalyzer(table.get_player(1)).in_tempai, False)
self.assertEqual(EnemyAnalyzer(table.get_player(1)).is_threatening, False)
table.add_called_riichi(1)
self.assertEqual(EnemyAnalyzer(table.get_player(1)).in_tempai, True)
self.assertEqual(EnemyAnalyzer(table.get_player(1)).is_threatening, True)
def test_set_scores():
table = Table()
table.init_round(0, 0, 0, 0, 0, [])
scores = [230, 110, 55, 405]
table.set_players_scores(scores)
assert table.get_player(0).scores == 23000
assert table.get_player(1).scores == 11000
assert table.get_player(2).scores == 5500
assert table.get_player(3).scores == 40500
def test_set_scores(self):
table = Table()
table.init_round(0, 0, 0, 0, 0, [])
scores = [230, 110, 55, 405]
table.set_players_scores(scores)
self.assertEqual(table.get_player(0).scores, 23000)
self.assertEqual(table.get_player(1).scores, 11000)
self.assertEqual(table.get_player(2).scores, 5500)
self.assertEqual(table.get_player(3).scores, 40500)
def test_set_scores(self):
table = Table()
table.init_round(0, 0, 0, 0, 0, [])
scores = [230, 110, 55, 405]
table.set_players_scores(scores)
self.assertEqual(table.get_player(0).scores, 23000)
self.assertEqual(table.get_player(1).scores, 11000)
self.assertEqual(table.get_player(2).scores, 5500)
self.assertEqual(table.get_player(3).scores, 40500)
def test_detect_enemy_tempai_and_riichi(self):
table = Table()
self.assertEqual(EnemyAnalyzer(table.get_player(1)).in_tempai, False)
self.assertEqual(
EnemyAnalyzer(table.get_player(1)).is_threatening, False)
table.add_called_riichi(1)
self.assertEqual(EnemyAnalyzer(table.get_player(1)).in_tempai, True)
self.assertEqual(
EnemyAnalyzer(table.get_player(1)).is_threatening, True)
def test_temporary_safe_tiles(self):
table = Table()
table.add_discarded_tile(1, self._string_to_136_tile(man='4'), False)
self.assertEqual(table.get_player(1).temporary_safe_tiles, [])
self.assertEqual(table.get_player(2).temporary_safe_tiles, [3])
self.assertEqual(table.get_player(3).temporary_safe_tiles, [3])
table.add_discarded_tile(2, self._string_to_136_tile(man='5'), False)
self.assertEqual(table.get_player(1).temporary_safe_tiles, [4])
self.assertEqual(table.get_player(2).temporary_safe_tiles, [])
self.assertEqual(table.get_player(3).temporary_safe_tiles, [3, 4])
table.add_discarded_tile(3, self._string_to_136_tile(man='6'), False)
self.assertEqual(table.get_player(1).temporary_safe_tiles, [4, 5])
self.assertEqual(table.get_player(2).temporary_safe_tiles, [5])
self.assertEqual(table.get_player(3).temporary_safe_tiles, [])
table.add_discarded_tile(1, self._string_to_136_tile(man='7'), False)
self.assertEqual(table.get_player(1).temporary_safe_tiles, [])
self.assertEqual(table.get_player(2).temporary_safe_tiles, [5, 6])
self.assertEqual(table.get_player(3).temporary_safe_tiles, [6])
def test_find_dealer_tile_to_discard(self):
dealer = 2
dora = self._string_to_136_tile(honors='3')
table = Table()
table.init_round(0, 0, 0, dora, dealer, [])
tiles = self._string_to_136_array(sou='2234678', pin='34', man='45789')
table.player.init_hand(tiles)
table.add_discarded_tile(1, self._string_to_136_tile(man='4'), False)
table.add_discarded_tile(1, self._string_to_136_tile(man='5'), False)
table.add_discarded_tile(2, self._string_to_136_tile(man='8'), False)
table.add_discarded_tile(2, self._string_to_136_tile(man='9'), False)
table.add_called_riichi(1)
table.add_called_riichi(2)
# for this test we don't need temporary_safe_tiles
table.get_player(1).temporary_safe_tiles = []
table.get_player(2).temporary_safe_tiles = []
result = table.player.discard_tile()
# second player is a dealer, let's fold against him
self.assertEqual(self._to_string([result]), '9m')
tiles = self._string_to_136_array(sou='234567', pin='348', man='234', honors='23')
table.player.init_hand(tiles)
result = table.player.discard_tile()
# there is no safe tiles against dealer, so let's fold against other players
self.assertEqual(table.player.ai.in_defence, True)
self.assertEqual(self._to_string([result]), '4m')
def test_set_scores_and_uma(self):
table = Table()
table.init_round(0, 0, 0, 0, 0, [])
scores = [230, 110, 55, 405]
uma = [-17, 3, 48, -34]
table.set_players_scores(scores, uma)
self.assertEqual(table.get_player(0).scores, 23000)
self.assertEqual(table.get_player(0).uma, -17)
self.assertEqual(table.get_player(1).scores, 11000)
self.assertEqual(table.get_player(1).uma, 3)
self.assertEqual(table.get_player(2).scores, 5500)
self.assertEqual(table.get_player(2).uma, 48)
self.assertEqual(table.get_player(3).scores, 40500)
self.assertEqual(table.get_player(3).uma, -34)
def test_set_scores_and_uma():
table = Table()
table.init_round(0, 0, 0, 0, 0, [])
scores = [230, 110, 55, 405]
uma = [-17, 3, 48, -34]
table.set_players_scores(scores, uma)
assert table.get_player(0).scores == 23000
assert table.get_player(0).uma == (-17)
assert table.get_player(1).scores == 11000
assert table.get_player(1).uma == 3
assert table.get_player(2).scores == 5500
assert table.get_player(2).uma == 48
assert table.get_player(3).scores == 40500
assert table.get_player(3).uma == (-34)
def test_set_scores_and_uma(self):
table = Table()
table.init_round(0, 0, 0, 0, 0, [])
scores = [230, 110, 55, 405]
uma = [-17, 3, 48, -34]
table.set_players_scores(scores, uma)
self.assertEqual(table.get_player(0).scores, 23000)
self.assertEqual(table.get_player(0).uma, -17)
self.assertEqual(table.get_player(1).scores, 11000)
self.assertEqual(table.get_player(1).uma, 3)
self.assertEqual(table.get_player(2).scores, 5500)
self.assertEqual(table.get_player(2).uma, 48)
self.assertEqual(table.get_player(3).scores, 40500)
self.assertEqual(table.get_player(3).uma, -34)
def test_set_names_and_ranks(self):
table = Table()
table.init_round(0, 0, 0, 0, 0, [])
values = [
{'name': 'NoName', 'rank': u'新人'},
{'name': 'o2o2', 'rank': u'3級'},
{'name': 'shimmmmm', 'rank': u'三段'},
{'name': u'川海老', 'rank': u'9級'}
]
table.set_players_names_and_ranks(values)
self.assertEqual(table.get_player(0).name, 'NoName')
self.assertEqual(table.get_player(0).rank, u'新人')
self.assertEqual(table.get_player(3).name, u'川海老')
self.assertEqual(table.get_player(3).rank, u'9級')
def test_add_safe_tile_after_discard(self):
table = Table()
table.add_called_riichi(3)
table.add_discarded_tile(1, self._string_to_136_tile(man='3'), False)
table.add_discarded_tile(0, self._string_to_136_tile(man='4'), False)
self.assertEqual(len(table.get_player(1).discards), 1)
self.assertEqual(len(table.get_player(2).discards), 0)
self.assertEqual(len(table.get_player(3).discards), 0)
self.assertEqual(len(table.get_player(1).safe_tiles), 1)
self.assertEqual(len(table.get_player(2).safe_tiles), 0)
self.assertEqual(len(table.get_player(3).safe_tiles), 2)
# "2" is 3 man
self.assertEqual(table.get_player(1).safe_tiles, [2])
self.assertEqual(table.get_player(3).safe_tiles, [2, 3])
def test_init_round(self):
table = Table()
round_wind_number = 4
count_of_honba_sticks = 2
count_of_riichi_sticks = 3
dora_indicator = 126
dealer = 3
scores = [250, 250, 250, 250]
table.init_round(
round_wind_number,
count_of_honba_sticks,
count_of_riichi_sticks,
dora_indicator,
dealer,
scores
)
self.assertEqual(table.round_wind_number, round_wind_number)
self.assertEqual(table.count_of_honba_sticks, count_of_honba_sticks)
self.assertEqual(table.count_of_riichi_sticks, count_of_riichi_sticks)
self.assertEqual(table.dora_indicators[0], dora_indicator)
self.assertEqual(table.get_player(dealer).is_dealer, True)
self.assertEqual(table.get_player(dealer).scores, 25000)
dealer = 2
table.player.in_tempai = True
table.player.in_riichi = True
table.init_round(
round_wind_number,
count_of_honba_sticks,
count_of_riichi_sticks,
dora_indicator,
dealer,
scores
)
# test that we reinit round properly
self.assertEqual(table.get_player(3).is_dealer, False)
self.assertEqual(table.player.in_tempai, False)
self.assertEqual(table.player.in_riichi, False)
self.assertEqual(table.get_player(dealer).is_dealer, True)
def test_detect_enemy_tempai_and_opened_sets(self):
table = Table()
self.assertEqual(EnemyAnalyzer(table.get_player(1)).in_tempai, False)
self.assertEqual(EnemyAnalyzer(table.get_player(1)).is_threatening, False)
table.add_called_meld(1, self._make_meld(Meld.CHI, sou='567'))
table.add_called_meld(1, self._make_meld(Meld.CHI, pin='123'))
table.add_called_meld(1, self._make_meld(Meld.CHI, man='345'))
table.add_called_meld(1, self._make_meld(Meld.PON, man='777'))
self.assertEqual(EnemyAnalyzer(table.get_player(1)).in_tempai, True)
self.assertEqual(EnemyAnalyzer(table.get_player(1)).is_threatening, False)
table.dora_indicators = [self._string_to_136_tile(man='6')]
# enemy opened the pon of dor, so better to fold against him
self.assertEqual(EnemyAnalyzer(table.get_player(1)).in_tempai, True)
self.assertEqual(EnemyAnalyzer(table.get_player(1)).is_threatening, True)
def test_try_to_detect_honitsu_hand(self):
table = Table()
table.add_called_meld(1, self._make_meld(Meld.CHI, pin='567'))
table.add_called_meld(1, self._make_meld(Meld.CHI, pin='123'))
table.add_called_meld(1, self._make_meld(Meld.CHI, pin='345'))
table.add_discarded_tile(1, self._string_to_136_tile(sou='1'), False)
table.add_discarded_tile(1, self._string_to_136_tile(sou='5'), False)
table.add_discarded_tile(1, self._string_to_136_tile(sou='8'), False)
table.add_discarded_tile(1, self._string_to_136_tile(sou='9'), False)
table.add_discarded_tile(1, self._string_to_136_tile(man='1'), False)
table.add_discarded_tile(1, self._string_to_136_tile(man='1'), False)
table.add_discarded_tile(1, self._string_to_136_tile(pin='1'), False)
self.assertEqual(
EnemyAnalyzer(table.get_player(1)).is_threatening, True)
self.assertEqual(
EnemyAnalyzer(table.get_player(1)).chosen_suit, is_pin)
def test_players_wind():
table = Table()
player = table.player
dealer_seat = 0
table.init_round(0, 0, 0, 0, dealer_seat, [])
assert player.player_wind == EAST
assert table.get_player(1).player_wind == SOUTH
dealer_seat = 1
table.init_round(0, 0, 0, 0, dealer_seat, [])
assert player.player_wind == NORTH
assert table.get_player(1).player_wind == EAST
dealer_seat = 2
table.init_round(0, 0, 0, 0, dealer_seat, [])
assert player.player_wind == WEST
assert table.get_player(1).player_wind == NORTH
dealer_seat = 3
table.init_round(0, 0, 0, 0, dealer_seat, [])
assert player.player_wind == SOUTH
assert table.get_player(1).player_wind == WEST
def test_set_names_and_ranks(self):
table = Table()
table.init_round(0, 0, 0, 0, 0, [])
values = [{
'name': 'NoName',
'rank': u'新人'
}, {
'name': 'o2o2',
'rank': u'3級'
}, {
'name': 'shimmmmm',
'rank': u'三段'
}, {
'name': u'川海老',
'rank': u'9級'
}]
table.set_players_names_and_ranks(values)
self.assertEqual(table.get_player(0).name, 'NoName')
self.assertEqual(table.get_player(0).rank, u'新人')
self.assertEqual(table.get_player(3).name, u'川海老')
self.assertEqual(table.get_player(3).rank, u'9級')
def test_threatening_riichi_player_and_not_early_hand_bonus():
table = Table()
enemy_seat = 2
discards = string_to_136_array(sou="1111222")
for discard in discards:
table.add_discarded_tile(enemy_seat, discard, False)
table.add_called_riichi_step_one(enemy_seat)
table.add_called_riichi_step_two(enemy_seat)
table.get_player(enemy_seat).is_ippatsu = False
# +1 scale for riichi on 6+ turn
threatening_player = table.player.ai.defence.get_threatening_players()[0]
assert threatening_player.enemy.seat == enemy_seat
assert threatening_player.get_assumed_hand_cost(
string_to_136_tile(man="2")) == 3900
def test_try_to_detect_honitsu_hand(self):
table = Table()
table.add_called_meld(1, self._make_meld(Meld.CHI, pin='567'))
table.add_called_meld(1, self._make_meld(Meld.CHI, pin='123'))
table.add_called_meld(1, self._make_meld(Meld.CHI, pin='345'))
table.add_discarded_tile(1, self._string_to_136_tile(sou='1'), False)
table.add_discarded_tile(1, self._string_to_136_tile(sou='5'), False)
table.add_discarded_tile(1, self._string_to_136_tile(sou='8'), False)
table.add_discarded_tile(1, self._string_to_136_tile(sou='9'), False)
table.add_discarded_tile(1, self._string_to_136_tile(man='1'), False)
table.add_discarded_tile(1, self._string_to_136_tile(man='1'), False)
table.add_discarded_tile(1, self._string_to_136_tile(pin='1'), False)
self.assertEqual(EnemyAnalyzer(table.get_player(1)).is_threatening, True)
self.assertEqual(EnemyAnalyzer(table.get_player(1)).chosen_suit, is_pin)
def test_find_common_safe_tile_to_discard(self):
table = Table()
tiles = self._string_to_136_array(sou='2456', pin='234478', man='2336')
table.player.init_hand(tiles)
table.add_discarded_tile(1, self._string_to_136_tile(sou='6'), False)
table.add_discarded_tile(1, self._string_to_136_tile(pin='5'), False)
table.add_discarded_tile(2, self._string_to_136_tile(pin='5'), False)
table.add_discarded_tile(2, self._string_to_136_tile(sou='6'), False)
table.add_called_riichi(1)
table.add_called_riichi(2)
# for this test we don't need temporary_safe_tiles
table.get_player(1).temporary_safe_tiles = []
table.get_player(2).temporary_safe_tiles = []
result = table.player.discard_tile()
self.assertEqual(self._to_string([result]), '6s')
def test_find_tile_to_discard_when_no_safe_tile(self):
dealer = 2
dora = self._string_to_136_tile(honors='3')
table = Table()
table.init_round(0, 0, 0, dora, dealer, [])
tiles = self._string_to_136_array(sou='2234555', pin='11', man='11113')
table.player.init_hand(tiles)
table.add_discarded_tile(1, self._string_to_136_tile(man='8'), False)
table.add_discarded_tile(1, self._string_to_136_tile(man='9'), False)
table.add_discarded_tile(2, self._string_to_136_tile(man='8'), False)
table.add_discarded_tile(2, self._string_to_136_tile(man='9'), False)
table.add_called_riichi(1)
table.add_called_riichi(2)
# for this test we don't need temporary_safe_tiles
table.get_player(1).temporary_safe_tiles = []
table.get_player(2).temporary_safe_tiles = []
result = table.player.discard_tile()
# No safe tile to discard. So should discard 5s
self.assertEqual(self._to_string([result]), '1m')
tiles = self._string_to_136_array(sou='2234556', pin='11', man='34567')
table.player.init_hand(tiles)
result = table.player.discard_tile()
# No safe tile to discard. So should discard 1p
self.assertEqual(self._to_string([result]), '1p')
tiles = self._string_to_136_array(sou='2345678', pin='19', man='34567')
table.player.init_hand(tiles)
result = table.player.discard_tile()
# No safe tile to discard. So should discard 1p
self.assertEqual(self._to_string([result]), '1p')
def test_threatening_riichi_player_middle_tiles_bonus():
table = Table()
enemy_seat = 2
table.add_called_riichi_step_one(enemy_seat)
table.add_called_riichi_step_two(enemy_seat)
table.get_player(enemy_seat).is_ippatsu = False
# +1 scale 456 tiles
threatening_player = table.player.ai.defence.get_threatening_players()[0]
assert threatening_player.enemy.seat == enemy_seat
# +1 scale 456 tiles
assert threatening_player.get_assumed_hand_cost(
string_to_136_tile(man="4"), can_be_used_for_ryanmen=True) == 3900
assert threatening_player.get_assumed_hand_cost(
string_to_136_tile(man="5"), can_be_used_for_ryanmen=True) == 3900
assert threatening_player.get_assumed_hand_cost(
string_to_136_tile(man="6"), can_be_used_for_ryanmen=True) == 3900
assert threatening_player.get_assumed_hand_cost(
string_to_136_tile(man="5"), can_be_used_for_ryanmen=False) == 3900
# +1 scare for 2378 tiles that could be used in ryanmen
assert threatening_player.get_assumed_hand_cost(
string_to_136_tile(pin="2"), can_be_used_for_ryanmen=True) == 3900
assert threatening_player.get_assumed_hand_cost(
string_to_136_tile(pin="2"), can_be_used_for_ryanmen=False) == 2000
assert threatening_player.get_assumed_hand_cost(
string_to_136_tile(sou="7"), can_be_used_for_ryanmen=True) == 3900
assert threatening_player.get_assumed_hand_cost(
string_to_136_tile(sou="7"), can_be_used_for_ryanmen=False) == 2000
# not middle tiles
assert threatening_player.get_assumed_hand_cost(
string_to_136_tile(man="1"), can_be_used_for_ryanmen=True) == 2000
assert threatening_player.get_assumed_hand_cost(
string_to_136_tile(pin="9"), can_be_used_for_ryanmen=True) == 2000
def test_detect_enemy_tempai_and_opened_sets(self):
table = Table()
self.assertEqual(EnemyAnalyzer(table.get_player(1)).in_tempai, False)
self.assertEqual(
EnemyAnalyzer(table.get_player(1)).is_threatening, False)
table.add_called_meld(1, self._make_meld(Meld.CHI, sou='567'))
table.add_called_meld(1, self._make_meld(Meld.CHI, pin='123'))
table.add_called_meld(1, self._make_meld(Meld.CHI, man='345'))
table.add_called_meld(1, self._make_meld(Meld.PON, man='777'))
self.assertEqual(EnemyAnalyzer(table.get_player(1)).in_tempai, True)
self.assertEqual(
EnemyAnalyzer(table.get_player(1)).is_threatening, False)
table.dora_indicators = [self._string_to_136_tile(man='6')]
# enemy opened the pon of dor, so better to fold against him
self.assertEqual(EnemyAnalyzer(table.get_player(1)).in_tempai, True)
self.assertEqual(
EnemyAnalyzer(table.get_player(1)).is_threatening, True)
def test_set_scores_and_recalculate_player_position(self):
table = Table()
table.init_round(0, 0, 0, 0, 0, [])
self.assertEqual(table.get_player(0).first_seat, 0)
self.assertEqual(table.get_player(1).first_seat, 1)
self.assertEqual(table.get_player(2).first_seat, 2)
self.assertEqual(table.get_player(3).first_seat, 3)
scores = [230, 110, 55, 405]
table.set_players_scores(scores)
self.assertEqual(table.get_player(0).position, 2)
self.assertEqual(table.get_player(1).position, 3)
self.assertEqual(table.get_player(2).position, 4)
self.assertEqual(table.get_player(3).position, 1)
scores = [110, 110, 405, 405]
table.set_players_scores(scores)
self.assertEqual(table.get_player(0).position, 3)
self.assertEqual(table.get_player(1).position, 4)
self.assertEqual(table.get_player(2).position, 1)
self.assertEqual(table.get_player(3).position, 2)
def test_set_scores_and_recalculate_player_position():
table = Table()
table.init_round(0, 0, 0, 0, 0, [])
assert table.get_player(0).first_seat == 0
assert table.get_player(1).first_seat == 1
assert table.get_player(2).first_seat == 2
assert table.get_player(3).first_seat == 3
scores = [230, 110, 55, 405]
table.set_players_scores(scores)
assert table.get_player(0).position == 2
assert table.get_player(1).position == 3
assert table.get_player(2).position == 4
assert table.get_player(3).position == 1
scores = [110, 110, 405, 405]
table.set_players_scores(scores)
assert table.get_player(0).position == 3
assert table.get_player(1).position == 4
assert table.get_player(2).position == 1
assert table.get_player(3).position == 2
def test_set_scores_and_recalculate_player_position(self):
table = Table()
table.init_round(0, 0, 0, 0, 0, [])
self.assertEqual(table.get_player(0).first_seat, 0)
self.assertEqual(table.get_player(1).first_seat, 1)
self.assertEqual(table.get_player(2).first_seat, 2)
self.assertEqual(table.get_player(3).first_seat, 3)
scores = [230, 110, 55, 405]
table.set_players_scores(scores)
self.assertEqual(table.get_player(0).position, 2)
self.assertEqual(table.get_player(1).position, 3)
self.assertEqual(table.get_player(2).position, 4)
self.assertEqual(table.get_player(3).position, 1)
scores = [110, 110, 405, 405]
table.set_players_scores(scores)
self.assertEqual(table.get_player(0).position, 3)
self.assertEqual(table.get_player(1).position, 4)
self.assertEqual(table.get_player(2).position, 1)
self.assertEqual(table.get_player(3).position, 2)
