def test_xml(self):
"""Verifica integridade e corretude dos xmls gerados."""
for i in range(300):
data1 = RandomPoke()
data2 = RandomPoke()
dados1 = data1.gera()
dados2 = data2.gera()
poke1 = Pokemon(dados1)
poke2 = Pokemon(dados2)
# Testando to_xml
bs_poke1 = poke1.to_xml()
bs_poke2 = poke2.to_xml()
data_teste1 = xml_to_poke(bs_poke1)
data_teste2 = xml_to_poke(bs_poke2)
for i in range(9):
self.assertEqual(data_teste1[i], dados1[i])
self.assertEqual(data_teste2[i], dados2[i])
pos_atk = 9 # Posição da lista de ataques na lista de dados
atk_dados1 = dados1[pos_atk]
atk_dados2 = dados2[pos_atk]
atk_test1 = data_teste1[pos_atk]
atk_test2 = data_teste2[pos_atk]
for i in range(len(poke1.ataques)):
self.assertEqual(atk_dados1[i].nome, atk_test1[i].nome)
self.assertEqual(atk_dados1[i].typ, atk_test1[i].typ)
self.assertEqual(atk_dados1[i].acu, atk_test1[i].acu)
self.assertEqual(atk_dados1[i].pwr, atk_test1[i].pwr)
self.assertEqual(atk_dados1[i].pp, atk_test1[i].pp)
def teste_melhor_ataque(self):
""" Vamos testar se a função melhor_ataque dá realmente o
ataque com a melhor relação dano x acurácia testando
todos os ataques do pokemon atacante no pokemon defensor."""
for j in range(100):
# Cria um pokemon atacante e um defensor
dados_atk = RandomPoke()
dados_def = RandomPoke()
atacante = Pokemon(dados_atk.gera())
defensor = Pokemon(dados_def.gera())
melhor = melhor_ataque(atacante, defensor)
danos = []
if atacante.hp < atacante.hp_max / 5:
estado_critico = True
else:
estado_critico = False
for ataque in atacante.ataques:
if ataque.pp > 0 and estado_critico is False:
dano = ataque.calcula_dano(atacante, defensor, basico=True)
danos.append(dano * (ataque.acu * ataque.acu) / 10000)
elif ataque.pp > 0 and estado_critico is True:
dano = ataque.calcula_dano(atacante, defensor, basico=True)
# Caso não tire todo o hp, escolhe o que causa (em média) o maior
# dano usando a relação dano x acurácia.
if max(danos) < defensor.hp:
melhor_dano = melhor.calcula_dano(atacante,
defensor,
basico=True)
self.assertEqual(atacante.get_ataque(danos.index(max(danos))),
melhor, 1)
def setUp(self):
"""Inicializa os dois Pokémons aleatórios para os testes."""
sys.stdout = open(os.devnull, "w") # Suprime o output de batalha.py
sys.stderr = sys.stdout
self.a = RandomPoke()
self.b = RandomPoke()
self.poke1 = Pokemon(self.a.gera())
self.poke2 = Pokemon(self.b.gera())
self.struggle = Ataque(["Struggle", 0, 100, 50, 10])
def setUp(self):
"""Inicializa dados para teste."""
sys.stdout = open(os.devnull, "w") # Suprime o output de batalha.py
sys.stderr = sys.stdout
self.srv = Servidor(False)
self.srv.app.config["TESTING"] = True
self.app = self.srv.app.test_client()
self.data1 = RandomPoke()
self.data2 = RandomPoke()
self.dados1 = self.data1.gera()
self.dados2 = self.data2.gera()
self.poke1 = Pokemon(self.dados1)
self.poke2 = Pokemon(self.dados2)
def test_realiza_ataque_e_calcula_dano(self):
"""Verifica se ataque e suas consequências ocorrem sem problemas."""
batalha.input = Mock(return_value="ok")
# Geramos novos Pokémons para podermos realizar vários
# testes sem acabar com todo o HP deles.
for i in range(100):
a = RandomPoke()
b = RandomPoke()
poke3 = poke1 = Pokemon(a.gera())
poke4 = poke2 = Pokemon(b.gera())
# Assumindo que o ataque sempre vai acertar
with patch('batalha.random.uniform', return_value=1.0):
# Aqui começa o cálculo do dano
lvl = poke1.lvl
ataque = Ataque(a.gera_ataque())
if ataque.typ.especial:
atk = poke1.spc
dfs = poke2.spc
else:
atk = poke1.atk
dfs = poke2.dfs
pp = ataque.pp
hp = poke2.hp
base = ataque.pwr
eff = efetividade(ataque, poke2, False)
dano = (2 * lvl + 10) / 250 * atk / dfs * base + 2
dano *= (stab(ataque, poke1) * critico(poke1, eff) * eff *
aleatorio())
dano = int(dano)
#Testa o dano.calcula_dano
self.assertEqual(dano, calcula_dano(ataque, poke1, poke2))
if (dano > 0):
poke1.remove_hp(dano)
if ataque == self.struggle:
dano //= 2
poke2.remove(hp.dano)
# Verficamos se o Pokemon.realiza_ataque está
# aplicando corretamente o dano conforme a fórmula.
pokemon.input = Mock(return_value="\n")
poke3.realiza_ataque(ataque, poke4)
self.assertEquals(pp - 1, ataque.pp)
self.assertEquals(poke1.hp, poke3.hp)
self.assertEquals(poke2.hp, poke4.hp)
def test_critico(self):
"""Verifica se o cálculo de golpes críticos está funcionando OK."""
res = (2 * self.poke1.lvl + 5)/(self.poke1.lvl + 5)
chance = self.poke1.spd/512
maior_chance = chance + 0.001
valores_menores = []
valores_maiores = []
# Novamente usamos valores conhecidos para testar a unidade do
# batalha.critico que usa números pseudo-aleatórios. Os primeiros
# 100 valores serão menores que a chance e os outros 100, maiores.
for i in range(100):
valores_menores.append(random.uniform(0.0, chance))
valores_maiores.append(random.uniform(maior_chance, 1.0))
valores = valores_menores + valores_maiores
a = RandomPoke()
ataque = Ataque(a.gera_ataque())
with patch("batalha.random.uniform", side_effect=valores):
# Em cada loop, a iteração chamará dano.critico duas
# vezes, usando, então, dois valores do side_effect.
for i in range(50):
self.assertEqual(ataque.critico(self.poke1, 0), 1)
self.assertEqual(ataque.critico(self.poke1,
random.randint(1, 100)), res)
for i in range(50):
self.assertEqual(ataque.critico(self.poke1, 0), 1)
self.assertEqual(ataque.critico(self.poke1,
random.randint(1, 100)), 1)
"""
def test_efetividade(self):
"""Verifica se o cálculo de efetividade é feito corretamente."""
# Novamente geramos um novo Pokémon para podermos realizar vários
# testes com resultados diferentes.
for i in range(100):
a = RandomPoke()
poke1 = Pokemon(a.gera())
ataque = Ataque(a.gera_ataque())
# Esta é a fórmula para calcular efetividade
mult = ataque.typ.get_eff_contra(poke1.tipo1)
if poke1.tipo2.nome != "Blank":
mult *= ataque.typ.get_eff_contra(poke1.tipo2)
self.assertEquals(mult, ataque.efetividade(poke1, False))
def gera_poke(self):
"""Gera pokemons tais que os ataques estão ordenados em ordem
crescente de pwr e acu."""
t = RandomPoke()
dados = t.gera()
dados = dados[:9] #Tiramos a lista de ataques aleatórios
ataque = []
rand_num = randint(1, 97)
for i in range(4): #Criamos ataques ordenados
ataque.append(
self.gera_ataque(i + rand_num, i + rand_num, randint(1, 255)))
ataques = [Ataque(ataque[i]) for i in range(4)]
dados.append(ataques)
poke = Pokemon(dados) #Agora nosso pokemón contém os ataques ordenados
return poke
def setUp(self):
sys.stdout = open(os.devnull, "w") # Suprime o output de batalha.py
sys.stderr = sys.stdout
self.a = RandomPoke()
self.poke1 = Pokemon(self.a.gera())
def setUp(self):
"""Inicializa o teste."""
sys.stdout = open(os.devnull, 'w') # Suprime o output de batalha.py
self.ctrl = RandomPoke()
self.test = Pokemon(self.ctrl.gera())