コード例 #1
0
    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)
コード例 #2
0
ファイル: simulacion.py プロジェクト: davidaam/ps6113
 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
コード例 #3
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
コード例 #4
0
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")
コード例 #5
0
    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)
コード例 #6
0
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.")
コード例 #7
0
    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)
コード例 #8
0
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
コード例 #9
0
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"
        ])
コード例 #10
0
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
    ]
コード例 #11
0
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]]
コード例 #12
0
ファイル: banco.py プロジェクト: Fedeper/banco
    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')
コード例 #13
0
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]
コード例 #14
0
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)
コード例 #15
0
    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)
コード例 #16
0
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)