Skip to content

Commit b8f3003

Browse files
author
renzon
committed
Refatorando código de Atores
1 parent 30dbf8c commit b8f3003

File tree

2 files changed

+114
-56
lines changed

2 files changed

+114
-56
lines changed

‎testes/atores_testes.py‎

Lines changed: 113 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -5,43 +5,51 @@
55
from atores import Ator, DESTRUIDO, ATIVO, Obstaculo, Porco, PassaroAmarelo, PassaroVermelho
66

77

8-
def assert_ator_status(test_case, ator, caracter_status_ativo, carater_status_destruido):
9-
test_case.assertEqual(ATIVO, ator.status(0))
10-
test_case.assertEqual(caracter_status_ativo, ator.caracter(0))
11-
ator.colidir(ator, 3.2)
12-
test_case.assertEqual(ATIVO, ator.status(3.1))
13-
test_case.assertEqual(caracter_status_ativo, ator.caracter(3.1))
14-
test_case.assertEqual(DESTRUIDO, ator.status(3.2))
15-
test_case.assertEqual(carater_status_destruido, ator.caracter(3.2))
16-
test_case.assertEqual(DESTRUIDO, ator.status(4))
17-
test_case.assertEqual(carater_status_destruido, ator.caracter(4))
18-
19-
20-
class AtorTestes(TestCase):
8+
class AtorBaseTest(TestCase):
9+
def assert_ator_caracteres(self, ator, caracter_status_ativo, caracter_status_destruido):
10+
'Confere status e caracteres ativos e destruidos de um ator'
11+
# Conferencia de caracter de ator ativo
12+
self.assertEqual(ATIVO, ator.status(0))
13+
self.assertEqual(caracter_status_ativo, ator.caracter(0))
14+
15+
# Colidindo ator com ele mesmo para alterar seu status para destruido
16+
ator.colidir(ator, 3.2)
17+
18+
self.assertEqual(caracter_status_ativo, ator.caracter(3.1),
19+
'Status ativo, logo o caracter deveria ser %s' % caracter_status_ativo)
20+
self.assertEqual(caracter_status_destruido, ator.caracter(3.2),
21+
'Status destruido, logo o caracter deveria ser %s' % caracter_status_destruido)
22+
self.assertEqual(caracter_status_destruido, ator.caracter(4),
23+
'Status destruido, logo o caracter deveria ser %s' % caracter_status_destruido)
24+
25+
26+
class AtorTestes(AtorBaseTest):
2127
def teste_ator_posicao(self):
2228
ator = Ator()
2329
self.assertTupleEqual((0, 0), ator.calcular_posicao(0))
2430
ator = Ator(0.3, 0.5)
25-
self.assertTupleEqual((0, 0), ator.calcular_posicao(2.3))
31+
self.assertTupleEqual((0, 0), ator.calcular_posicao(2.3), 'Deveria arredondar para inteiro')
2632
ator = Ator(0.6, 2.1)
27-
self.assertTupleEqual((1, 2), ator.calcular_posicao(3.14))
33+
self.assertTupleEqual((1, 2), ator.calcular_posicao(3.14), 'Deveria arredondar para inteiro')
2834

29-
def assert_colisao_atores_ativos(self, ator, ator2, intervalo=1):
30-
tempo_da_colisao = 2
31-
self.assertEqual(ator.status(tempo_da_colisao), ATIVO)
32-
self.assertEqual(ator2.status(tempo_da_colisao), ATIVO)
33-
ator.colidir(ator2, tempo_da_colisao, intervalo)
34-
self.assertEqual(ator2.status(tempo_da_colisao), DESTRUIDO)
35-
self.assertEqual(ator.status(tempo_da_colisao), DESTRUIDO)
35+
def teste_status(self):
36+
ator = Ator()
37+
'Confere status de um ator'
38+
# Conferencia de caracter de ator ativo
39+
self.assertEqual(ATIVO, ator.status(0))
3640

