def test_init_play():
plateau = init_play()
# Comme on construit le tableau à la main, il est préférable de vérifier qu'il est bien correct.
assert len(plateau['tiles']) == 16, "Erreur, le plateau n'est pas initialisé à 16 cases."
print("Test de la fonction init_play: Ok")
def test_check_room():
plateau = init_play()
assert check_room(plateau, 2, 1)
assert check_room(plateau, 3, 3)
assert not (check_room(plateau, 10, 2))
assert not (check_room(plateau, -1, 3))
print("Test de la fonction check_room: Ok")
def test_check_indice():
plateau = init_play()
assert check_indice(plateau, 0)
assert check_indice(plateau, 3)
assert not (check_indice(plateau, 10))
assert not (check_indice(plateau, 4))
assert not (check_indice(plateau, -1))
print("Test de la fonction check_indice: Ok")
def test_check_indice():
"""
Test de la fonction check_indice
"""
plateau = init_play()
assert check_indice(plateau, 0)
assert check_indice(plateau, 3)
assert not check_indice(plateau, 4)
assert not check_indice(plateau, -1)
print('Test de la fonction check_indice : OK')
def test_is_game_over() :
"""
Test de la fonction is_game_over
"""
plateau = init_play()
assert not is_game_over(plateau)
plateau["tiles"] = [1,0,2,1,2,1,2,1,2,1,2,1,1,2,1,2]
assert not is_game_over(plateau)
plateau["tiles"] = [1 for i in range(16)]
assert is_game_over(plateau)
print('Test de la fonction is_game_over : OK')
def test_init_play():
"""
Test de la fonction init_play
"""
plateau = {
'n' : 4,
'nombre_cases_libres' : 16,
'tiles' : [0 for i in range(16)]
}
assert init_play() == plateau
print("Test de la fonction init_play : OK")
def test_get_value():
"""
Test de la fonction get_value
"""
plateau = init_play()
assert get_value(plateau, 0, 0) == 0
assert get_value(plateau, 2, 3) == 0
assert get_value(plateau, 1, 3) == 0
assert get_value(plateau, 3, 0) == 0
assert get_value(plateau, 18, 3) == 'Erreur !'
print('Test de la fonction get_value : OK')
def test_get_score() :
"""
Test de la fonction get_score
"""
plateau = init_play()
assert get_score(plateau) == 0
plateau["tiles"] = [1,0,2,1,2,1,2,1,2,1,2,1,1,2,1,2]
assert get_score(plateau) == 22
plateau["tiles"] = [1,0,2,1,2,1,2,-1,2,1,2,1,1,2,1,2]
assert get_score(plateau) == 20
print("Test de la fonction get_score : OK")
def test_get_score():
plateau = init_play()
assert get_score(plateau) == 0
plateau = {'n': 4,
'nb_cases_libres': 0,
'tiles': [6, 2, 3, 2, 12, 2, 6, 2, 6, 2, 2, 12, 1, 6, 3, 1]}
assert get_score(plateau) == 68
print("Test de la fonction get_score: Ok")
def test_set_value():
"""
Test de la fonction set_value
"""
plateau = init_play()
set_value(plateau, 0, 0, 1)
assert plateau['tiles'][0] == 1 and plateau["nombre_cases_libres"] == 15
set_value(plateau, 1, 2, 0)
assert plateau['tiles'][6] == 0 and plateau["nombre_cases_libres"] == 14
assert set_value(plateau, 18, 3, 1) == 'Erreur !'
set_value(plateau, 2, 3, 6)
assert plateau['tiles'][11] == 6 and plateau["nombre_cases_libres"] == 13
set_value(plateau, 3, 3, 6)
assert plateau['tiles'][15] == 6 and plateau["nombre_cases_libres"] == 12
print('Test de la fonction set_value : OK')
def test_is_room_empty():
plateau = init_play()
set_value(plateau, 0, 1, 2)
set_value(plateau, 1, 1, 1)
set_value(plateau, 1, 2, 0)
assert not (is_room_empty(plateau, 0, 1))
assert not (is_room_empty(plateau, 1, 1))
assert is_room_empty(plateau, 1, 2)
assert is_room_empty(plateau, 3, 2)
# is_room_empty(15, 2) renvoie une erreur.
print("Test de la fonction is_room_empty: Ok")
def test_put_next_tiles():
plateau = init_play()
tiles = get_next_alea_tiles(plateau, "init") # Tests avec le mode 'init'
put_next_tiles(plateau, tiles)
assert not is_room_empty(plateau, tiles['0']['lig'], tiles['0']['col'])
assert not is_room_empty(plateau, tiles['1']['lig'], tiles['1']['col'])
tiles = get_next_alea_tiles(plateau,
"encours") # Tests avec le mode 'encours'
put_next_tiles(plateau, tiles)
assert not is_room_empty(plateau, tiles['0']['lig'], tiles['0']['col'])
print("Test de la fonction put_next_tiles: Ok")
def test_get_free_space():
plateau = init_play()
lig, col = get_free_space(plateau)
assert is_room_empty(plateau, lig, col)
plateau = {
'n': 4,
'nb_cases_libres': 1,
'tiles': [6, 2, 3, 12, 2, 6, 2, 12, 2, 2, 12, 1, 12, 12, 12, 0]
}
lig, col = get_free_space(plateau)
assert lig == 3 and col == 3 # Vérification que les coordonnées de la case libre correspondent bien à celles de l'unique case libre disponible.
assert is_room_empty(plateau, lig, col)
print("Test de la fonction get_free_space: Ok")
def test_play_display():
plateau = init_play()
# Affichage attendu:
# 0 0 0 0
# 0 0 0 0
# 0 0 0 0
# 0 0 0 0
simple_display(plateau)
plateau['tiles'] = [12, 3, 6, 0, 3, 12, 1, 2, 48, 12, 96, 1, 192, 6, 3, 3]
# Affichage attendu:
# 12 3 6 0
# 3 12 1 2
# 48 12 96 1
# 192 6 3 3
simple_display(plateau)
print("Test de la fonction play_display: Ok")
def test_set_value():
plateau = init_play()
set_value(plateau, 0, 0, 1)
assert get_value(plateau, 0, 0) == 1
assert plateau["nombre_cases_libres"] == 15
set_value(plateau, 1, 2, 0)
assert get_value(plateau, 1, 2) == 0
assert plateau["nombre_cases_libres"] == 15
set_value(plateau, 2, 3, 6)
assert get_value(plateau, 2, 3) == 6
assert plateau["nombre_cases_libres"] == 14
# set_value(plateau, 18, 3, 1) renvoie une erreur.
print("Test de la fonction set_value: Ok")
def test_get_tile():
plateau = init_play()
tile = get_tile(plateau, 2)
assert tile['val'] == 2
# Vérification de la validité des coordonnées
assert 0 <= tile['lig'] < plateau['n']
assert 0 <= tile['col'] < plateau['n']
plateau = {
'n': 4,
'nb_cases_libres': 1,
'tiles': [6, 2, 3, 12, 2, 6, 2, 12, 2, 2, 12, 1, 12, 12, 12, 0]
}
tile = get_tile(plateau, 1)
assert tile['val'] == 1
assert tile['lig'] == 3 # Vérification de la ligne
assert tile['col'] == 3 # Vérification de la colonne
print("Test de la fonction get_tile: Ok")
def test_get_next_alea_tiles():
plateau = init_play()
tiles = get_next_alea_tiles(plateau, "init")
# Vérification de l'existence de deux tuiles de valeurs 1 et 2.
# On ne revérifie pas les coordonnées car elles sont déjà vérifiées dans les autres fonctions de test unitaire.
assert tiles['0']['val'] == 1
assert tiles['1']['val'] == 2
assert tiles['check']
plateau = {
'n': 4,
'nb_cases_libres': 1,
'tiles': [6, 2, 3, 12, 2, 6, 2, 12, 2, 2, 12, 1, 12, 12, 12, 0]
}
tiles = get_next_alea_tiles(plateau, "encours")
# Vérification de l'existance d'une seule tuile dont la valeur est comprise entre 1 et 3 (inclus).
assert 1 <= tiles['0']['val'] <= 3
assert not tiles['check']
print("Test de la fonction get_next_alea_tiles: Ok")
from game.play import init_play
p = init_play()
def aff_tab(t):
i = 0
ch = ''
while i < len(t):
ch += str(t[i]) + ' '
i += 1
return ch
def affich(p):
n = p['n']
i = 0
taille = n
j = 0
while i < n * n:
lig = []
while j < taille:
lig.append(p['tiles'][j])
j += 1
print(aff_tab(lig))
taille += n
i += n
affich(p)
