def setUp(self):
self.b1000 = Billete1000()
self.cajero = Cajero()
billetes = []
for i in range(0, 10):
billetes.append(self.b1000)
self.cajero.agregar_dinero(billetes)
def __init__(self, duracion):
self.duracion = duracion
self.tiempo = 0
self.cajeros = [Cajero() for _ in range(4)]
self.cola = [] # [Cliente]
self.clientes_atendidos = 0
self.desertores = 0
self.total_tiempo_esperado = 0
self.capacidad_clientes_disponible = 0
def proximo_evento(proxima_llegada, lista_cajeros):
cajeros_activos = Cajero.tiempo_servicio_cajeros(lista_cajeros)
if len(cajeros_activos) > 0 and proxima_llegada is not None:
if proxima_llegada <= min(cajeros_activos):
return proxima_llegada
elif proxima_llegada > min(cajeros_activos):
return min(cajeros_activos)
elif proxima_llegada is None:
return min(cajeros_activos)
else:
return proxima_llegada
class TestCajero(unittest.TestCase):
def setUp(self):
self.b1000 = Billete1000()
self.cajero = Cajero()
billetes = []
for i in range(0, 10):
billetes.append(self.b1000)
self.cajero.agregar_dinero(billetes)
def test_contar(self):
a = self.cajero.contar_dinero()
self.assertEqual(a, "10 billetes de $1000, " +
"parcial $10000\n" +
"Total $10000")
def test_extraer1(self):
b = self.cajero.extraer_dinero(5000)
self.assertEqual(b, "5 billetes de $1000\n")
def test_extraer2(self):
c = self.cajero.extraer_dinero(12000)
self.assertEqual(c, "Error. Quiere sacar mas dinero de lo que se puede"
)
def test_extraer3(self):
d = self.cajero.extraer_dinero(5520)
self.assertEqual(d, "Error. El monto es incorrecto")
def setUp(self):
self.b1000 = Billete1000()
self.b500 = Billete500()
self.b200 = Billete200()
# Set 1
self.cajero1 = Cajero()
billetes1 = []
for i in range(0, 10):
billetes1.append(self.b1000)
self.cajero1.agregar_dinero(billetes1)
# Set 2
self.cajero2 = Cajero()
billetes2 = []
for i in range(0, 10):
billetes2.append(self.b1000)
for i in range(0, 20):
billetes2.append(self.b500)
self.cajero2.agregar_dinero(billetes2)
# Set 3
self.cajero3 = Cajero()
billetes3 = []
for i in range(0, 10):
billetes3.append(self.b1000)
for i in range(0, 20):
billetes3.append(self.b500)
for i in range(0, 15):
billetes3.append(self.b200)
self.cajero3.agregar_dinero(billetes3)
class TestCajero(unittest.TestCase):
def setUp(self):
self.b1000 = Billete1000()
self.b500 = Billete500()
self.cajero = Cajero()
billetes = []
for i in range(0, 10):
billetes.append(self.b1000)
for i in range(0, 20):
billetes.append(self.b500)
self.cajero.agregar_dinero(billetes)
def test_contar(self):
a = self.cajero.contar_dinero()
self.assertEqual(
a, "10 billetes de $1000, " + "parcial $10000\n" +
"20 billetes de $500, " + "parcial $10000\n" + "Total $20000")
def test_extraer1(self):
b = self.cajero.extraer_dinero(5000)
self.assertEqual(b, "5 billetes de $1000\n")
def test_extraer2(self):
c = self.cajero.extraer_dinero(12000)
self.assertEqual(c, "10 billetes de $1000\n" + "4 billetes de $500\n")
def test_extraer3(self):
d = self.cajero.extraer_dinero(12100)
self.assertEqual(
d, "Error. No hay una combinacion de billetes que" +
" nos permita extraer ese monto.")
def setUp(self):
self.primerSet = Cajero()
self.segundoSet = Cajero()
self.tercerSet = Cajero()
self.empty = Cajero()
billetera1 = [Billete1000() for item in range(10)]
billetera2 = [Billete1000() for item in range(10)]
billetera2 += [Billete500() for item in range(20)]
billetera3 = [Billete1000() for item in range(10)]
billetera3 += [Billete500() for item in range(20)]
billetera3 += [Billete200() for item in range(15)]
self.primerSet.agregar_dinero(billetera1)
self.segundoSet.agregar_dinero(billetera2)
self.tercerSet.agregar_dinero(billetera3)
def proximo_evento(proxima_llegada, cajeros):
servidores_validos = Cajero.tiempo_servicio_valido(cajeros)
if servidores_validos == [] and proxima_llegada == 0:
print "Error"
exit()
if len(servidores_validos) > 0 and proxima_llegada is not None:
if min(servidores_validos) == 0:
print "Error"
exit()
if proxima_llegada <= min(servidores_validos):
return proxima_llegada
elif proxima_llegada > min(servidores_validos):
return min(servidores_validos)
elif proxima_llegada is None:
return min(servidores_validos)
else:
return proxima_llegada
class CajeroTest(unittest.TestCase):
def setUp(self):
self.primerSet = Cajero()
self.segundoSet = Cajero()
self.tercerSet = Cajero()
self.empty = Cajero()
billetera1 = [Billete1000() for item in range(10)]
billetera2 = [Billete1000() for item in range(10)]
billetera2 += [Billete500() for item in range(20)]
billetera3 = [Billete1000() for item in range(10)]
billetera3 += [Billete500() for item in range(20)]
billetera3 += [Billete200() for item in range(15)]
self.primerSet.agregar_dinero(billetera1)
self.segundoSet.agregar_dinero(billetera2)
self.tercerSet.agregar_dinero(billetera3)
def test_cajero_vacio(self):
with self.assertRaises(Exception):
self.empty.extraer_dinero(100)
def test_contar_a(self):
dinero_contado = self.primerSet.contado_imprimir()
self.assertEqual(
dinero_contado, "pesos:\n" +
"10 billetes de $1000 parcial $10000\n\n" + "Total:10000")
def test_extraer_bien_a(self):
billetes = self.primerSet.extraer_dinero(5000, 0)
ext = [i.getRepresentacion() for i in billetes]
self.assertEqual(ext, ["$1000", "$1000", "$1000", "$1000", "$1000"])
def test_extraer_mucho_a(self):
self.assertRaises(Exception, self.primerSet.extraer_dinero, **{
"monto": 12000,
"porcentaje_cambio": 0
})
def test_extraer_mal_a(self):
self.assertRaises(Exception, self.primerSet.extraer_dinero, **{
"monto": 5520,
"porcentaje_cambio": 0
})
def test_contar_b(self):
dinero_contado = self.segundoSet.contado_imprimir()
self.assertEqual(
dinero_contado,
"pesos:\n" + "10 billetes de $1000 parcial $10000\n" +
"20 billetes de $500 parcial $10000\n\n" + "Total:20000")
def test_extraer_bien_b(self):
billetes = self.segundoSet.extraer_dinero(5000, 0)
ext = [i.getRepresentacion() for i in billetes]
self.assertEqual(ext, ["$1000", "$1000", "$1000", "$1000", "$1000"])
def test_extraer_bien2_b(self):
billetes = self.segundoSet.extraer_dinero(12000, 0)
ext = [i.getRepresentacion() for i in billetes]
self.assertEqual(ext, [
"$1000", "$1000", "$1000", "$1000", "$1000", "$1000", "$1000",
"$1000", "$1000", "$1000", "$500", "$500", "$500", "$500"
])
def test_extraer_mal_b(self):
self.assertRaises(Exception, self.segundoSet.extraer_dinero, **{
"monto": 12100,
"porcentaje_cambio": 0
})
def test_extraer_cambio_b(self):
billetes = self.segundoSet.extraer_dinero(7000, 10)
ext = [i.getRepresentacion() for i in billetes]
self.assertEqual(ext, [
"$500", "$500", "$1000", "$1000", "$1000", "$1000", "$1000",
"$1000"
])
def test_contar_c(self):
dinero_contado = self.tercerSet.contado_imprimir()
self.assertEqual(
dinero_contado,
"pesos:\n" + "10 billetes de $1000 parcial $10000\n" +
"20 billetes de $500 parcial $10000\n" +
"15 billetes de $200 parcial $3000\n\n"
"Total:23000")
def test_extraer_bien_c(self):
billetes = self.tercerSet.extraer_dinero(5000, 0)
ext = [i.getRepresentacion() for i in billetes]
self.assertEqual(ext, ["$1000", "$1000", "$1000", "$1000", "$1000"])
def test_extraer_bien2_c(self):
billetes = self.tercerSet.extraer_dinero(12000, 0)
ext = [i.getRepresentacion() for i in billetes]
self.assertEqual(ext, [
"$1000", "$1000", "$1000", "$1000", "$1000", "$1000", "$1000",
"$1000", "$1000", "$1000", "$500", "$500", "$500", "$500"
])
def test_extraer_mal_c(self):
self.assertRaises(Exception, self.tercerSet.extraer_dinero, **{
"monto": 12100,
"porcentaje_cambio": 0
})
def test_extraer_cambio_c(self):
billetes = self.tercerSet.extraer_dinero(7000, 10)
ext = [i.getRepresentacion() for i in billetes]
self.assertEqual(ext, [
"$200", "$200", "$200", "$200", "$1000", "$1000", "$1000", "$1000",
"$1000", "$1000", "$200"
])
def Simular(tiempo_laborable, numero_servidores):
tiempo_transcurrido = 0
clientes_declinaron = 0
cajeros = numero_servidores * [Cajero()]
personas_atendidas = []
cajero_1, cajero_2, cajero_3, cajero_4 = [], [], [], []
colas = [cajero_1, cajero_2, cajero_3, cajero_4]
proxima_llegada = tiempo_llegada_cliente()
for i in range(numero_servidores):
cajeros[i] = Cajero()
while tiempo_transcurrido < tiempo_laborable or len(colas[0]) > 0 or len(
colas[1]) > 0 or len(colas[2]) > 0 or len(colas[3]) > 0:
proxima_actividad = proximo_evento(proxima_llegada, cajeros)
tiempo_transcurrido += proxima_actividad
proxima_llegada -= proxima_actividad
if proxima_llegada == 0:
cajero_seleccionado = Cajero.seleccionar_cajero(colas, cajeros)
#cajero esta desocupado
if cajeros[cajero_seleccionado].cliente_atendido is None:
cajeros[
cajero_seleccionado].tiempo_servicio = tiempo_servicio_cajero(
)
cajeros[cajero_seleccionado].cliente_atendido = Cliente()
cajeros[cajero_seleccionado].disponible = False
cajeros[cajero_seleccionado].recien_asignado = True
#se encola a la persona
elif len(colas[cajero_seleccionado]) < 6:
colas[cajero_seleccionado].append(Cliente())
#la cola es mayor a 6 y se debe ver si el cliente declina
else:
clientes_declinaron = probabilidad_declinar(
colas[cajero_seleccionado], clientes_declinaron,
personas_atendidas)
proxima_llegada = tiempo_llegada_cliente()
for i in range(numero_servidores):
if cajeros[i].tiempo_servicio > 0 and not cajeros[i].disponible:
if cajeros[i].recien_asignado:
cajeros[i].recien_asignado = False
else:
cajeros[i].tiempo_servicio -= proxima_actividad
cajeros[i].tiempo_servicio_total += proxima_actividad
cajeros[
i].cliente_atendido.tiempo_en_sistema += proxima_actividad
#se desocupa un cajero
if cajeros[i].tiempo_servicio == 0:
#se revisa si hay personas por atender en la cola de la caja
if len(colas[i]) > 0:
personas_atendidas.append(
cajeros[i].cliente_atendido)
cajeros[i].cliente_atendido = colas[i].pop()
cajeros[
i].tiempo_servicio = tiempo_servicio_cajero()
cajeros[i].disponible = False
else:
personas_atendidas.append(
cajeros[i].cliente_atendido)
cajeros[i].cliente_atendido = None
cajeros[i].disponible = True
for cola in colas:
for cliente in cola:
cliente.tiempo_en_sistema += proxima_actividad
porcentaje_clientes_declinaron = (clientes_declinaron *
100) / len(personas_atendidas)
tiempo_espera_cliente = Cliente.tiempo_promedio_espera(personas_atendidas)
tiempo_total = [0] * 4
for i in range(numero_servidores):
tiempo_total[
i] = tiempo_transcurrido - cajeros[i].tiempo_servicio_total
tiempo_total[i] = tiempo_total[i] * 100 / tiempo_transcurrido
return [
porcentaje_clientes_declinaron, tiempo_espera_cliente, tiempo_total
]
def iniciar_simulacion(maximo_de_tiempo, maximo_servidores):
cola_por_atender = Cola()
tiempo_actual = 0
personas_que_declinaron = 0
lista_cajeros = maximo_servidores * [Cajero()]
personas_fuera_del_sistema = []
for i in range(maximo_servidores):
lista_cajeros[i] = Cajero()
proxima_llegada = random_arrival_time()
# SIMULACION
while (tiempo_actual < maximo_de_tiempo or not Cajero.todos_servidores_disponibles(
lista_cajeros) or cola_por_atender.tamano() > 0):
servidor_recien_asignado = 10
# print "Tiempo Actual: %0.6f" % (tiempo_actual)
# Verificamos cual es el evento mas proximo
tiempo_para_evento = proximo_evento(
proxima_llegada,
lista_cajeros)
if tiempo_para_evento == 0:
print "Error tiempo para evento invalido"
exit()
# print "El proximo evento ocurrira en %0.6f" % (tiempo_para_evento)
# print "En la cola inicial hay: %d" % (cola_por_llegar.tamano())
# print "En la cola de espera hay: %d" % (cola_por_atender.tamano())
tiempo_actual += tiempo_para_evento
# Manejamos las llegadas al sistema
if proxima_llegada > 0:
proxima_llegada -= tiempo_para_evento
# Verificamos si un cliente ha llegado
if proxima_llegada == 0:
# Seleccionamos el cajero con menos cola
cajero_seleccionado = cajero_con_menos_cola(lista_cajeros)
# Si el cajero seleccionado esta vacio procedemos a atender
if cajero_seleccionado.cola_por_atender.tamano() == 0:
cajero_seleccionado.tiempo_servicio = random_service_time()
cajero_seleccionado.persona_atendida = Persona()
cajero_seleccionado.disponible = False
servidor_recien_asignado = cajero_seleccionado
# Si no esta vacia pero la cola es corta entonces lo encolamos en
# el cajero
elif cajero_seleccionado.cola_por_atender.tamano() < 6:
cajero_seleccionado.cola_por_atender.encolar(
Persona())
#
else:
personas_que_declinaron = random_decline(
cajero_seleccionado.cola_por_atender,
personas_que_declinaron,
personas_fuera_del_sistema)
proxima_llegada = random_arrival_time()
# Manejo de servidores
for i in range(maximo_servidores):
if (lista_cajeros[i].tiempo_servicio > 0
and not lista_cajeros[i].disponible
and servidor_recien_asignado != lista_cajeros[i]):
# Disminuimos el tiempo de servicio restante para el cliente
# actual
lista_cajeros[i].tiempo_servicio -= tiempo_para_evento
# Le sumamos tiempo de servicio al cajero
lista_cajeros[i].tiempo_servicio_total += tiempo_para_evento
# Le sumamos tiempo de sistema a la persona siendo atendida por el
# cajero
lista_cajeros[i].persona_atendida.tiempo_sistema += tiempo_para_evento
# Verificamos si el cajero termino te atender a alguien
if lista_cajeros[i].tiempo_servicio == 0:
if lista_cajeros[i].cola_por_atender.tamano() > 0:
personas_fuera_del_sistema.append(
lista_cajeros[i].persona_atendida)
lista_cajeros[
i].persona_atendida = lista_cajeros[i].cola_por_atender.desencolar()
lista_cajeros[
i].tiempo_servicio = random_service_time()
lista_cajeros[i].disponible = False
else:
personas_fuera_del_sistema.append(
lista_cajeros[i].persona_atendida)
lista_cajeros[i].persona_atendida = None
lista_cajeros[i].disponible = True
# Agregamos tiempo en el sistema a las personas en la cola
for persona in cola_por_atender.items:
persona.tiempo_sistema += tiempo_para_evento
porcentaje_declinaron = (personas_que_declinaron * 100 / len(personas_fuera_del_sistema))
tiempo_esperado_cliente = (Persona.tiempo_promedio_en_sistema(personas_fuera_del_sistema))
porcentaje_tiempo_clista = []
print "----------------------------------------------------------------"
print "Analisis de resultados: "
print "----------------------------------------------------------------"
print "(a) El tiempo esperado que un cliente pasa en el sistema %0.2f minutos" % (tiempo_esperado_cliente)
print "(b) Porcentaje de personas que declinaron %0.2f" % (porcentaje_declinaron)
print "(c) El porcentaje de tiempo desocupado de cada cajero"
for i in range(maximo_servidores):
tiempo_total = tiempo_actual - lista_cajeros[i].tiempo_servicio_total
aux = (tiempo_total * 100 / tiempo_actual)
porcentaje_tiempo_clista.append(aux)
print " Cajero %d: %0.6f" % (i, aux)
print "---------------------------------------------------------------- "
return [porcentaje_declinaron, tiempo_esperado_cliente, porcentaje_tiempo_clista[0],porcentaje_tiempo_clista[1],porcentaje_tiempo_clista[2],porcentaje_tiempo_clista[3]]
cola.append(cliente)
encolar_Cliente(
cola,
Cliente('Monica', 'Galindo', 'lalla 123', 152369854, '12051980', 25987645,
'M', '05062010', 'Cordoba23', 1))
encolar_Cliente(
cola,
Cliente('Laura', 'Garcia', 'lalla 123', 152369854, '12051980', 25987645,
'M', '05062010', 'Cordoba23', 2))
encolar_Cliente(
cola,
Cliente('Esteban', 'Ayala', 'lalla 123', 152369854, '12051980', 25987645,
'M', '05062010', 'Cordoba23', 3))
encolar_Cliente(
cola,
Cliente('Zacarias', 'Flores de la Plaza', 'lalla 123', 152369854,
'12051980', 25987645, 'M', '05062010', 'Cordoba23', 4))
encolar_Cliente(
cola,
Cliente('Pedro', 'Picapiedra', 'lalla 123', 152369854, '12051980',
25987645, 'M', '05062010', 'Cordoba23', 5))
cajero = Cajero(cola)
while len(cola) >= 1:
cajero.atender()
else:
print('No hay mas clientes en la cola')
def Simular(tiempo_laborable, numero_servidores):
tiempo_transcurrido = 0
clientes_declinaron = 0
personas_atendidas = []
cola_clientes = Cola.Queue()
cajeros = numero_servidores * [Cajero()]
proxima_llegada = tiempo_llegada_cliente()
clientes_en_cola = []
for i in range(numero_servidores):
cajeros[i] = Cajero()
while tiempo_transcurrido < tiempo_laborable or cola_clientes.qsize() > 0:
tiempo_para_ser_atendido = llegada_cliente(proxima_llegada, cajeros)
tiempo_transcurrido += tiempo_para_ser_atendido
proxima_llegada -= tiempo_para_ser_atendido
if proxima_llegada == 0:
if cola_clientes.empty() and Cajero.existe_cajero_disponible(cajeros):
for cajero in cajeros:
if cajero.disponible:
cajero.tiempo_servicio = tiempo_servicio_cajero()
cajero.cliente_atendido = Cliente()
cajero.disponible = False
cajero.recien_asignado = True
break
else:
if cola_clientes.qsize() < 6:
cola_clientes.put(Cliente())
clientes_en_cola.append(Cliente())
else:
clientes_declinaron = probabilidad_declinar(cola_clientes, clientes_declinaron, personas_atendidas, clientes_en_cola)
proxima_llegada = tiempo_llegada_cliente()
for cajero in cajeros:
if cajero.tiempo_servicio > 0:
if cajero.recien_asignado:
cajero.recien_asignado = False
else:
cajero.tiempo_servicio -= tiempo_para_ser_atendido
cajero.tiempo_servicio_total += tiempo_para_ser_atendido
cajero.cliente_atendido.tiempo_en_sistema += tiempo_para_ser_atendido
if cajero.tiempo_servicio == 0:
if cola_clientes.qsize() > 0:
personas_atendidas.append(cajero.cliente_atendido)
cajero.cliente_atendido = cola_clientes.get()
cajero.tiempo_servicio = tiempo_servicio_cajero()
cajero.cliente_atendido.tiempo_en_sistema = clientes_en_cola.pop().tiempo_en_sistema
else:
personas_atendidas.append(cajero.cliente_atendido)
cajero.cliente_atendido = None
cajero.disponible = True
for cliente in clientes_en_cola:
cliente.tiempo_en_sistema += tiempo_para_ser_atendido
porcentaje_clientes_declinaron = (clientes_declinaron * 100) / len(personas_atendidas)
tiempo_espera_cliente = Cliente.tiempo_promedio_espera(personas_atendidas)
tiempo_total = [0]*4
for i in range(numero_servidores):
tiempo_total[i] = tiempo_transcurrido - cajeros[i].tiempo_servicio_total
tiempo_total[i] = tiempo_total[i] * 100 / tiempo_transcurrido
return [porcentaje_clientes_declinaron, tiempo_espera_cliente, tiempo_total]
class TestCajero(unittest.TestCase):
def setUp(self):
self.b1000 = Billete1000()
self.b500 = Billete500()
self.cajero = Cajero()
billetes = []
for i in range(0, 10):
billetes.append(self.b1000)
for i in range(0, 20):
billetes.append(self.b500)
self.cajero.agregar_dinero(billetes)
def test_contar(self):
a = self.cajero.contar_dinero()
self.assertEqual(
a, "10 billetes de $1000, " + "parcial $10000\n" +
"20 billetes de $500, " + "parcial $10000\n" + "Total $20000")
def test_extraer1(self):
b = self.cajero.extraer_dinero(5000)
self.assertEqual(b, "5 billetes de $1000\n")
def test_extraer2(self):
c = self.cajero.extraer_dinero(12000)
self.assertEqual(c, "10 billetes de $1000\n" + "4 billetes de $500\n")
def test_extraer3(self):
with self.assertRaises(CombinacionError):
self.cajero.extraer_dinero(12100)
def test_extraer4(self):
with self.assertRaises(MontoError):
self.cajero.extraer_dinero(-5000)
def test_extraer5(self):
with self.assertRaises(MultiplicidadError):
self.cajero.extraer_dinero(6850)
def test_extraer6(self):
with self.assertRaises(CantidadError):
self.cajero.extraer_dinero(25000)
def test_extraer7(self):
c = self.cajero.extraer_dinero(20000)
with self.assertRaises(CargaError):
self.cajero.extraer_dinero(5000)
persona_DAO = PersonaDao(db)
actividad_DAO = ActividadDao(db)
tipo_DAO = Tipo_ActividadDao(db)
pers1 = Persona("Franco", "Santander", "Cliente")
pers2 = Persona("Daniel", "Quinteros", "Cliente")
persona_DAO.guardar(pers1)
persona_DAO.guardar(pers2)
cargar_dinero = Tipo_Actividad("Deposito", "Ingresar dinero")
extraer_dinero = Tipo_Actividad("Extraccion", "Extraer dinero")
tipo_DAO.guardar(cargar_dinero)
tipo_DAO.guardar(extraer_dinero)
cajero1 = Cajero()
cajero2 = Cajero()
# Creo Billetes
a = Billete100()
b = Billete200()
c = Billete500()
d = Billete1000()
e = Billete200()
f = Billete1000()
dep1 = [a, b, c, d, e, f] # 3000 # Deposito1
dep2 = [a, a, b, b, c, c, d, d] # 3600 # Deposito2
agr_bill_1 = cajero1.agregar_dinero(dep1)
agr_bill_2 = cajero2.agregar_dinero(dep2)
class TestCajero(unittest.TestCase):
def setUp(self):
self.b1000 = Billete1000()
self.b500 = Billete500()
self.b200 = Billete200()
# Set 1
self.cajero1 = Cajero()
billetes1 = []
for i in range(0, 10):
billetes1.append(self.b1000)
self.cajero1.agregar_dinero(billetes1)
# Set 2
self.cajero2 = Cajero()
billetes2 = []
for i in range(0, 10):
billetes2.append(self.b1000)
for i in range(0, 20):
billetes2.append(self.b500)
self.cajero2.agregar_dinero(billetes2)
# Set 3
self.cajero3 = Cajero()
billetes3 = []
for i in range(0, 10):
billetes3.append(self.b1000)
for i in range(0, 20):
billetes3.append(self.b500)
for i in range(0, 15):
billetes3.append(self.b200)
self.cajero3.agregar_dinero(billetes3)
# Test Set 1
def test_set1_contar(self):
a = self.cajero1.contar_dinero()
self.assertEqual(
a, "10 billetes de $1000, " + "parcial $10000\n" + "Total $10000")
def test_set1_extraer1(self):
b = self.cajero1.extraer_dinero(5000)
self.assertEqual(b, "5 billetes de $1000\n")
def test_set1_extraer2(self):
with self.assertRaises(CantidadError):
self.cajero1.extraer_dinero(12000)
def test_set1_extraer3(self):
with self.assertRaises(MultiplicidadError):
self.cajero1.extraer_dinero(5520)
def test_set1_extraer4(self):
with self.assertRaises(MontoError):
self.cajero1.extraer_dinero(-5000)
def test_set1_extraer5(self):
with self.assertRaises(CombinacionError):
self.cajero1.extraer_dinero(9100)
def test_set1_extraer6(self):
c = self.cajero1.extraer_dinero(10000)
with self.assertRaises(CargaError):
self.cajero1.extraer_dinero(5000)
# Test Set 2
def test_set2_contar(self):
a = self.cajero2.contar_dinero()
self.assertEqual(
a, "10 billetes de $1000, " + "parcial $10000\n" +
"20 billetes de $500, " + "parcial $10000\n" + "Total $20000")
def test_set2_extraer1(self):
b = self.cajero2.extraer_dinero(5000)
self.assertEqual(b, "5 billetes de $1000\n")
def test_set2_extraer2(self):
c = self.cajero2.extraer_dinero(12000)
self.assertEqual(c, "10 billetes de $1000\n" + "4 billetes de $500\n")
def test_set2_extraer3(self):
with self.assertRaises(CombinacionError):
self.cajero2.extraer_dinero(12100)
def test_set2_extraer4(self):
with self.assertRaises(MontoError):
self.cajero2.extraer_dinero(-5000)
def test_set2_extraer5(self):
with self.assertRaises(MultiplicidadError):
self.cajero2.extraer_dinero(6850)
def test_set2_extraer6(self):
with self.assertRaises(CantidadError):
self.cajero2.extraer_dinero(25000)
def test_set2_extraer7(self):
c = self.cajero2.extraer_dinero(20000)
with self.assertRaises(CargaError):
self.cajero2.extraer_dinero(5000)
# Test Set 3
def test_set3_contar(self):
a = self.cajero3.contar_dinero()
self.assertEqual(
a, "10 billetes de $1000, " + "parcial $10000\n" +
"20 billetes de $500, " + "parcial $10000\n" +
"15 billetes de $200, " + "parcial $3000\n" + "Total $23000")
def test_set3_extraer1(self):
b = self.cajero3.extraer_dinero(5000)
self.assertEqual(b, "5 billetes de $1000\n")
def test_set3_extraer2(self):
c = self.cajero3.extraer_dinero(12000)
self.assertEqual(c, "10 billetes de $1000\n" + "4 billetes de $500\n")
def test_set3_extraer3(self):
with self.assertRaises(CombinacionError):
self.cajero3.extraer_dinero(12100)
def test_set3_extraer4(self):
with self.assertRaises(MontoError):
self.cajero3.extraer_dinero(-5000)
def test_set3_extraer5(self):
with self.assertRaises(MultiplicidadError):
self.cajero3.extraer_dinero(6850)
def test_set3_extraer6(self):
with self.assertRaises(CantidadError):
self.cajero3.extraer_dinero(25000)
def test_set3_extraer7(self):
c = self.cajero3.extraer_dinero(23000)
with self.assertRaises(CargaError):
self.cajero3.extraer_dinero(5000)