37-
def assert_nao_colisao(self, ator, ator2):
38-
tempo_da_colisao = 2
39-
status_iniciais = [ator.status(tempo_da_colisao), ator2.status(tempo_da_colisao)]
40-
ator.colidir(ator2, tempo_da_colisao)
41-
self.assertListEqual(status_iniciais, [ator.status(tempo_da_colisao), ator2.status(tempo_da_colisao)])
41+
# Colidindo ator com ele mesmo para alterar seu status para destruido
42+
ator._tempo_de_colisao = 3.2
43+
44+
self.assertEqual(ATIVO, ator.status(3.1),
45+
'Status para tempo 3.1 de jogo deveria mostrar status ativo, já que é menor que o tempo de colisão 3.2')
46+
self.assertEqual(DESTRUIDO, ator.status(3.2),
47+
'Status para tempo 3.2 de jogo deveria mostrar status destruido, já que é igual ao tempo de colisão 3.2')
48+
self.assertEqual(DESTRUIDO, ator.status(4),
49+
'Status para tempo 4 de jogo deveria mostrar status destruido, já que é maior que o tempo de colisão 3.2')
4250

4351
def teste_colisao_entre_atores_ativos(self):
44-
ator = Ator(2, 2)
52+
ator = Ator(2, 2) # Ator recém criado deve ter status ativo
4553
ator2 = Ator(2, 2)
4654
self.assert_colisao_atores_ativos(ator, ator2)
4755
self.assert_colisao_atores_ativos(Ator(2, 2), Ator(2, 3))
@@ -54,6 +62,7 @@ def teste_colisao_entre_atores_ativos(self):
5462
self.assert_colisao_atores_ativos(Ator(2, 2), Ator(1, 3))
5563

5664
def teste_colisao_entre_atores_ativos_com_intervalo(self):
65+
# Com intervalo 2, diferente do padrão 1, essa colisão deveria acontecer
5766
self.assert_colisao_atores_ativos(Ator(2, 2), Ator(2, 4), 2)
5867

5968
def teste_nao_colisao_entre_atores_ativos(self):
@@ -68,7 +77,7 @@ def teste_nao_colisao_entre_atores_ativos(self):
6877

6978
def teste_colisao_somente_um_ator_destruido(self):
7079
ator = Ator(2, 2)
71-
ator.colidir(ator, 0)
80+
ator.colidir(ator, 0) # colidingo ator com ele mesmo para alterar seu status para destruido
7281
ator2 = Ator(2, 2)
7382
self.assert_nao_colisao(ator, ator2)
7483
self.assert_nao_colisao(Ator(2, 3), ator)
@@ -89,42 +98,75 @@ def teste_colisao_somente_um_ator_destruido(self):
8998
self.assert_nao_colisao(Ator(1, 2), ator)
9099
self.assert_nao_colisao(Ator(1, 3), ator)
91100

92-
def teste_status(self):
101+
def test_caracter(self):
93102
ator = Ator()
94-
assert_ator_status(self, ator, 'A', ' ')
103+
self.assert_ator_caracteres(ator, 'A', ' ')
104+
105+
106+
def assert_colisao_atores_ativos(self, ator, ator2, intervalo=1):
107+
'Se certifica que há colisão entre atores ativos'
108+
tempo_da_colisao = 2
109+
# Conferindo status dos dois atores antes da colisão
110+
self.assertEqual(ator.status(tempo_da_colisao), ATIVO, 'Status deveria ser ativo antes da colisão')
111+
self.assertEqual(ator2.status(tempo_da_colisao), ATIVO, 'Status deveria ser ativo antes da colisão')
112+
ator.colidir(ator2, tempo_da_colisao, intervalo)
113+
# Conferindo status dos dois atores depois da colisão
114+
self.assertEqual(ator2.status(tempo_da_colisao), DESTRUIDO, 'Status deveria ser destruido depois da colisão')
115+
self.assertEqual(ator.status(tempo_da_colisao), DESTRUIDO, 'Status deveria ser destruido depois da colisão')
116+
117+
def assert_nao_colisao(self, ator, ator2):
118+
'Se certifica que não colisão entre dois atores'
119+
tempo_da_colisao = 2
120+
# Armazenando status antes da colisão
121+
status_inicial_ator = ator.status(tempo_da_colisao)
122+
status_inicial_ator_2 = ator2.status(tempo_da_colisao)
123+
124+
ator.colidir(ator2, tempo_da_colisao)
125+
126+
# Conferindo se status ficaram inalterados
127+
self.assertEqual(status_inicial_ator, ator.status(tempo_da_colisao), 'Status de ator não deveria mudar')
128+
self.assertEqual(status_inicial_ator_2, ator2.status(tempo_da_colisao), 'Status de ator2 não deveria mudar')
95129

