def test_restar_correcto(self):
calculadora = Calculadora()
op1 = 3
op2 = 2
res_esperada = 1
res_obtenida = calculadora.restar(op1, op2)
self.assertEqual(res_esperada, res_obtenida)
def test_sumar_int_str(self):
calculadora = Calculadora()
op1 = "3"
op2 = 2
res_esperada = None
res_obtenida = calculadora.sumar(op1, op2)
self.assertEqual(res_esperada, res_obtenida, "Hay error")
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)
def test_restar_negativo(self):
calculadora = Calculadora()
op1 = 2
op2 = 4
res_esperada = -2
res_obtenida = calculadora.restar(op1, op2)
self.assertEqual(res_esperada, res_obtenida)
def Iniciar_menu(self):
opcion = 0
self.calculadora1 = Calculadora()
while opcion != 5:
print("\n por favor ingrese una opcion: \n")
print(" 1: sumar \n"
" 2: restar \n"
" 3: multiplicar \n"
" 4: dividir \n"
" 5: salir \n")
try:
opcion = int(input())
if opcion == 1:
self.calculadora1.suma()
elif opcion == 2:
self.calculadora1.resta()
elif opcion == 3:
self.calculadora1.producto()
else:
if opcion == 4:
self.calculadora1.division()
except ValueError:
print("\n**********opcion invalida**********\n")
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 multiplicacion(valor_1: int, valor_2: int):
c = Calculadora()
c.valor_1 = valor_1
c.valor_2 = valor_2
c.multiplicar()
return str(c.resultado)
def resta(valor_1: int, valor_2: int):
c = Calculadora()
c.valor_1 = valor_1
c.valor_2 = valor_2
c.restar()
return str(c.resultado)
def test_sumar_strings(self):
calculadora = Calculadora()
op1 = "3"
op2 = "2"
res_esperada = "5"
res_obtenida = calculadora.sumar(op1, op2)
self.assertEqual(res_esperada, res_obtenida, "Hay error")
def test_Calculadora_1_add_1_(self):
calc = Calculadora()
calc.ingresar('1')
calc.ingresar('+')
calc.ingresar('1')
calc.ingresar('=')
self.assertEqual(calc.display(),'2')
def test_Calculadora_10_div_5_(self):
calc = Calculadora()
calc.ingresar('1')
calc.ingresar('0')
calc.ingresar('/')
calc.ingresar('5')
calc.ingresar('=')
def test_Calculadora_2_x_2_(self):
calc = Calculadora()
calc.ingresar('2')
calc.ingresar('*')
calc.ingresar('2')
calc.ingresar('=')
self.assertEqual(calc.display(),'4')
def operacoes(a, b, operacao):
calculator = Calculadora()
valor = calculator.realiza_calculo(a, b, operacao)
return render_template("calculadora.html",
operacao=operacao,
a=a,
b=b,
valor=valor)
def setUp(self):
self.values_a = [i for i in range(1, 100)]
self.values_b = [i for i in range(1, 100)]
self.calculadoras = []
for a in self.values_a:
for b in self.values_b:
self.calculadoras.append(Calculadora(a, b))
def runOperation(self):
classCalculadora = Calculadora()
if (self.operacao == 1 ):
result = classCalculadora.somar(self.a, self.b)
if (self.operacao == 2 ):
result = classCalculadora.subtrair(self.a, self.b)
return "\nRespostado da operação é: " + str(result)
def test_sumar_correcto(self):
calculadora = Calculadora()
op1 = 3
op2 = 2
res_obtenida = calculadora.sumar(op1, op2)
res_esperada = 5
self.assertEqual(
res_obtenida, res_esperada,
"Suma incorrecta: op1:{} op2:{} r_obtenido:{} r_esperado:{}".
format(op1, op2, res_obtenida, res_esperada))
def adicionar_operacoes_test(self):
calculadora = Calculadora()
operacao = OperacaoMock()
calculadora.adicionar_operacao('+', operacao)
self.assertDictEqual({'+': operacao}, calculadora.operacoes)
subtracao = OperacaoMock()
calculadora.adicionar_operacao('-', subtracao)
self.assertDictEqual({
'+': operacao,
'-': subtracao
}, calculadora.operacoes)
def contador_letras(lista_palavras):
contador = []
for x in lista_palavras:
quantidade = len(x)
contador.append(quantidade)
return contador
if __name__ == '__main__':
lista_palavras = contador_letras(lista)
print("total letras po palavras de lista: {}".format(total_letras))
calculadora = Calculadora(5, 19)
print(calculadora.somA)
def teste_soma(self):
calc = Calculadora()
result = calc.somar(-20, 40)
self.assertEqual(20, result
def test_sub(self):
calc = Calculadora()
result = cal.subtrair(40,20)
self.assertEqual(20, result)
if __name__ == '__name__':
print(unittest.main())
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 calc():
operacao = request.args.get('oper', default="soma", type=str)
a = request.args.get('a', default=0.0, type=float)
b = request.args.get('b', default=0.0, type=float)
print(operacao, a, b)
calc = Calculadora()
resultado = 0.0
if operacao == "soma":
resultado = calc.soma(a, b)
return jsonify(resultado=resultado)
def __init__(self, nombre, capital_prestado, meses,
TIN): # el TIN es el euríbor + diferencial
self.nombre = nombre
self.capital_prestado = capital_prestado
self.total_de_meses = meses # total de cuotas/meses a pagar
self.TIN = TIN
self.interés_efectivo_mensual = TIN / 1200 # tipo interés mensual efectivo. Divido por 12 y por 100 para convertir el porciento
self.es_hipoteca_revisada = False
self.meses_reales = meses # si la hipoteca se revisa, estos serán los que realmente apliquen hasta la revisión
self.calculadora = Calculadora()
self.cuota = self.calculadora.cuota(self.capital_prestado,
self.interés_efectivo_mensual,
self.total_de_meses)
def calcular_resultado_test(self):
calculadora = Calculadora()
calculadora.param1 = 5
calculadora.param2 = 4
calculadora.sinal_de_operacao = '$'
operacao_mock = OperacoMockComResultado()
calculadora.adicionar_operacao('$', operacao_mock)
resultado = calculadora.calcular_resultado()
self.assertEqual(1, operacao_mock.executou)
self.assertEqual(20, resultado)
calculadora.param1 = 6
calculadora.param2 = 4
resultado = calculadora.calcular_resultado()
self.assertEqual(2, operacao_mock.executou)
self.assertEqual(24, resultado)
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_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))
class TesteCalculadora(unittest.TestCase):
calc = Calculadora()
def testeSoma(self):
result = self.calc.soma(2, 2)
self.assertEqual(result, 4)
def testeSub(self):
result = self.calc.subtracao(5, 1)
self.assertEqual(result, 4)
def testeMult(self):
result = self.calc.multiplicacao(2, 4)
self.assertEqual(result, 8)
def testeDivi(self):
result = self.calc.divisao(4, 2)
self.assertEqual(result, 2)
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.calculadora = Calculadora(-5, 5)
with self.assertRaises(ValueError) as contexto:
self.calculadora.multiplicar(2, 3)
self.assertEqual("Se superó el límite superior",
str(contexto.exception))
def main():
print("""
Essa aplicao tem como finalidade demonstrar os valores que serao gastos
com combustivel durante uma viagem, com base no contador so seu veiculo, e
com a distancia determinada por voce
""")
print("Os combustiveis disponiveis para esse calulo sao:")
print(" Alcool")
print(" Diesel")
print(" Gasolina")
print(" ")
try:
distancia = float(input("Distância em Quilômetros a ser percorrida: "))
consumo = float(input("Consumo de combustivel do veiculo (Km/l): "))
calculo = Calculadora()
print(calculo.calcular_gasto(distancia, consumo))
except ValueError:
print("O valor recebido nao e valido")
def initBtn(self):
self.objCalc = Calculadora()
self.arrayNum = []
self.arrayOperator = []
print('testando init')
self.btn_one.clicked.connect(self.One)
self.btn_two.clicked.connect(self.Two)
self.btn_three.clicked.connect(self.Three)
self.btn_four.clicked.connect(self.Four)
self.btn_five.clicked.connect(self.Five)
self.btn_six.clicked.connect(self.Six)
self.btn_seven.clicked.connect(self.Seven)
self.btn_eight.clicked.connect(self.Eight)
self.btn_nine.clicked.connect(self.Nine)
self.btn_zero.clicked.connect(self.Zero)
self.btn_clear_all.clicked.connect(self.ClearAll)
self.btn_clear.clicked.connect(self.Clear)
self.btn_divide.clicked.connect(self.Divide)
self.btn_equal.clicked.connect(self.Equal)
self.btn_mult.clicked.connect(self.Mult)
self.btn_sub.clicked.connect(self.Sub)
self.btn_sum.clicked.connect(self.Sum)
def main():
print("""
Esta aplicação tem como finalidade demonstrar os valores que serão gastos
com combustível durante uma viagem, com base no consumo do seu veículo, e
com a distância determinada por você!
""")
print("Os combustíveis disponíveis para este cálculo são:")
print(" ° Álcool")
print(" ° Díesel")
print(" ° Gasolina")
print(" ")
comb1 = Combustivel("Gasolina", 4.80)
comb2 = Combustivel("Álcool", 3.80)
comb3 = Combustivel("Díesel", 3.90)
calc = Calculadora()
try:
comb1 = Combustivel("Gasolina", 4.80)
comb2 = Combustivel("Álcool", 3.80)
comb3 = Combustivel("Díesel", 3.90)
veiculo = Veiculo(
input("Distância em Quilometros a ser percorrida: "),
input("Consumo de combustível do veículo(km por lt)"))
print("""
O valor gasto será de:
Gasolina: R$ {}
Álcool: R$ {}
Díesel: R$ {}
""".format(calc.calcular_valor_gasto_combustivel(veiculo, comb1),
calc.calcular_valor_gasto_combustivel(veiculo, comb2),
calc.calcular_valor_gasto_combustivel(veiculo, comb3)))
except ValueError:
print("o valor não é válido!")
