def division(valor_1: int, valor_2: int):
c = Calculadora()
c.valor_1 = valor_1
c.valor_2 = valor_2
c.dividir()
return str(c.resultado)
def test_ler_historico(self):
entradas = [[2, 2], [2, 2], [2, 2], [2, 2]]
saidas = [4, 0, 4, 1]
calc = Calculadora()
calc.somar(entradas[0][0], entradas[0][1])
calc.subtrair(entradas[1][0], entradas[1][1])
calc.multiplicar(entradas[2][0], entradas[2][1])
calc.dividir(entradas[3][0], entradas[3][1])
historico = calc.ler_historico()
for i in range(len(saidas)):
assert saidas[i] == historico[i]
def test_dividir_entre_0(self):
calculadora = Calculadora()
op1 = 2
op2 = 0
res_esperada = None
res_obtenida = calculadora.dividir(op1, op2)
self.assertEqual(res_esperada, res_obtenida)
class CalculadoraTest(unittest.TestCase):
"""
* Calculadora receber dois números e aplica o cálculo desejado.
* Operações disponíveis:
* - somar
* - subtrair
* - multiplicar
* - dividir
"""
def setUp(self):
self.calculadora = Calculadora()
def testSomar(self):
self.assertEquals(self.calculadora.somar(1, 1), 2)
def testSubtrair(self):
self.assertEquals(self.calculadora.subtrair(1, 1), 0)
def testMultiplicar(self):
self.assertEquals(self.calculadora.multiplicar(2, 2), 4)
def testDividir(self):
self.assertEquals(self.calculadora.dividir(4, 2), 2)
def divicion(valor_1, valor_2):
c = Calculadora()
c.valor_1 = valor_1
c.valor_2 = valor_2
c.dividir()
return (str(c.valor_1)+" / "+ str(c.valor_2)+"="+ str(c.resultado))
def test_divisao(self):
value = Calculadora.dividir(10, 2)
self.assertEqual(5, value, "Houve problemas ao tentar dividir")
def test_dividir(self):
testes = [[10, 1, 10], [4, 2, 2]]
calc = Calculadora()
for i in range(len(testes)):
assert calc.dividir(testes[i][0], testes[i][1]) == testes[i][2]
def teste_div(self):
calc = Calculadora()
result = calc.dividir(10, 2)
self.assertEqual(5, result)
# Arquivo principal do programa.
from calculadora import Calculadora
# Do arquivo calculadora importe a classe Calculadora.
numero1 = float(input("Digite o primeiro número: "))
numero2 = float(input("Digite o segundo número: "))
myCalc = Calculadora(numero1, numero2) # Na variavel myClac
# cria um novo objeto do tipo Cauculadora, passando numero1
# e numero2 como parâmetros
op = input("Digite a operação matemática desejada( + - * / ): ")
if op == "+":
myCalc.somar() # Executa o método somar do obj myCalc
elif op == "-":
myCalc.subtrair() # Executa o método subtrair do obj myCalc
elif op == "*":
myCalc.multiplicar() # Executa o método multiplicar do obj myCalc
elif op == "/":
myCalc.dividir() # Executa o método dividir do obj myCalc
else:
print("Opção inválida!!! ")
# Se foi utilizado um operador válido
if op == "+" or op == "-" or op == "*" or op == "/":
print("O Resultado é ", myCalc.resultado) # imprime a propriedade
# resultado do objeto calc
class Test_Calculadora(unittest.TestCase):
def setUp(self):
self.calculadora = Calculadora(-100, 100)
def test_sumar_2_mas_2_da_4(self):
"""
Escenario: Sumar 2 más 2 da 4
Dado que tengo una calculadora
Y que el límite inferior es -100
Y que el límite superior es 100
Cuando sumo 2 más 2
Entonces el resultado es 4
"""
resultado = self.calculadora.sumar(2, 2)
self.assertEqual(4, resultado)
def test_sumar_5_mas_7_da_12(self):
"""
Escenario: Sumar 5 más 7 da 12
Dado que tengo una calculadora
Y que el límite inferior es -100
Y que el límite superior es 100
Cuando sumo 5 más 7
Entonces el resultado es 12
"""
self.fail("Test no implementado")
def test_sumar_es_conmutativa(self):
"""
Escenario: La suma es conmutativa
Dado que tengo una calculadora
Y que el límite inferior es -100
Y que el límite superior es 100
Cuando sumo 3 más 5
Y sumo 5 más 3
Entonces ambos resultados son iguales
"""
self.fail("Test no implementado")
def test_sumar_numeros_negativos(self):
"""
Escenario: La suma de números negativos da por resultado otro número negativo
Dado que tengo una calculadora
Y que el límite inferior es -100
Y que el límite superior es 100
Cuando sumo -3 y -5
Entonces el resultado es -8
"""
self.fail("Test no implementado")
def test_restar_5_menos_3_da_2(self):
"""
Escenario: Se realiza una resta en la que el primer valor es mayor que el segundo
Dado que tengo una calculadora
Y que el límite inferior es -100
Y que el límite superior es 100
Cuando le resto 3 a 5
Entonces el resultado es 2
"""
resultado = self.calculadora.restar(5, 3)
self.assertEqual(2, resultado)
def test_restar_2_menos_3_da_menos_1(self):
"""
Escenario: Se realiza una resta en la que el segundo valor es mayor que el primero
Dado que tengo una calculadora
Y que el límite inferior es -100
Y que el límite superior es 100
Cuando le resto 3 a 2
Entonces el resultado es -1
"""
self.fail("Test no implementado")
def test_restar_no_es_conmutativa(self):
"""
Escenario: La resta no es conmutativa
Dado que tengo una calculadora
Y que el límite inferior es -100
Y que el límite superior es 100
Cuando resto 4 menos 2
Y resto 2 menos 4
Entonces los resultados son diferentes
"""
self.fail("Test no implementado")
def test_restar_menos_2_y_menos_4_da_2(self):
"""
Escenario: Se realiza una resta de dos valores negativos
Dado que tengo una calculadora
Y que el límite inferior es -100
Y que el límite superior es 100
Cuando resto -4 a -2
Entonces el resultado es 2
"""
self.fail("Test no implementado")
def test_dividir_2_por_2_da_1(self):
"""
Escenario: Se realiza una división entera de dos valores positivos
Dado que tengo una calculadora
Y que el límite inferior es -100
Y que el límite superior es 100
Cuando divido 2 por 2
Entonces el resultado es 1
"""
self.fail("Test no implementado")
def test_dividir_10_por_5_da_2(self):
"""
Escenario: Se realiza una división entera de dos valores positivos
Dado que tengo una calculadora
Y que el límite inferior es -100
Y que el límite superior es 100
Cuando divido 10 por 5
Entonces el resultado es 2
"""
self.fail("Test no implementado")
def test_dividir_10_por_menos_5_da_menos_2(self):
"""
Escenario: Se realiza una división entera de un positivo por un negativo
Dado que tengo una calculadora
Y que el límite inferior es -100
Y que el límite superior es 100
Cuando divido 10 por -5
Entonces el resultado es -2
"""
self.fail("Test no implementado")
def test_dividir_3_por_2_arroja_value_error(self):
"""
Escenario: Se realiza una división no entera
Dado que tengo una calculadora
Y que el límite inferior es -100
Y que el límite superior es 100
Cuando divido 3 por 2
Entonces la calculadora arroja un ValueError con el mensaje "La división debe ser entera"
"""
with self.assertRaises(ValueError) as contexto:
self.calculadora.dividir(3, 2)
self.assertEqual("La división debe ser entera", str(contexto.exception))
def test_dividir_3_por_0_arroja_zero_division_error(self):
"""
Escenario: Se realiza una división por cero
Dado que tengo una calculadora
Y que el límite inferior es -100
Y que el límite superior es 100
Cuando divido 3 por 0
Entonces la calculadora arroja un ZeroDivisionError
Y no importa el mensaje
"""
self.fail("Test no implementado")
def test_restar_pasa_limite_inferior_arroja_value_error(self):
"""
Escenario: La resta arroja por resultado un número más bajo que el límite inferior
Dado que tengo una calculadora
Y que el límite inferior es -5
Y que el límite superior es 5
Cuando resto 4 a -5
Entonces la calculadora arroja un ValueError con el mensaje "Se superó el límite inferior"
"""
self.calculadora = Calculadora(-5, 5)
with self.assertRaises(ValueError) as contexto:
self.calculadora.restar(-5, 4)
self.assertEqual("Se superó el límite inferior", str(contexto.exception))
def test_sumar_pasa_limite_superior_arroja_value_error(self):
"""
Escenario: La suma arroja por resultado un número más alto que el límite superior
Dado que tengo una calculadora
Y que el límite inferior es -5
Y que el límite superior es 5
Cuando sumo 5 más 4
Entonces la calculadora arroja un ValueError con el mensaje "Se superó el límite superior"
"""
self.fail("Test no implementado")
def test_multiplicar_2_por_2_da_4(self):
"""
Escenario: Se realiza una multiplicación de dos valores
Dado que tengo una calculadora
Y que el límite inferior es -100
Y que el límite superior es 100
Cuando se multiplica 2 por 2
Entonces el resultado es 4
"""
resultado = self.calculadora.multiplicar(2, 2)
self.assertEqual(4, resultado)
def test_multiplicar_4_por_3_da_12(self):
"""
Escenario: Se realiza una multiplicación de dos valores
Dado que tengo una calculadora
Y que el límite inferior es -100
Y que el límite superior es 100
Cuando se multiplica 4 por 3
Entonces el resultado es 12
"""
self.fail("Test no implementado")
def test_multiplicar_es_conmutativa(self):
"""
Escenario: La multiplicación es conmutativa
Dado que tengo una calculadora
Y que el límite inferior es -100
Y que el límite superior es 100
Cuando multiplico 3 por 5
Y multiplico 5 por 3
Entonces los resultados son iguales
"""
self.fail("Test no implementado")
def test_multiplicar_numeros_negativos(self):
"""
Escenario: Se realiza una multiplicación de dos valores negativos
Dado que tengo una calculadora
Y que el límite inferior es -100
Y que el límite superior es 100
Cuando multiplico -3 por -5
Entonces el resultado es 15
"""
self.fail("Test no implementado")
def test_multiplicar_pasa_limite_inferior_arroja_value_error(self):
"""
Escenario: La multiplicación arroja por resultado un número más bajo que el límite inferior
Dado que tengo una calculadora
Y que el límite inferior es -5
Y que el límite superior es 5
Cuando multiplico 2 por -3
Entonces la calculadora arroja un ValueError con el mensaje "Se superó el límite inferior"
"""
self.fail("Test no implementado")
def test_multiplicar_pasa_limite_superior_arroja_value_error(self):
"""
Escenario: La multiplicación arroja por resultado un número más alto que el límite superior
Dado que tengo una calculadora
Y que el límite inferior es -5
Y que el límite superior es 5
Cuando multiplico 2 por 3
Entonces la calculadora arroja un ValueError con el mensaje "Se superó el límite superior"
"""
self.fail("Test no implementado")
def test_primer_parametro_supera_limite_inferior_arroja_value_error(self):
"""
Escenario: El primer parámetro es menor que el límite inferior
Dado que tengo una calculadora
Y que el límite inferior es -5
Y que el límite superior es 5
Cuando el primer parámetro es menor al límite inferior
Entonces la calculadora arroja un ValueError con el mensaje "Primer parámetro supera el límite inferior"
"""
self.calculadora = Calculadora(-5, 5)
with self.assertRaises(ValueError) as contexto:
self.calculadora.validar_argumentos(-10, 2)
self.assertEqual("Primer parámetro supera el límite inferior", str(contexto.exception))
def test_segundo_parametro_supera_limite_inferior_arroja_value_error(self):
"""
Escenario: El segundo parámetro es menor que el límite inferior
Dado que tengo una calculadora
Y que el límite inferior es -5
Y que el límite superior es 5
Cuando el segundo parámetro es menor al límite inferior
Entonces la calculadora arroja un ValueError con el mensaje "Segundo parámetro supera el límite inferior"
"""
self.fail("Test no implementado")
def test_primer_parametro_supera_limite_superior_arroja_value_error(self):
"""
Escenario: El primer parámetro es mayor que el límite superior
Dado que tengo una calculadora
Y que el límite inferior es -5
Y que el límite superior es 5
Cuando el primer parámetro es mayor al límite superior
Entonces la calculadora arroja un ValueError con el mensaje "Primer parámetro supera el límite superior"
"""
self.fail("Test no implementado")
def test_segundo_parametro_supera_limite_superior_arroja_value_error(self):
"""
Escenario: El segundo parámetro es mayor que el límite superior
Dado que tengo una calculadora
Y que el límite inferior es -5
Y que el límite superior es 5
Cuando el segundo parámetro es mayor al límite superior
Entonces la calculadora arroja un ValueError con el mensaje "Segundo parámetro supera el límite superior"
"""
self.fail("Test no implementado")
def main():
calc = Calculadora()
print("2 + 4 = ", calc.somar(2, 4)) #6
print("3 - 5 = ", calc.subtrair(3, 5)) #-2
print("2 * 4 = ", calc.multiplicar(4, 5)) #20
print("2 / 4 = ", calc.dividir(100, 20)) #5
class CalculadoraTest(unittest.TestCase):
# Test fixtures
def setUp(self):
self.calc = Calculadora()
def tearDown(self):
pass
# Prueba del valor de inicio
def test_valor_inicio(self):
self.assertEqual(self.calc.get_resultado(), 0)
# Pruebas del método sumar
def test_suma_positivos_1(self):
self.calc.sumar(2, 2)
self.assertEqual(self.calc.get_resultado(), 4)
def test_suma_positivos_2(self):
self.calc.sumar(3, 3)
self.assertEqual(self.calc.get_resultado(), 6)
def test_suma_con_cero(self):
self.calc.sumar(0, 2)
self.assertEqual(self.calc.get_resultado(), 2)
def test_suma_negativos_1(self):
self.calc.sumar(-1, 2)
self.assertEqual(self.calc.get_resultado(), 1)
def test_suma_datos_invalidos(self):
self.calc.sumar('L', 2)
self.assertEqual(self.calc.get_resultado(), 'Datos inválidos')
# Pruebas del método restar
def test_resta_positivos_1(self):
self.calc.restar(2, 2)
self.assertEqual(self.calc.get_resultado(), 0)
def test_resta_positivos_2(self):
self.calc.restar(3, 1)
self.assertEqual(self.calc.get_resultado(), 2)
def test_resta_negativos_1(self):
self.calc.restar(-1, 2)
self.assertEqual(self.calc.get_resultado(), -3)
def test_resta_negativos_2(self):
self.calc.restar(0, -2)
self.assertEqual(self.calc.get_resultado(), 2)
def test_resta_datos_invalidos_1(self):
self.calc.restar('a', 1)
self.assertEqual(self.calc.get_resultado(), 'Datos inválidos')
def test_resta_datos_invalidos_2(self):
self.calc.restar(1, 'a')
self.assertEqual(self.calc.get_resultado(), 'Datos inválidos')
# Pruebas del método multiplicar
def test_multiplicacion_positivos_1(self):
self.calc.multiplicar(2, 2)
self.assertEqual(self.calc.get_resultado(), 4)
def test_multiplicacion_positivos_2(self):
self.calc.multiplicar(3, 3)
self.assertEqual(self.calc.get_resultado(), 9)
def test_multiplicacion_negativos_1(self):
self.calc.multiplicar(-3, 4)
self.assertEqual(self.calc.get_resultado(), -12)
def test_multiplicacion_negativos_2(self):
self.calc.multiplicar(3, -4)
self.assertEqual(self.calc.get_resultado(), -12)
def test_multiplicacion_negativos_3(self):
self.calc.multiplicar(-3, -4)
self.assertEqual(self.calc.get_resultado(), 12)
def test_multiplicacion_con_cero(self):
self.calc.multiplicar(0, 2)
self.assertEqual(self.calc.get_resultado(), 0)
def test_multiplicacion_datos_invalidos_1(self):
self.calc.multiplicar('a', 1)
self.assertEqual(self.calc.get_resultado(), 'Datos inválidos')
def test_multiplicacion_datos_invalidos_2(self):
self.calc.multiplicar(1, 'a')
self.assertEqual(self.calc.get_resultado(), 'Datos inválidos')
# Pruebas del método dividir
def test_division_positivos_1(self):
self.calc.dividir(4, 2)
self.assertEqual(self.calc.get_resultado(), 2.0)
def test_division_positivos_2(self):
self.calc.dividir(3, 3)
self.assertEqual(self.calc.get_resultado(), 1.0)
def test_division_positivos_3(self):
self.calc.dividir(3, 4)
self.assertEqual(self.calc.get_resultado(), 0.75)
def test_division_negativos_1(self):
self.calc.dividir(-3, 4)
self.assertEqual(self.calc.get_resultado(), -0.75)
def test_division_negativos_2(self):
self.calc.dividir(3, -4)
self.assertEqual(self.calc.get_resultado(), -0.75)
def test_division_negativos_3(self):
self.calc.dividir(-3, -4)
self.assertEqual(self.calc.get_resultado(), 0.75)
def test_division_cero_numerador(self):
self.calc.dividir(0, 2)
self.assertEqual(self.calc.get_resultado(), 0.0)
def test_division_cero_denominador(self):
self.calc.dividir(2, 0)
self.assertEqual(self.calc.get_resultado(),
'No se permiten divisiones entre 0')
def test_division_datos_invalidos_1(self):
self.calc.dividir('a', 1)
self.assertEqual(self.calc.get_resultado(), 'Datos inválidos')
def test_division_datos_invalidos_2(self):
self.calc.dividir(1, 'a')
self.assertEqual(self.calc.get_resultado(), 'Datos inválidos')
# Pruebas del método raiz
def test_raiz_positivo_1(self):
self.calc.raiz(2)
self.assertEqual(self.calc.get_resultado(), 1.4142135623730951)
def test_raiz_positivo_2(self):
self.calc.raiz(9)
self.assertEqual(self.calc.get_resultado(), 3.0)
def test_raiz_positivo_3(self):
self.calc.raiz(7)
self.assertEqual(self.calc.get_resultado(), 2.6457513110645907)
def test_raiz_negativo(self):
self.calc.raiz(-5)
self.assertEqual(self.calc.get_resultado(),
'No se permiten números negativos')
def test_raiz_datos_invalidos(self):
self.calc.raiz('a')
self.assertEqual(self.calc.get_resultado(), 'Datos inválidos')
# Pruebas del método potencia
def test_potencia_positivos_1(self):
self.calc.potencia(2, 3)
self.assertEqual(self.calc.get_resultado(), 8)
def test_potencia_positivos_2(self):
self.calc.potencia(9, 2)
self.assertEqual(self.calc.get_resultado(), 81)
def test_potencia_negativos_1(self):
self.calc.potencia(-5, 2)
self.assertEqual(self.calc.get_resultado(), 25)
def test_potencia_negativos_2(self):
self.calc.potencia(7, -2)
self.assertEqual(self.calc.get_resultado(), 0.02040816326530612)
def test_potencia_datos_invalidos_1(self):
self.calc.potencia('a', 2)
self.assertEqual(self.calc.get_resultado(), 'Datos inválidos')
def test_potencia_datos_invalidos_2(self):
self.calc.potencia(1, 'a')
self.assertEqual(self.calc.get_resultado(), 'Datos inválidos')
def division(valor_1, valor_2):
c = Calculadora()
c.valor_1 = valor_1
c.valor_2 = valor_2
c.dividir()
return int(c.resultado)
from calculadora import Calculadora c = Calculadora() c.valor_1 = 2 c.valor_2 = 5 c.sumar() print(str(c.valor_1) + " + " + str(c.valor_2) + " = " + str(c.resultado)) c.restar() print(str(c.valor_1) + " - " + str(c.valor_2) + " = " + str(c.resultado)) c.multiplicar() print(str(c.valor_1) + " * " + str(c.valor_2) + " = " + str(c.resultado)) c.dividir() print(str(c.valor_1) + " / " + str(c.valor_2) + " = " + str(c.resultado))