96130

97-
class ObstaculoTestes(TestCase):
131+
class ObstaculoTestes(AtorBaseTest):
98132
def teste_status(self):
99133
obstaculo = Obstaculo()
100-
assert_ator_status(self, obstaculo, 'O', ' ')
134+
self.assert_ator_caracteres(obstaculo, 'O', ' ')
101135

102136

103-
class PorcoTestes(TestCase):
137+
class PorcoTestes(AtorBaseTest):
104138
def teste_status(self):
105139
porco = Porco()
106-
assert_ator_status(self, porco, '@', '+')
140+
self.assert_ator_caracteres(porco, '@', '+')
107141

108142

109-
class PassaroBaseTests(TestCase):
143+
class PassaroBaseTests(AtorBaseTest):
110144
def assert_passaro_posicao(self, x_esperado, y_esperado, status_esperado, passaro, tempo):
111-
dct = {'x_esperado': x_esperado, 'y_esperado': y_esperado, 'status_esperado': status_esperado, 'tempo': tempo}
112-
self.assertTupleEqual((x_esperado, y_esperado), passaro.calcular_posicao(tempo), dct)
145+
x_calculado, y_calculado = passaro.calcular_posicao(tempo)
146+
self.assertEqual(x_esperado, x_calculado)
147+
self.assertEqual(y_esperado, y_calculado)
113148
passaro.colidir_com_chao(tempo)
114-
self.assertEqual(status_esperado, passaro.status(tempo), dct)
149+
self.assertEqual(status_esperado, passaro.status(tempo))
115150

116151

117152
class PassaroVermelhoTests(PassaroBaseTests):
153+
def teste_status(self):
154+
passaro_amarelo = PassaroVermelho(1, 1)
155+
self.assert_ator_caracteres(passaro_amarelo, 'V', 'v')
156+
118157
def teste_velocidade_escalar(self):
119158
self.assertEqual(20, PassaroVermelho.velocidade_escalar)
120159

121160
def teste_foi_lancado(self):
122161
passaro_vermelho = PassaroVermelho(1, 1)
123-
self.assertFalse(passaro_vermelho.foi_lancado())
162+
self.assertFalse(passaro_vermelho.foi_lancado(),
163+
'Se o método lançar ainda não foi executado, deve retornar falso')
124164
passaro_vermelho.lancar(0, 0)
125-
self.assertTrue(passaro_vermelho.foi_lancado())
165+
self.assertTrue(passaro_vermelho.foi_lancado(),
166+
'Se o método lançar foi executado, deve retornar verdadeiro')
126167

127168
def teste_posicao_antes_do_lancamento(self):
169+
'Método que testa que o pássaro fica parado antes do tempo de lançamento'
128170
passaro_vermelho = PassaroVermelho(1, 1)
129171
passaro_vermelho.lancar(90, 2) # passaro lancado a 90 graus no tempo 2 segundos
130172
#
@@ -133,9 +175,6 @@ def teste_posicao_antes_do_lancamento(self):
133175
self.assertEqual((1, 1), passaro_vermelho.calcular_posicao(t),
134176
'Não deveria se mover no tempo %s < 2 segundtos' % t)
135177

136-
def teste_status(self):
137-
passaro_amarelo = PassaroVermelho(1, 1)
138-
assert_ator_status(self, passaro_amarelo, 'V', 'v')
139178

140179
def teste_colisao_com_chao(self):
141180
for i in range(30):
@@ -146,18 +185,30 @@ def teste_colisao_com_chao(self):
146185
def teste_colisao(self):
147186
passaro_vermelho = PassaroVermelho(1, 1)
148187
passaro_vermelho.lancar(45, 2) # passaro lancado a 45 graus no tempo 2 segundos
149-
# Código de geração de testes
150188

