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))