class Menu:
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")
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)
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)
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
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')
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 dado_que_tengo_el_numero_group4_y_group4(step, num1, num2):
cal = Calculadora()
world.resultado = cal.division(int(num1), int(num2))
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
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