151189
porco = Porco(14, 10)
152-
passaro_vermelho.calcular_posicao(2.89) # tempo exato quanto o passário chega em 14,10
190+
x_calculado, y_calculado = passaro_vermelho.calcular_posicao(2.89)
191+
self.assertEqual(14, x_calculado)
192+
self.assertEqual(10, y_calculado)
193+
153194
passaro_vermelho.colidir(porco, 2.89)
154195
self.assertEqual(DESTRUIDO, passaro_vermelho.status(2.89))
155-
# Deve ficar parado onde colidiu para qualquer tempo maior que o de colisão
156-
self.assertTupleEqual((14, 10), passaro_vermelho.calcular_posicao(2.9))
157-
self.assertTupleEqual((14, 10), passaro_vermelho.calcular_posicao(1000))
196+
197+
# Deve ficar parado onde colidiu para qualquer tempo maior ou igual que o de colisão
198+
x_calculado, y_calculado = passaro_vermelho.calcular_posicao(2.89)
199+
self.assertEqual(14, x_calculado)
200+
self.assertEqual(10, y_calculado)
201+
202+
x_calculado, y_calculado = passaro_vermelho.calcular_posicao(4)
203+
self.assertEqual(14, x_calculado)
204+
self.assertEqual(10, y_calculado)
158205

159206

160207
class PassaroAmareloTests(PassaroBaseTests):
208+
def teste_status(self):
209+
passaro_amarelo = PassaroAmarelo(1, 1)
210+
self.assert_ator_caracteres(passaro_amarelo, 'A', 'a')
211+
161212
def teste_velocidade_escalar(self):
162213
self.assertEqual(30, PassaroAmarelo.velocidade_escalar)
163214

@@ -170,9 +221,6 @@ def teste_posicao_antes_do_lancamento(self):
170221
self.assertEqual((1, 1), passaro_amarelo.calcular_posicao(t),
171222
'Não deveria se mover no tempo %s < 2 segundtos' % t)
172223

173-
def teste_status(self):
174-
passaro_amarelo = PassaroAmarelo(1, 1)
175-
assert_ator_status(self, passaro_amarelo, 'A', 'a')
176224

177225
def teste_colisao_com_chao(self):
178226
for i in range(30):
@@ -184,17 +232,26 @@ def teste_colisao(self):
184232
passaro_amarelo = PassaroAmarelo(1, 1)
185233
passaro_amarelo.lancar(45, 2) # passaro lancado a 45 graus no tempo 2 segundos
186234
porco = Porco(4, 4)
187-
passaro_amarelo.calcular_posicao(2.12) # tempo exato quanto o passário chega em 4,3
235+
x_calculado, y_calculado = passaro_amarelo.calcular_posicao(2.12)
236+
self.assertEqual(4, x_calculado)
237+
self.assertEqual(3, y_calculado)
238+
188239
passaro_amarelo.colidir(porco, 2.12)
189240
self.assertEqual(DESTRUIDO, passaro_amarelo.status(2.12))
190-
# Deve ficar parado onde colidiu para qualquer tempo maior que o de colisão
191-
self.assertTupleEqual((4, 3), passaro_amarelo.calcular_posicao(2.13))
192-
self.assertTupleEqual((4, 3), passaro_amarelo.calcular_posicao(1000))
241+
# Deve ficar parado onde colidiu para qualquer tempo maior ou igual que o de colisão
242+
x_calculado, y_calculado = passaro_amarelo.calcular_posicao(2.12)
243+
self.assertEqual(4, x_calculado)
244+
self.assertEqual(3, y_calculado)
245+
246+
x_calculado, y_calculado = passaro_amarelo.calcular_posicao(1000)
247+
self.assertEqual(4, x_calculado)
248+
self.assertEqual(3, y_calculado)
193249

194250
def teste_lacamento_vertical(self):
195251
passaro_amarelo = PassaroAmarelo(1, 1)
196252
passaro_amarelo.lancar(90, 2) # passaro lancado a 90 graus no tempo 2 segundos
197253

254+
# função auxiliar que mantém x fixo com valor 1, status Ativo, variando apenas o tempo e a posição y
198255
def assert_vertical(y_local, tempo):
199256
self.assert_passaro_posicao(1, y_local, ATIVO, passaro_amarelo, tempo)
200257

‎testes/fase_testes.py‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -169,6 +169,7 @@ def criar_fase_exemplo():
169169

170170
for i in range(86):
171171
fase_exemplo.calcular_pontos(i / 10)
172+
return fase_exemplo
172173

173174

174175
if __name__ == '__main__':

0 commit comments

Comments
 (0)