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)
class PruebasCalculadora(unittest.TestCase):
def setUp(self):
self.calc = Calculadora()
def test_potencia(self):
self.assertEqual(self.calc.potencia(2,3), 8)
self.assertEqual(self.calc.potencia(-2,3), -8)
def test_resta(self):
resta = self.calc.resta(10, 4)
print "Resta:",resta
self.assertEqual(resta, 6)
def test_division(self):
self.assertEqual(self.calc.division(10,5), 2)
def calcular_resultado_test(self):
calculadora = Calculadora()
calculadora.param1 = 5
calculadora.param2 = 4
calculadora.sinal_de_operacao = '$'
operacao_mock = OperacaoMockComResultado()
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.assertTrue(2, operacao_mock.executou)
self.assertEqual(24,resultado)
class CalculadoraTest(unittest.TestCase): def setUp(self): self.calc = Calculadora() def test_valor_de_inicio_igual_a_cero(self): self.assertEquals(self.calc.obtener_resultado(), 0) def test_sumar_2_mas_2_igual_4(self): self.calc.suma(2, 2) self.assertEquals(self.calc.obtener_resultado(), 4) def test_restar_2_menos_2_igual_0(self): self.calc.resta(2, 2) self.assertEquals(self.calc.obtener_resultado(), 0) def tearDown(self): pass
# 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
from calculadora import Calculadora, Calculadora_v2
from user import User
c = Calculadora(128, 2)
print('Soma:', c.soma())
c2 = Calculadora_v2()
print('Soma:', c2.soma(1, 1))
u1 = User('Regis', 35)
u1.save()
u2 = User('Fabio', 20)
u2.save()
print(User.all())
'3-12':[0,4,8],
'3-2':[0,1,8],
'3-3':[0,2,8],
'3-4':[0,1,8],
'3-5':[0,2,8],
'3-6':[0,4,8],
'3-7':[0,2,8],
from calculadora import Calculadora
from thrift import Thrift
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
transport = TSocket.TSocket('localhost', 9090)
transport = TTransport.TBufferedTransport(transport)
protocol = TBinaryProtocol.TBinaryProtocol(transport)
# creamos el cliente
client = Calculadora.Client(protocol)
transport.open()
print('Hacemos ping al server')
client.ping()
resultado = client.suma(1, 1)
print('1 + 1 = ' + str(resultado))
resultado = client.resta(1, 1)
print('1 - 1 = ' + str(resultado))
transport.close()
class TestCalculadora(unittest.TestCase):
def setUp(self):
self.calc = Calculadora()
def test_valor_de_inicio_igual_a_cero(self):
self.assertEquals(self.calc.resultado(), 0)
from calculadora import Calculadora
if __name__ == '__main__':
calc = Calculadora()
# -*- coding: utf-8 -*-
from calculadora import Calculadora
c = Calculadora(128, 2)
print('Soma:', c.soma())
print('Subtração:', c.subtrai())
print('Multiplicação:', c.multiplica())
print('Divisão:', c.divide())
c.a = 12
c.b = 42
print(c.soma())
class CalculadoraTest(unittest.TestCase):
def setUp(self):
self.operaciones = Calculadora()
def test_sumar_2_mas_2_igual_4(self):
self.operaciones.suma(2, 2)
self.assertEquals(self.operaciones.obtener_resultado(), 4)
def test_sumar_1_mas_12_igual_13(self):
self.operaciones.suma(1, 12)
self.assertEquals(self.operaciones.obtener_resultado(), 13)
def test_sumar_3_mas_3_igual_6(self):
self.operaciones.suma(3, 3)
self.assertEquals(self.operaciones.obtener_resultado(), 6)
def test_sumar_menos1_mas_2_igual_1(self):
self.operaciones.suma(-1, 2)
self.assertEquals(self.operaciones.obtener_resultado(), 1)
def test_sumas_l_mas_2_igual_dato_invalido(self):
self.operaciones.suma('L', 2)
self.assertEquals(self.operaciones.obtener_resultado(),
'datos incorrectos')
def test_valor_de_inicio_es_igual_a_cero(self):
self.operaciones.suma(0, 2)
self.assertEquals(self.operaciones.obtener_resultado(),
'No se aceptan ceros')
def test_no_se_aceptan_numeros_mayores_a_diezmil(self):
self.operaciones.suma(5, 10001)
self.assertEquals(self.operaciones.obtener_resultado(),
'No se aceptan numeros mayores a 10000')
def test_restar_5_menos_4_igual_1(self):
self.operaciones.resta(5, 4)
self.assertEquals(self.operaciones.obtener_resultado(), 1)
def test_restar_3_menos_3_igual_0(self):
self.operaciones.resta(3, 3)
self.assertEquals(self.operaciones.obtener_resultado(), 0)
def test_restar_segundo_numero_mayor(self):
self.operaciones.resta(2, 5)
self.assertEquals(self.operaciones.obtener_resultado(),
'El segundo numero no debe ser mayor al primero')
def test_restar_8_menos_N_datos_invalidos(self):
self.operaciones.resta(8, 'N')
self.assertEquals(self.operaciones.obtener_resultado(),
'datos incorrectos')
def test_multiplicar_3_por_2_igual_6(self):
self.operaciones.multiplicacion(3, 2)
self.assertEquals(self.operaciones.obtener_resultado(), 6)
def test_multiplicar_menos2_por_2_igual_menos4(self):
self.operaciones.multiplicacion(-2, 2)
self.assertEquals(self.operaciones.obtener_resultado(), -4)
def test_multiplicar_menos2_por_menos2_igual_4(self):
self.operaciones.multiplicacion(-2, -2)
self.assertEquals(self.operaciones.obtener_resultado(), 4)
def test_multiplicar_0_por_5_no_se_acepta(self):
self.operaciones.multiplicacion(0, 5)
self.assertEquals(self.operaciones.obtener_resultado(),
'No se aceptan ceros')
def test_multiplicar_R_por_7_datos_incorrectos(self):
self.operaciones.multiplicacion('R', 7)
self.assertEquals(self.operaciones.obtener_resultado(),
'datos incorrectos')
def test_division_4_entre_2_igual_2(self):
self.operaciones.division(4, 2)
self.assertEquals(self.operaciones.obtener_resultado(), 2)
def test_division_1_entre_10_igual_0(self):
self.operaciones.division(1, 10)
self.assertEquals(self.operaciones.obtener_resultado(), 0)
def test_divison_H_entre_1_datos_incorrecots(self):
self.operaciones.division('H', 1)
self.assertEquals(self.operaciones.obtener_resultado(),
'datos incorrectos')
def test_division_1_entre_0_indeterminacion(self):
self.operaciones.division(1, 0)
self.assertEquals(self.operaciones.obtener_resultado(),
'Indeterminacion')
def test_division_1_entre_menos1_igual_menos1(self):
self.operaciones.division(1, -1)
self.assertEquals(self.operaciones.obtener_resultado(), -1)
def test_raiz_de_5_igual_2punto2(self):
self.operaciones.raiz(5, 0)
self.assertEquals(self.operaciones.obtener_resultado(), 2.2)
def test_raiz_de_0_igual_0punto0(self):
self.operaciones.raiz(0, 0)
self.assertEquals(self.operaciones.obtener_resultado(), 0.0)
def test_raiz_de_menos1_no_se_pueden_negativos(self):
self.operaciones.raiz(-1, 0)
self.assertEquals(self.operaciones.obtener_resultado(),
'No se puede sacar raiz de un numero negativo')
def test_raiz_de_L_datos_incorrectos(self):
self.operaciones.raiz('L', 0)
self.assertEquals(self.operaciones.obtener_resultado(),
'datos incorrectos')
def test_potencia_de_5_al_cuadrado_igual_25(self):
self.operaciones.potencia(5, 2)
self.assertEquals(self.operaciones.obtener_resultado(), 25)
def test_potencia_de_3_a_la_j_datos_incorrectos(self):
self.operaciones.potencia(3, 'j')
self.assertEquals(self.operaciones.obtener_resultado(),
'datos incorrectos')
def test_potencia_de_2_a_la_menos2_no_se_pueden_negativos(self):
self.operaciones.potencia(2, -2)
self.assertEquals(self.operaciones.obtener_resultado(),
'No se aceptan negativos')
def test_potencia_de_3_a_la_11_no_se_pueden_mayores_a_10(self):
self.operaciones.potencia(3, 11)
self.assertEquals(self.operaciones.obtener_resultado(),
'No se aceptan exponentes mayores a 10')
def test_edad_menor_a_0_no_existes(self):
self.operaciones.edad(-1)
self.assertEquals(self.operaciones.obtener_resultado(), 'No existes')
def test_edad_menor_a_13_eres_ninio(self):
self.operaciones.edad(10)
self.assertEquals(self.operaciones.obtener_resultado(), 'Eres ninio')
def test_edad_menor_a_18_eres_adolescente(self):
self.operaciones.edad(15)
self.assertEquals(self.operaciones.obtener_resultado(),
'Eres adolescente')
def test_edad_menor_a_65_eres_adulto(self):
self.operaciones.edad(33)
self.assertEquals(self.operaciones.obtener_resultado(), 'Eres adulto')
def test_edad_menor_a_120_eres_adulto_mayor(self):
self.operaciones.edad(105)
self.assertEquals(self.operaciones.obtener_resultado(),
'Eres adulto mayor')
def test_edad_mayor_a_120_eres_mummra(self):
self.operaciones.edad(200)
self.assertEquals(self.operaciones.obtener_resultado(), 'Eres Mumm-Ra')
def dado_que_ingreso_los_numeros_group1_y_group2(step, num1, num2):
world.cal = Calculadora()
world.cal.suma(int(num1), int(num2))
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 testa_soma(self):
Calculadora.soma(1,1) |should| equal_to(2)
from calculadora import Calculadora
from comodo import Comodo
calculadora = Calculadora()
comodo = Comodo(input("Qual a largura do cômodo? "),
input("Qual a profundidade do cômodo? "))
# calculadora.area_paredes: float = 2 * (largura + profundidade) * altura
print("A área das paredes é:", calculadora.calcular_area_paredes(comodo))
# calculadora.area_teto: float = largura * profundidade
print("A Área do teto é:", calculadora.calcular_area_teto(comodo))
print("A litragem de tinta necessária é:",
calculadora.calcular_litragem_necessaria())
class Aplicacion():
def __init__(self):
self.dollar_saver = Save_dollar()
dollars = get_dollars()
self.dolar_blue = dollars['blue']
self.dolar_oficial = dollars['oficial']
self.calculadora = Calculadora(self.dolar_blue, self.dolar_oficial)
self.raiz = Tk()
self.raiz.geometry('600x400')
#defino la fuente
fuente = font.Font(weight='bold')
self.etiq1 = ttk.Label(self.raiz, text="Dolar Oficial:", font=fuente)
self.cantidad = StringVar()
self.ctext1 = ttk.Entry(self.raiz,
textvariable=self.cantidad,
width=10)
self.dolarToConvert = StringVar()
self.convertDolar = ttk.Entry(self.raiz,
textvariable=self.dolarToConvert)
# Impide que los bordes puedan desplazarse para
# ampliar o reducir el tamaño de la ventana 'self.raiz':
self.raiz.resizable(width=False, height=False)
self.raiz.title('Ver info')
# Define el widget Text 'self.tinfo ' en el que se
# pueden introducir varias líneas de texto:
self.tinfo = Text(self.raiz, width=70, height=10)
# Sitúa la caja de texto 'self.tinfo' en la parte
# superior de la ventana 'self.raiz':
self.tinfo.pack(side=TOP)
self.ctext1.pack(side=TOP, fill=X, expand=False, padx=5, pady=5)
self.boton_cal_dollar = ttk.Button(self.raiz,
text='calc Dollar',
command=self.calc_dollar)
self.boton_cal_dollar.pack(side=TOP)
self.convertDolar.pack(side=TOP, fill=X, expand=False, padx=5, pady=5)
self.convert_dollar_button = ttk.Button(self.raiz,
text='convertir',
command=self.convert_dollar)
self.convert_dollar_button.pack(side=TOP)
# Define el widget Button 'self.binfo' que llamará
# al metodo 'self.verinfo' cuando sea presionado
self.bhistoric = ttk.Button(self.raiz,
text='Historico',
command=self.dol_historic)
# Coloca el botón 'self.binfo' debajo y a la izquierda
# del widget anterior
self.bhistoric.pack(side=LEFT)
self.save_today_dollar = ttk.Button(self.raiz,
text='save Dollar',
command=self.save_dollar)
self.save_today_dollar.pack(side=LEFT)
#dolar ahora
self.save_today_dollar = ttk.Button(self.raiz,
text='Dollar now',
command=self.dollar_now)
self.save_today_dollar.pack(side=LEFT)
#test
#self.save_today_dollar = ttk.Button(self.raiz,text='test',command=self.create_test)
#self.save_today_dollar.pack(side=LEFT)
# Define el botón 'self.bsalir'. En este caso
# cuando sea presionado, el método destruirá o
# terminará la aplicación-ventana 'self.raíz' con
# 'self.raiz.destroy'
self.bsalir = ttk.Button(self.raiz,
text='Salir',
command=self.raiz.destroy)
# Coloca el botón 'self.bsalir' a la derecha del
# objeto anterior.
self.bsalir.pack(side=LEFT)
# El foco de la aplicación se sitúa en el botón
# 'self.binfo' resaltando su borde. Si se presiona
# la barra espaciadora el botón que tiene el foco
# será pulsado. El foco puede cambiar de un widget
# a otro con la tecla tabulador [tab]
self.bhistoric.focus_set()
self.raiz.mainloop()
def fill_textbox(self, data):
self.tinfo.delete(1.0, END)
self.tinfo.insert(1.0, str(data))
def convert_dollar(self):
toConvert = float(self.convertDolar.get())
toConvert = (self.dolar_oficial.price * float(1.3)) * toConvert
self.fill_textbox("Son pesos: " + str(round(toConvert, 3)))
#self.fill_textbox(toConvert)
def calc_dollar(self):
dolar_billete = self.ctext1.get()
final = self.calculadora.calcular(float(dolar_billete))
final = 'Pagas en blue \n' + str(final)
self.fill_textbox(final)
def dol_historic(self):
lista_dollar = self.dollar_saver.read_all()
text = ''
for dollar in lista_dollar:
text += dollar.name + ': ' + str(dollar.price) + ', fecha: ' + str(
dollar.date)
text += '\n'
self.fill_textbox(text)
def save_dollar(self):
self.dollar_now()
allhistoric = self.dollar_saver.read_all()
try:
last_dollar_saved = allhistoric[len(allhistoric) - 1]
if last_dollar_saved is not None:
if self.dolar_blue.date > last_dollar_saved.date:
self.dollar_saver.append_dollar(self.dolar_blue)
self.fill_textbox('new dollar saved')
else:
#equals or less
if last_dollar_saved.price != self.dolar_blue.price:
print('sobre escribo el ultimo registro')
self.fill_textbox('sobre escribo el ultimo registro')
self.dollar_saver.update_last_one(self.dolar_blue)
else:
print('same price not update')
self.fill_textbox('same price not update')
else:
self.dollar_saver.append_dollar(self.dolar_blue)
except Exception:
traceback.print_exc(file=sys.stdout)
print('exception')
self.fill_textbox('not rebasing')
self.dollar_saver.save_dollar(self.dolar_blue)
def dollar_now(self):
dollars = get_dollars()
self.dolar_blue = dollars['blue']
self.dolar_oficial = dollars['oficial']
text = 'dolar now:\n'
text = text + dollars['blue'].name + ': ' + str(
dollars['blue'].price) + '\n'
text = text + dollars['oficial'].name + ': ' + str(
dollars['oficial'].price)
self.fill_textbox(text)
def create_test(self):
aDate = datetime.date(2019, 6, 15)
dolar1 = Dollar('dolar a', '120.0', aDate)
aDate2 = datetime.date(2019, 6, 16)
dolar2 = Dollar('dolar b', '122.0', aDate2)
self.dollar_saver.append_dollar(dolar1)
self.dollar_saver.append_dollar(dolar2)
def dado_que_resto_los_numeros_group1_y_group2(step, num1, num2):
world.cal = Calculadora()
world.cal.resta(int(num1), int(num2))
class CalculadoraTest(unittest.TestCase):
def setUp(self):
self.calc = Calculadora()
def test_valor_de_inicio_es_igual_a_cero(self):
self.assertEquals(self.calc.obtener_resultado(), 0)
def test_sumar_2_mas_Igual_4(self):
self.calc.suma(2, 2)
self.assertEquals(self.calc.obtener_resultado(), 4)
def test_sumar_3s(self):
self.calc.suma(3, 3)
self.assertEquals(self.calc.obtener_resultado(), 6)
def test_numero_negativo(self):
self.calc.suma(-1, 2)
self.assertEquals(self.calc.obtener_resultado(), 1)
def test_parametro_incorrecto_suma(self):
self.calc.suma('L', 2)
self.assertEquals(self.calc.obtener_resultado(), 'Datos incorrectos')
def test_restar_2_menos_2(self):
self.calc.resta(2, 2)
self.assertEquals(self.calc.obtener_resultado(), 0)
def test_restar_3_menos_4(self):
self.calc.resta(3, 4)
self.assertEquals(self.calc.obtener_resultado(), -1)
def test_restar_negativos(self):
self.calc.resta(-2, -3)
self.assertEquals(self.calc.obtener_resultado(), 1)
def test_parametro_incorrecto_resta(self):
self.calc.resta('R', 0)
self.assertEquals(self.calc.obtener_resultado(), 'Datos incorrectos')
def test_multiplicar_2_por_3(self):
self.calc.multiplicacion(2, 3)
self.assertEquals(self.calc.obtener_resultado(), 6)
def test_multiplicar_por_0(self):
self.calc.multiplicacion(2, 0)
self.assertEquals(self.calc.obtener_resultado(), 0)
def test_multiplicar_por_negativo(self):
self.calc.multiplicacion(2, -5)
self.assertEquals(self.calc.obtener_resultado(), -10)
def test_multiplicar_numero_mayor_a_10000(self):
self.calc.multiplicacion(2000000, 10000)
self.assertEquals(self.calc.obtener_resultado(),
'Numero muy grande no se puede computar')
def test_parametro_incorrecto_multiplicacion(self):
self.calc.multiplicacion('R', 3)
self.assertEquals(self.calc.obtener_resultado(), 'Datos incorrectos')
def test_dividir_2_entre_2(self):
self.calc.division(2, 2)
self.assertEquals(self.calc.obtener_resultado(), 1)
def test_dividir_0(self):
self.calc.division(2, 0)
self.assertEquals(self.calc.obtener_resultado(),
'No se puede dividir entre cero')
def test_dividir_entre_negativo(self):
self.calc.division(10, -2)
self.assertEquals(self.calc.obtener_resultado(), -5)
def test_dividision_parametro_incorrecto(self):
self.calc.division(2, 'D')
self.assertEquals(self.calc.obtener_resultado(), 'Datos incorrectos')
def test_potencia_2_a_la_2(self):
self.calc.potencia(2, 2)
self.assertEquals(self.calc.obtener_resultado(), 4)
def test_potencia_3_a_la_3(self):
self.calc.potencia(3, 3)
self.assertEquals(self.calc.obtener_resultado(), 27)
def test_potencia_negativo(self):
self.calc.potencia(-1, 2)
self.assertEquals(self.calc.obtener_resultado(), 1)
def test_potencia_parametro_incorrecto(self):
self.calc.potencia(2, 'P')
self.assertEquals(self.calc.obtener_resultado(), 'Datos incorrectos')
def test_potencia_numero_grande(self):
self.calc.potencia(250000000, 10)
self.assertEquals(self.calc.obtener_resultado(),
'Numero muy grande no se puede computar')
def test_raiz_4(self):
self.calc.raiz(4)
self.assertEquals(self.calc.obtener_resultado(), 2)
def test_raiz_negativa(self):
self.calc.raiz(-1)
self.assertEquals(self.calc.obtener_resultado(),
'No se puede calcular numeros imaginarios')
def test_raiz_parametro_incorrecto(self):
self.calc.raiz('R')
self.assertEquals(self.calc.obtener_resultado(), 'Datos incorrectos')
def tearDown(self):
pass
def dado_que_tengo_el_numero_group1_y_group1(step, num1, num2):
cal = Calculadora()
world.resultado = cal.suma(int(num1),int(num2))
def setUp(self):
self.calc = Calculadora()
self.datosIncorrectos = 'Datos incorrectos'
def test_inicial(self):
calc = Calculadora()
self.assertEqual(0, calc.value())
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)
if __name__ == "__main__":
import sys
app = QtWidgets.QApplication(sys.argv)
Dialog = QtWidgets.QDialog()
ui = Ui_Dialog()
ui.setupUi(Dialog)
Dialog.show()
obj_calc = Calculadora()
ui.setOperator('')
ui.initBtn()
sys.exit(app.exec_())
class CalculadoraTest(unittest.TestCase):
def setUp(self):
self.calc = Calculadora()
def test_valor_de_inicio_es_igual_a_cero(self):
self.assertEquals(self.calc.obtener_resultado(), 0)
def test_sumar_2_mas_2_igual_a_4(self):
self.calc.suma(2,2)
self.assertEquals(self.calc.obtener_resultado(), 4)
def test_sumar_3_mas_3_igual_a_6(self):
self.calc.suma(3,3)
self.assertEquals(self.calc.obtener_resultado(), 6)
def test_sumar_menos_1_mas_2_igual_a_1(self):
self.calc.suma(-1,2)
self.assertEquals(self.calc.obtener_resultado(), 1)
def test_sumar_L_mas_2_igual_a_datos_incorrectos(self):
self.calc.suma('L',2)
self.assertEquals(self.calc.obtener_resultado(), 'datos incorrectos')
def test_restar_3_menos_2_igual_a_1(self):
self.calc.resta(3,2)
self.assertEquals(self.calc.obtener_resultado(), 1)
def test_restar_5_menos_6_igual_a_menos_1(self):
self.calc.resta(5,6)
self.assertEquals(self.calc.obtener_resultado(), -1)
def test_restar_J_menos_6_igual_a_datos_incorrectos(self):
self.calc.resta('J',6)
self.assertEquals(self.calc.obtener_resultado(), 'datos incorrectos')
def test_multiplicar_8_por_0_igual_a_0(self):
self.calc.multiplicacion(8,0)
self.assertEquals(self.calc.obtener_resultado(), 0)
def test_multiplicar_2_por_2_igual_a_4(self):
self.calc.multiplicacion(2,2)
self.assertEquals(self.calc.obtener_resultado(), 4)
def test_multiplicar_menos_3_por_menos_1_igual_a_3(self):
self.calc.multiplicacion(-3,-1)
self.assertEquals(self.calc.obtener_resultado(), 3)
def test_multiplicar_T_por_3_igual_a_datos_incorrectos(self):
self.calc.multiplicacion('T',3)
self.assertEquals(self.calc.obtener_resultado(), 'datos incorrectos')
def test_dividir_10_entre_2_igual_a_5(self):
self.calc.division(10,2)
self.assertEquals(self.calc.obtener_resultado(), 5)
def test_dividir_8_entre_0_igual_a_No_sepuede_dividir(self):
self.calc.division(8,0)
self.assertEquals(self.calc.obtener_resultado(), 'no se puede dividir entre cero')
def test_dividir_R_entre_8_igual_a_datos_incorrectos(self):
self.calc.division('R',8)
self.assertEquals(self.calc.obtener_resultado(), 'datos incorrectos')
def test_potenciar_3_a_la_2_igual_a_9(self):
self.calc.potencia(3,2)
self.assertEquals(self.calc.obtener_resultado(), 9)
def test_potenciar_9_a_la_0_igual_a_1(self):
self.calc.potencia(9,0)
self.assertEquals(self.calc.obtener_resultado(), 1)
def test_potenciar_X_a_la_3_igual_a_datos_incorrectos(self):
self.calc.potencia('X',3)
self.assertEquals(self.calc.obtener_resultado(), 'datos incorrectos')
def test_raiz_cuadrada_de_9_igual_a_3(self):
self.calc.raiz2(9)
self.assertEquals(self.calc.obtener_resultado(), 3)
def test_raiz_cuadrada_de_16_igual_a_4(self):
self.calc.raiz2(16)
self.assertEquals(self.calc.obtener_resultado(), 4)
def test_raiz_cuadrada_de_G_igual_a_datos_incorrectos(self):
self.calc.raiz2('G')
self.assertEquals(self.calc.obtener_resultado(), 'datos incorrectos')
def setUp(self):
self.calc = Calculadora()
from calculadora import Calculadora
if __name__ == "__main__":
cal = Calculadora()
from calculadora import Calculadora
from comodo import Comodo
calc = Calculadora()
comodo = Comodo(input('Qual a largura do cômodo? '),
input("Qual a profundidade do cômodo? "))
print('A area das parede é:', calc.calcular_area_parede(comodo))
print('Area do teto é:', calc.calcula_area_teto(comodo))
print('A litragem de tinta nescessaria é:',
calc.calcular_litragem_necessaria())
def test_suma_dos_mas_dos(self):
calc = Calculadora()
self.assertEquals(4, calc.suma(2, 2))
from calculadora import Calculadora c = Calculadora() c.valor_1 = 2 c.valor_2 = 9 c.resta() #c.suma() #c.multiplicacion() #c.division() print(c.resultado)
def test_suma_dos_mas_tres(self):
calc = Calculadora()
self.assertEquals(5, calc.suma(2, 3))
from calculadora import Calculadora
calc = Calculadora()
print("Bem-vindo a Calculadora! Escolha uma das operações abaixo:");
escolha = 0
while (escolha != 5):
print("\n1) Soma")
print("2) Subtração")
print("3) Multiplicação")
print("4) Divisão")
print("5) Sair")
escolha = int(input());
if (escolha == 1):
num1 = int(input("\n1º Valor: "));
num2 = int(input("2º Valor: "));
print("Resultado da Soma: {}".format(calc.sum(num1,num2)))
print("\nDeseja fazer outra operação?")
elif (escolha == 2):
num1 = int(input("\n1º Valor: "));
num2 = int(input("2º Valor: "));
print("Resultado da Subtração: {}".format(calc.sub(num1,num2)))
print("\nDeseja fazer outra operação?")
elif (escolha == 3):
num1 = int(input("\n1º Valor: "));
num2 = int(input("2º Valor: "));
print("Resultado da Multiplicação: {}".format(calc.mul(num1,num2)))
print("\nDeseja fazer outra operação?")
from calculadora import Calculadora
from comodo import Comodo
calc = Calculadora()
comodo = Comodo(input('Qual a largura do cômodo?'),
input('Qual a profundidade do cômodo?'))
print('A área das paredes é:', calc.calcular_area_paredes(comodo))
print('A área do teto é:', calc.calcular_area_teto(comodo))
print('A litragem da tinta necessária é:', calc.calcular_litragem_necessaria())
if op_dcha == 'x':
result_mult *= pol[i+1].val
if op_izq == '/' and op_dcha != '/':
if pol[i-1].op_izq == 'x':
if result_div != 1:
result_div = pol[i].val
result_div = result_mult / result_div
result_parcial = result_div
else:
result_parcial += result_div
else:
if op_dcha == '/':
result_div /= pol[i+1].val
return result_parcial
if __name__ == '__main__':
handler = CalculadoraHandler()
processor = Calculadora.Processor(handler)
transport = TSocket.TServerSocket(host = '127.0.0.1', port = 9090)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
print('Iniciando servidor ...')
server.serve()
print ('Fin.')
from calculadora import Calculadora
from comodo import Comodo
#Criando um objeto calculadora
calc = Calculadora()
comodo = Comodo(input('Qual a largura do comodo?'),
input('Qual a profunidade do cômodo?'))
#calc.area_paredes= float = 2 * (largura + profundidade) * altura
print("A área das paredes é: ",
calc.calcular_area_paredes(comodo))
print('A área do teto é:',
calc.calcular_area_teto(comodo))
print('A litragem de tinta necessária é:',
calc.calcular_litragem_necessaria()
)
def __init__(self):
self.dollar_saver = Save_dollar()
dollars = get_dollars()
self.dolar_blue = dollars['blue']
self.dolar_oficial = dollars['oficial']
self.calculadora = Calculadora(self.dolar_blue, self.dolar_oficial)
self.raiz = Tk()
self.raiz.geometry('600x400')
#defino la fuente
fuente = font.Font(weight='bold')
self.etiq1 = ttk.Label(self.raiz, text="Dolar Oficial:", font=fuente)
self.cantidad = StringVar()
self.ctext1 = ttk.Entry(self.raiz,
textvariable=self.cantidad,
width=10)
self.dolarToConvert = StringVar()
self.convertDolar = ttk.Entry(self.raiz,
textvariable=self.dolarToConvert)
# Impide que los bordes puedan desplazarse para
# ampliar o reducir el tamaño de la ventana 'self.raiz':
self.raiz.resizable(width=False, height=False)
self.raiz.title('Ver info')
# Define el widget Text 'self.tinfo ' en el que se
# pueden introducir varias líneas de texto:
self.tinfo = Text(self.raiz, width=70, height=10)
# Sitúa la caja de texto 'self.tinfo' en la parte
# superior de la ventana 'self.raiz':
self.tinfo.pack(side=TOP)
self.ctext1.pack(side=TOP, fill=X, expand=False, padx=5, pady=5)
self.boton_cal_dollar = ttk.Button(self.raiz,
text='calc Dollar',
command=self.calc_dollar)
self.boton_cal_dollar.pack(side=TOP)
self.convertDolar.pack(side=TOP, fill=X, expand=False, padx=5, pady=5)
self.convert_dollar_button = ttk.Button(self.raiz,
text='convertir',
command=self.convert_dollar)
self.convert_dollar_button.pack(side=TOP)
# Define el widget Button 'self.binfo' que llamará
# al metodo 'self.verinfo' cuando sea presionado
self.bhistoric = ttk.Button(self.raiz,
text='Historico',
command=self.dol_historic)
# Coloca el botón 'self.binfo' debajo y a la izquierda
# del widget anterior
self.bhistoric.pack(side=LEFT)
self.save_today_dollar = ttk.Button(self.raiz,
text='save Dollar',
command=self.save_dollar)
self.save_today_dollar.pack(side=LEFT)
#dolar ahora
self.save_today_dollar = ttk.Button(self.raiz,
text='Dollar now',
command=self.dollar_now)
self.save_today_dollar.pack(side=LEFT)
#test
#self.save_today_dollar = ttk.Button(self.raiz,text='test',command=self.create_test)
#self.save_today_dollar.pack(side=LEFT)
# Define el botón 'self.bsalir'. En este caso
# cuando sea presionado, el método destruirá o
# terminará la aplicación-ventana 'self.raíz' con
# 'self.raiz.destroy'
self.bsalir = ttk.Button(self.raiz,
text='Salir',
command=self.raiz.destroy)
# Coloca el botón 'self.bsalir' a la derecha del
# objeto anterior.
self.bsalir.pack(side=LEFT)
# El foco de la aplicación se sitúa en el botón
# 'self.binfo' resaltando su borde. Si se presiona
# la barra espaciadora el botón que tiene el foco
# será pulsado. El foco puede cambiar de un widget
# a otro con la tecla tabulador [tab]
self.bhistoric.focus_set()
self.raiz.mainloop()
def dado_que_tengo_los_operandos_group1_y_group1(step, num1, num2):
world.cal = Calculadora()
world.operando1 = int(num1)
world.operando2 = int(num2)
def setUp(self):
self.operaciones = Calculadora()
from calculadora import Calculadora c = Calculadora() c.valor_1 = 5 c.valor_2 = 10 c.sumar() print(c.valor_1, '+', c.valor_2, '=', c.resultado) c.restar() print(c.valor_1, '-', c.valor_2, '=', c.resultado) c.multiplicar() print(c.valor_1, '*', c.valor_2, '=', c.resultado)
def setUp(self):
self.calc = Calculadora()
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 setUp(self):
self.calculadora = Calculadora(-100, 100)
class CalculadoraTest(unittest.TestCase):
def setUp(self):
self.calc = Calculadora()
self.datosIncorrectos = 'Datos incorrectos'
def test_valor_de_inicio_igual_a_cero(self):
self.assertEquals(self.calc.obtener_resultado(), 0)
def test_sumar_2_mas_2_igual_4(self):
self.calc.suma(2,2)
self.assertEquals(self.calc.obtener_resultado(), 4)
def test_sumar_3_mas_3_igual_6(self):
self.calc.suma(3,3)
self.assertEquals(self.calc.obtener_resultado(), 6)
def test_sumar_menos_uno_mas_2_igual_1(self):
self.calc.suma(-1,2)
self.assertEquals(self.calc.obtener_resultado(), 1)
def test_sumar_ele_mas_2_igual_datos_incorrectos(self):
self.calc.suma('L',2)
self.assertEquals(self.calc.obtener_resultado(), self.datosIncorrectos)
def test_restar_2_menos_2_igual_0(self):
self.calc.resta(2,2)
self.assertEquals(self.calc.obtener_resultado(), 0)
def test_restar_3_menos_9_igual_menos_6(self):
self.calc.resta(3,9)
self.assertEquals(self.calc.obtener_resultado(), -6)
def test_restar_menos_1_menos_2_igual_menos_3(self):
self.calc.resta(-1,2)
self.assertEquals(self.calc.obtener_resultado(), -3)
def test_restar_2_menos_10_igual_menos_8(self):
self.calc.resta(2,10)
self.assertEquals(self.calc.obtener_resultado(), -8)
def test_restar_uve_menos_2_igual_datos_incorrectos(self):
self.calc.resta('V',2)
self.assertEquals(self.calc.obtener_resultado(), self.datosIncorrectos)
def test_dividir_2_entre_2_igual_1(self):
self.calc.division(2,2)
self.assertEquals(self.calc.obtener_resultado(), 1)
def test_dividir_99_entre_5_igual_19(self):
self.calc.division(99,5)
self.assertEquals(self.calc.obtener_resultado(), 19)
def test_dividir_menos_88_entre_78_igual_menos_2(self):
self.calc.division(-88,78)
self.assertEquals(self.calc.obtener_resultado(), -2)
def test_dividir_0_entre_11_igual_0(self):
self.calc.division(0,11)
self.assertEquals(self.calc.obtener_resultado(), 0)
def test_dividir_10_entre_0_igual_division_no_definida(self):
self.calc.division(10,0)
self.assertEquals(self.calc.obtener_resultado(), 'La division por cero no esta definida')
def test_dividir_eme_entre_2_igual_datos_incorrectos(self):
self.calc.division('M',2)
self.assertEquals(self.calc.obtener_resultado(), self.datosIncorrectos)
def test_multiplicar_5_por_5_igual_25(self):
self.calc.multiplicacion(5,5)
self.assertEquals(self.calc.obtener_resultado(), 25)
def test_multiplicar_menos_11_por_menos_23_igual_253(self):
self.calc.multiplicacion(-11,-23)
self.assertEquals(self.calc.obtener_resultado(), 253)
def test_multiplicar_11_por_menos_11_igual_menos_121(self):
self.calc.multiplicacion(11,-11)
self.assertEquals(self.calc.obtener_resultado(), -121)
def test_multiplicar_zeta_por_2_igual_datos_incorrectos(self):
self.calc.multiplicacion('Z',2)
self.assertEquals(self.calc.obtener_resultado(), self.datosIncorrectos)
def test_multiplicar_10_por_0_igual_0(self):
self.calc.multiplicacion(10,0)
self.assertEquals(self.calc.obtener_resultado(), 0)
def test_elevar_2_a_la_3_igual_8(self):
self.calc.potencia(2,3)
self.assertEquals(self.calc.obtener_resultado(), 8)
def test_elevar_10_a_la_menos_4_igual_punto_0001(self):
self.calc.potencia(10,-4)
self.assertEquals(self.calc.obtener_resultado(), 0.0001)
def test_elevar_de_a_la_11_igual_datos_incorrectos(self):
self.calc.potencia('D',11)
self.assertEquals(self.calc.obtener_resultado(), self.datosIncorrectos)
def test_elevar_menos_1_a_la_punto_5_igual_datos_incorrectos(self):
self.calc.potencia(-1,0.5)
self.assertEquals(self.calc.obtener_resultado(), self.datosIncorrectos)
def test_elevar_menos_9_a_la_punto_5_igual_datos_incorrectos(self):
self.calc.potencia(-9,0.5)
self.assertEquals(self.calc.obtener_resultado(), self.datosIncorrectos)
def test_raiz_8_igual_2_punto_8284271247461903(self):
self.calc.raiz(8)
self.assertEquals(self.calc.obtener_resultado(), 2.8284271247461903)
def test_raiz_0_igual_0(self):
self.calc.raiz(0)
self.assertEquals(self.calc.obtener_resultado(), 0)
def test_raiz_78_punto_54_igual_8_punto_86227961644181(self):
self.calc.raiz(78.54)
self.assertEquals(self.calc.obtener_resultado(), 8.86227961644181)
def test_raiz_menos_11_igual_no_numeros_negativos(self):
self.calc.raiz(-11)
self.assertEquals(self.calc.obtener_resultado(), 'No se aceptan numeros negativos (i)')
def test_raiz_eme_datos_incorrectos(self):
self.calc.raiz('M')
self.assertEquals(self.calc.obtener_resultado(), self.datosIncorrectos)
def tearDown(self):
pass