def setUp(self):
        self.lista_vacia = ListaEnlazada()

        self.ELEM_0 = "dummy_0"
        self.ELEM_1 = "dummy_1"
        self.ELEM_2 = "dummy_2"

        self.lista1 = ListaEnlazada()
        self.lista1.agregar(self.ELEM_0, 0)

        self.lista2 = ListaEnlazada()
        self.lista2.agregar(self.ELEM_0, 0)
        self.lista2.agregar(self.ELEM_1, 1)

        self.lista3 = ListaEnlazada()
        self.lista3.agregar(self.ELEM_0, 0)
        self.lista3.agregar(self.ELEM_1, 1)
        self.lista3.agregar(self.ELEM_2, 2)

        self.lista_vacia_py = ListaConPyLista()

        self.lista_py_1 = ListaConPyLista()
        self.lista_py_1.agregar(self.ELEM_0, 0)

        self.lista_py_2 = ListaConPyLista()
        self.lista_py_2.agregar(self.ELEM_0, 0)
        self.lista_py_2.agregar(self.ELEM_1, 1)

        self.lista_py_3 = ListaConPyLista()
        self.lista_py_3.agregar(self.ELEM_0, 0)
        self.lista_py_3.agregar(self.ELEM_1, 1)
        self.lista_py_3.agregar(self.ELEM_2, 2)
    def test_get_hijos(self):
        self.nodo_general.setDato("dummy_nodo_1")
        lista = ListaConPyLista()
        lista.agregar(self.DUMMY_0, 0)
        lista.agregar(self.DUMMY_1, 1)
        lista.agregar(self.DUMMY_2, 2)
        lista.agregar(self.DUMMY_3, 2)
        self.nodo_general._NodoGeneral__listaHijos = lista

        self.assertEqual(lista, self.nodo_general.getHijos())
    def test_set_hijos(self):
        lista = ListaConPyLista()
        lista.agregar(self.DUMMY_0, 0)
        lista.agregar(self.DUMMY_1, 1)
        lista.agregar(self.DUMMY_2, 2)
        lista.agregar(self.DUMMY_3, 2)

        self.nodo_general.setHijos(lista)

        self.assertEqual(lista, self.nodo_general._NodoGeneral__listaHijos)
    def test_eliminar_hijo(self):
        self.arbol_general.eliminarHijo(self.ng2)

        lista = ListaConPyLista()
        lista.agregar(self.ng3, 0)

        self.assertEqual(str(lista), str(self.arbol_general.getHijos()))
        self.arbol_general.eliminarHijo(self.ng3)

        # No hay mas hijos
        self.assertRaises(StopIteration, self.arbol_general.eliminarHijo,
                          self.ng3)
    def test_eliminar_hijo(self):
        self.arbol_general.eliminarHijo(self.ng2)

        lista = ListaConPyLista()
        lista.agregar(self.ng3, 0)

        self.assertEqual(str(lista), str(self.arbol_general.getHijos()))
        self.arbol_general.eliminarHijo(self.ng3)

        # No hay mas hijos
        self.assertRaises(StopIteration,
            self.arbol_general.eliminarHijo, self.ng3)
Beispiel #6
0
    def getHijos(self):
        rec_hijos = self._ArbolGeneral__getRaiz().getHijos().recorredor()
        lista = ListaConPyLista()
        try:
            rec_hijos.comenzar()
        except StopIteration:
            return lista

        while not rec_hijos.fin():
            arbol = ArbolGeneral(rec_hijos.elemento())
            lista.agregar(arbol, lista.getTamanio())
            rec_hijos.proximo()

        return lista
Beispiel #7
0
    def getHijos(self):
        rec_hijos = self._ArbolGeneral__getRaiz().getHijos().recorredor()
        lista = ListaConPyLista()
        try:
            rec_hijos.comenzar()
        except StopIteration:
            return lista

        while not rec_hijos.fin():
            arbol = ArbolGeneral(rec_hijos.elemento())
            lista.agregar(arbol, lista.getTamanio())
            rec_hijos.proximo()

        return lista
    def test_nivel_dato_no_existe(self):
        ng_nuevo = NodoGeneral()
        l_nuevo = ListaConPyLista()
        ng_nuevo._NodoGeneral__listaHijos = l_nuevo
        ng_nuevo._NodoGeneral__dato = 8

        self.assertEqual(-1, self.arbol_general.nivel(ng_nuevo))
Beispiel #9
0
    def setUp(self):
        self.lista_vacia = ListaEnlazada()

        self.ELEM_0 = 'dummy_0'
        self.ELEM_1 = 'dummy_1'
        self.ELEM_2 = 'dummy_2'

        self.lista1 = ListaEnlazada()
        self.lista1.agregar(self.ELEM_0, 0)

        self.lista2 = ListaEnlazada()
        self.lista2.agregar(self.ELEM_0, 0)
        self.lista2.agregar(self.ELEM_1, 1)

        self.lista3 = ListaEnlazada()
        self.lista3.agregar(self.ELEM_0, 0)
        self.lista3.agregar(self.ELEM_1, 1)
        self.lista3.agregar(self.ELEM_2, 2)

        self.lista_vacia_py = ListaConPyLista()

        self.lista_py_1 = ListaConPyLista()
        self.lista_py_1.agregar(self.ELEM_0, 0)

        self.lista_py_2 = ListaConPyLista()
        self.lista_py_2.agregar(self.ELEM_0, 0)
        self.lista_py_2.agregar(self.ELEM_1, 1)

        self.lista_py_3 = ListaConPyLista()
        self.lista_py_3.agregar(self.ELEM_0, 0)
        self.lista_py_3.agregar(self.ELEM_1, 1)
        self.lista_py_3.agregar(self.ELEM_2, 2)
    def test_agregar_hijo(self):
        ng_nuevo = NodoGeneral()
        l_nuevo = ListaConPyLista()
        ng_nuevo._NodoGeneral__listaHijos = l_nuevo
        ng_nuevo._NodoGeneral__dato = 8

        self.arbol_general.agregarHijo(ng_nuevo)

        self.l1.agregar(ng_nuevo, 2)
        self.assertEqual(str(self.l1), str(self.arbol_general.getHijos()))
Beispiel #11
0
class Pila(object):

    def __init__(self):
        self._datos = ListaConPyLista()

    def __str__(self):
        return str(self._datos)

    def __repr__(self):
        return self.__str__()

    def poner(self, elem):
        """ Agrega elem a la pila.
        Args:
            elem (Object): dato
        """
        tamanio = self._datos.getTamanio()
        self._datos.agregar(elem, tamanio)

    def sacar(self):
        """ Elimina y devuelve el elemento en el tope de la pila.
        Returns:
            Object: elemento en el tope de la lista.
        """
        tamanio = self._datos.getTamanio()

        elem = self.tope()
        self._datos.eliminar(tamanio - 1)

        return elem

    def tope(self):
        """ Devuelve el elemento en el tope de la pila sin eliminarlo.
        Returns:
            Object: elemento en el tope de la lista.
        """
        tamanio = self._datos.getTamanio()
        elem = self._datos.elemento(tamanio -1)

        return elem

    def esVacia(self):
        """ Metodo para saber si la lista esta vacia o no.
        Returns:
            bool: True si la pila esta vacia y False si no lo esta.
        """
        return self._datos.esVacia()
    def test_set_hijos(self):
        lista = ListaConPyLista()
        lista.agregar(self.DUMMY_0, 0)
        lista.agregar(self.DUMMY_1, 1)
        lista.agregar(self.DUMMY_2, 2)
        lista.agregar(self.DUMMY_3, 2)

        self.nodo_general.setHijos(lista)

        self.assertEqual(lista, self.nodo_general._NodoGeneral__listaHijos)
    def test_get_hijos(self):
        self.nodo_general.setDato("dummy_nodo_1")
        lista = ListaConPyLista()
        lista.agregar(self.DUMMY_0, 0)
        lista.agregar(self.DUMMY_1, 1)
        lista.agregar(self.DUMMY_2, 2)
        lista.agregar(self.DUMMY_3, 2)
        self.nodo_general._NodoGeneral__listaHijos = lista

        self.assertEqual(lista, self.nodo_general.getHijos())
Beispiel #14
0
class TestListaConPyListas(unittest.TestCase):
    def setUp(self):
        self.lista = ListaConPyLista()

    def test_lista_inicio_none(self):
        self.assertEqual([], self.lista._datos)

    def test_lista_vacia_si(self):
        self.assertTrue(self.lista.esVacia())

    def test_lista_vacia_no(self):
        self.lista._datos = [1, 2, 3, 4]
        self.lista._tamanio = 4
        self.assertFalse(self.lista.esVacia())

    def test_str(self):
        self.assertEqual("[]", str(self.lista))
        self.lista._datos = [1, 2, 3, 4]
        self.lista._tamanio = 4
        self.assertEqual("[1, 2, 3, 4]", str(self.lista))

    def test_elemento_lista_vacia(self):
        self.assertRaises(IndexError, self.lista.elemento, 0)
        self.assertRaises(IndexError, self.lista.elemento, 2)

    def test_elemento_pos_menor_cero(self):
        self.assertRaises(IndexError, self.lista.elemento, -1)

    def test_elemento_en_posiciones_ordenadas(self):
        self.lista._datos = ['dummy_0', 'dummy_1', 'dummy_2', 'dummy_3']
        self.lista._tamanio = 4

        self.assertEqual('dummy_0', self.lista.elemento(0))
        self.assertEqual('dummy_1', self.lista.elemento(1))
        self.assertEqual('dummy_2', self.lista.elemento(2))
        self.assertEqual('dummy_3', self.lista.elemento(3))

    def test_elemento_en_posiciones_desordenadas(self):
        self.lista._datos = ['dummy_0', 'dummy_1', 'dummy_2', 'dummy_3']
        self.lista._tamanio = 4

        self.assertEqual('dummy_3', self.lista.elemento(3))
        self.assertEqual('dummy_1', self.lista.elemento(1))
        self.assertEqual('dummy_0', self.lista.elemento(0))
        self.assertEqual('dummy_2', self.lista.elemento(2))

    def test_agregar_a_lista_pos_menor_0(self):
        self.assertRaises(IndexError, self.lista.agregar, 'dummy', -1)

    def test_agregar_a_lista_pos_mayor_tamanio_lista(self):
        self.assertRaises(IndexError, self.lista.agregar, 'dummy', 1)
        self.lista._tamanio = 1
        self.assertRaises(IndexError, self.lista.agregar, 'dummy', 2)

    def test_agregar_a_lista_nueva(self):
        self.lista.agregar('dummy_0', 0)
        self.assertEqual('dummy_0', self.lista.elemento(0))

        self.lista.agregar('dummy_1', 1)
        self.assertEqual('dummy_1', self.lista.elemento(1))

        self.lista.agregar('dummy_2', 0)
        self.assertEqual('dummy_2', self.lista.elemento(0))
        self.assertEqual('dummy_0', self.lista.elemento(1))
        self.assertEqual('dummy_1', self.lista.elemento(2))

    def test_incluye_lista_vacia(self):
        self.assertFalse(self.lista.incluye('dummy_0'))

    def test_incluye_existe(self):
        self.lista._datos = ['dummy_0', 'dummy_1', 'dummy_2', 'dummy_3']
        self.lista._tamanio = 4

        self.assertTrue(self.lista.incluye('dummy_0'))
        self.assertTrue(self.lista.incluye('dummy_1'))
        self.assertTrue(self.lista.incluye('dummy_2'))
        self.assertTrue(self.lista.incluye('dummy_3'))

    def test_incluye_no_existe(self):
        self.lista._datos = ['dummy_0', 'dummy_1', 'dummy_2', 'dummy_3']
        self.assertFalse(self.lista.incluye('dummy_4'))
        self.assertFalse(self.lista.incluye('dummy_5'))

    def test_eliminar_index_error(self):
        lista = ListaEnlazada()
        lista.agregar('dummy_0', 0)
        lista.agregar('dummy_1', 1)
        lista.agregar('dummy_2', 2)
        lista.agregar('dummy_3', 3)

    def test_eliminar_ok(self):
        self.lista._datos = ['dummy_0']
        self.lista._tamanio = 1
        self.lista.eliminar(0)
        self.assertTrue(self.lista.esVacia())
        self.assertFalse(self.lista.incluye('dummy0'))

        self.lista._datos = ['dummy_0', 'dummy_1', 'dummy_2', 'dummy_3']
        self.lista._tamanio = 4
        tamanio = self.lista.getTamanio()

        self.lista.eliminar(2)
        self.assertEqual(tamanio - 1, self.lista.getTamanio())
        self.assertFalse(self.lista.incluye('dummy2'))

        self.lista.eliminar(2)
        self.assertEqual(tamanio - 2, self.lista.getTamanio())
        self.assertFalse(self.lista.incluye('dummy3'))

        self.lista.eliminar(0)
        self.assertEqual(tamanio - 3, self.lista.getTamanio())
        self.assertFalse(self.lista.incluye('dummy0'))

        self.lista.eliminar(0)
        self.assertEqual(tamanio - 4, self.lista.getTamanio())
        self.assertFalse(self.lista.incluye('dummy1'))

    def test_eliminar_pos_error(self):
        self.lista._datos = ['dummy_0', 'dummy_1', 'dummy_2']
        self.lista._tamanio = 34

        tamanio = self.lista.getTamanio()

        self.assertRaises(IndexError, self.lista.eliminar, 3)
        self.assertRaises(IndexError, self.lista.eliminar, 4)
        self.assertRaises(IndexError, self.lista.eliminar, -1)

        self.assertEqual(tamanio, self.lista.getTamanio())
        self.assertTrue(self.lista.incluye('dummy_0'))
        self.assertTrue(self.lista.incluye('dummy_1'))
        self.assertTrue(self.lista.incluye('dummy_2'))
    def test_get_hijos_none(self):
        arbol_dummy = ArbolGeneral()
        arbol_dummy._ArbolGeneral__raiz = self.ng7

        self.assertEqual(str(ListaConPyLista()), str(arbol_dummy.getHijos()))
    def setUp(self):
        #self.DUMMY_0 = 'dummy0'
        #self.DUMMY_1 = 'dummy1'
        #self.DUMMY_2 = 'dummy2'
        #self.DUMMY_3 = 'dummy3'

        #self.lista = ListaConPyLista()
        #self.lista.agregar(self.DUMMY_0, 0)
        #self.lista.agregar(self.DUMMY_1, 1)
        #self.lista.agregar(self.DUMMY_2, 2)
        #self.lista.agregar(self.DUMMY_3, 2)

        #self.nodo_general = NodoGeneral()
        #self.nodo_general.setDato(self.DUMMY_0)
        #self.nodo_general.setHijos(self.lista)

        """
                        1
                        |
                   ----- -----
                  |           |
                  2           3
                  |           |
                -- --       -- --
               |     |     |     |
               4     5     6     7

        """
        self.ng7 = NodoGeneral()
        self.ng6 = NodoGeneral()
        self.ng5 = NodoGeneral()
        self.ng4 = NodoGeneral()
        self.ng2 = NodoGeneral()
        self.ng3 = NodoGeneral()
        self.ng1 = NodoGeneral()

        self.ng7._NodoGeneral__dato = 7
        self.ng6._NodoGeneral__dato = 6
        self.ng5._NodoGeneral__dato = 5
        self.ng4._NodoGeneral__dato = 4
        self.ng3._NodoGeneral__dato = 3
        self.ng2._NodoGeneral__dato = 2
        self.ng1._NodoGeneral__dato = 1

        self.l1 = ListaConPyLista()
        self.l2 = ListaConPyLista()
        self.l3 = ListaConPyLista()
        self.l4 = ListaConPyLista()
        self.l5 = ListaConPyLista()
        self.l6 = ListaConPyLista()
        self.l7 = ListaConPyLista()

        self.ag1 = ArbolGeneral()
        self.ag2 = ArbolGeneral()
        self.ag3 = ArbolGeneral()
        self.ag4 = ArbolGeneral()
        self.ag5 = ArbolGeneral()
        self.ag6 = ArbolGeneral()
        self.ag7 = ArbolGeneral()

        self.l3.agregar(self.ng6, 0)
        self.l3.agregar(self.ng7, 1)
        self.ng3._NodoGeneral__listaHijos = self.l3

        self.l2.agregar(self.ng4, 0)
        self.l2.agregar(self.ng5, 1)
        self.ng2._NodoGeneral__listaHijos = self.l2

        self.l1.agregar(self.ng2, 0)
        self.l1.agregar(self.ng3, 1)
        self.ng1._NodoGeneral__listaHijos = self.l1

        self.arbol_general = ArbolGeneral()
        self.arbol_general._ArbolGeneral__raiz = self.ng1
 def setUp(self):
     self.lista = ListaConPyLista()
    def setUp(self):
        #self.DUMMY_0 = 'dummy0'
        #self.DUMMY_1 = 'dummy1'
        #self.DUMMY_2 = 'dummy2'
        #self.DUMMY_3 = 'dummy3'

        #self.lista = ListaConPyLista()
        #self.lista.agregar(self.DUMMY_0, 0)
        #self.lista.agregar(self.DUMMY_1, 1)
        #self.lista.agregar(self.DUMMY_2, 2)
        #self.lista.agregar(self.DUMMY_3, 2)

        #self.nodo_general = NodoGeneral()
        #self.nodo_general.setDato(self.DUMMY_0)
        #self.nodo_general.setHijos(self.lista)
        """
                        1
                        |
                   ----- -----
                  |           |
                  2           3
                  |           |
                -- --       -- --
               |     |     |     |
               4     5     6     7

        """
        self.ng7 = NodoGeneral()
        self.ng6 = NodoGeneral()
        self.ng5 = NodoGeneral()
        self.ng4 = NodoGeneral()
        self.ng2 = NodoGeneral()
        self.ng3 = NodoGeneral()
        self.ng1 = NodoGeneral()

        self.ng7._NodoGeneral__dato = 7
        self.ng6._NodoGeneral__dato = 6
        self.ng5._NodoGeneral__dato = 5
        self.ng4._NodoGeneral__dato = 4
        self.ng3._NodoGeneral__dato = 3
        self.ng2._NodoGeneral__dato = 2
        self.ng1._NodoGeneral__dato = 1

        self.l1 = ListaConPyLista()
        self.l2 = ListaConPyLista()
        self.l3 = ListaConPyLista()
        self.l4 = ListaConPyLista()
        self.l5 = ListaConPyLista()
        self.l6 = ListaConPyLista()
        self.l7 = ListaConPyLista()

        self.ag1 = ArbolGeneral()
        self.ag2 = ArbolGeneral()
        self.ag3 = ArbolGeneral()
        self.ag4 = ArbolGeneral()
        self.ag5 = ArbolGeneral()
        self.ag6 = ArbolGeneral()
        self.ag7 = ArbolGeneral()

        self.l3.agregar(self.ng6, 0)
        self.l3.agregar(self.ng7, 1)
        self.ng3._NodoGeneral__listaHijos = self.l3

        self.l2.agregar(self.ng4, 0)
        self.l2.agregar(self.ng5, 1)
        self.ng2._NodoGeneral__listaHijos = self.l2

        self.l1.agregar(self.ng2, 0)
        self.l1.agregar(self.ng3, 1)
        self.ng1._NodoGeneral__listaHijos = self.l1

        self.arbol_general = ArbolGeneral()
        self.arbol_general._ArbolGeneral__raiz = self.ng1
Beispiel #19
0
 def __init__(self):
     self._datos = ListaConPyLista()
Beispiel #20
0
 def __init__(self):
     self._datos = ListaConPyLista()
Beispiel #21
0
 def __init__(self):
     self.__dato = None
     self.__listaHijos = ListaConPyLista()
class TestRecorredor(unittest.TestCase):
    def setUp(self):
        self.lista_vacia = ListaEnlazada()

        self.ELEM_0 = "dummy_0"
        self.ELEM_1 = "dummy_1"
        self.ELEM_2 = "dummy_2"

        self.lista1 = ListaEnlazada()
        self.lista1.agregar(self.ELEM_0, 0)

        self.lista2 = ListaEnlazada()
        self.lista2.agregar(self.ELEM_0, 0)
        self.lista2.agregar(self.ELEM_1, 1)

        self.lista3 = ListaEnlazada()
        self.lista3.agregar(self.ELEM_0, 0)
        self.lista3.agregar(self.ELEM_1, 1)
        self.lista3.agregar(self.ELEM_2, 2)

        self.lista_vacia_py = ListaConPyLista()

        self.lista_py_1 = ListaConPyLista()
        self.lista_py_1.agregar(self.ELEM_0, 0)

        self.lista_py_2 = ListaConPyLista()
        self.lista_py_2.agregar(self.ELEM_0, 0)
        self.lista_py_2.agregar(self.ELEM_1, 1)

        self.lista_py_3 = ListaConPyLista()
        self.lista_py_3.agregar(self.ELEM_0, 0)
        self.lista_py_3.agregar(self.ELEM_1, 1)
        self.lista_py_3.agregar(self.ELEM_2, 2)

    def test_inicio(self):
        rec = Recorredor(self.lista_vacia)
        self.assertEqual(self.lista_vacia, rec._lista)
        self.assertEqual(None, rec._actual)

        rec2 = Recorredor(self.lista3)
        self.assertEqual(self.lista3, rec2._lista)
        self.assertEqual(None, rec2._actual)

        recpy = Recorredor(self.lista_vacia_py)
        self.assertEqual(self.lista_vacia_py, recpy._lista)
        self.assertEqual(None, recpy._actual)

        rec2 = Recorredor(self.lista3)
        self.assertEqual(self.lista3, rec2._lista)
        self.assertEqual(None, rec2._actual)

    def test_comenzar_vacia(self):
        rec = Recorredor(self.lista_vacia)
        self.assertRaises(StopIteration, rec.comenzar)

        recpy = Recorredor(self.lista_vacia_py)
        self.assertRaises(StopIteration, rec.comenzar)

    def test_comenzar_no_vacia(self):
        rec1 = Recorredor(self.lista1)
        rec2 = Recorredor(self.lista2)
        rec3 = Recorredor(self.lista3)

        rec1.comenzar()
        rec2.comenzar()
        rec3.comenzar()

        self.assertEqual(0, rec1._actual)
        self.assertEqual(0, rec2._actual)
        self.assertEqual(0, rec3._actual)

        recpy1 = Recorredor(self.lista_py_1)
        recpy2 = Recorredor(self.lista_py_2)
        recpy3 = Recorredor(self.lista_py_3)

        recpy1.comenzar()
        recpy2.comenzar()
        recpy3.comenzar()

        self.assertEqual(0, recpy1._actual)
        self.assertEqual(0, recpy2._actual)
        self.assertEqual(0, recpy3._actual)

    def test_elemento(self):
        rec = Recorredor(self.lista3)
        rec.comenzar()

        rec._actual = 0
        self.assertEqual(self.ELEM_0, rec.elemento())

        rec._actual = 1
        self.assertEqual(self.ELEM_1, rec.elemento())

        rec._actual = 2
        self.assertEqual(self.ELEM_2, rec.elemento())

        recpy = Recorredor(self.lista_py_3)
        recpy.comenzar()

        recpy._actual = 0
        self.assertEqual(self.ELEM_0, recpy.elemento())

        recpy._actual = 1
        self.assertEqual(self.ELEM_1, recpy.elemento())

        recpy._actual = 2
        self.assertEqual(self.ELEM_2, recpy.elemento())

    def test_proximo_no_hay(self):
        rec = Recorredor(self.lista1)
        rec.comenzar()
        self.assertRaises(StopIteration, rec.proximo)

        rec2 = Recorredor(self.lista3)
        rec2._actual = 2
        self.assertRaises(StopIteration, rec2.proximo)

        recpy = Recorredor(self.lista_py_1)
        recpy.comenzar()
        self.assertRaises(StopIteration, recpy.proximo)

        recpy2 = Recorredor(self.lista_py_3)
        recpy2._actual = 2
        self.assertRaises(StopIteration, recpy2.proximo)

    def test_proximo(self):
        rec = Recorredor(self.lista3)
        rec.comenzar()
        rec.proximo()

        self.assertEqual(self.ELEM_1, rec.elemento())
        rec.proximo()

        self.assertEqual(self.ELEM_2, rec.elemento())

        self.assertRaises(StopIteration, rec.proximo)

        recpy = Recorredor(self.lista_py_3)
        recpy.comenzar()
        recpy.proximo()

        self.assertEqual(self.ELEM_1, recpy.elemento())
        recpy.proximo()

        self.assertEqual(self.ELEM_2, recpy.elemento())

        self.assertRaises(StopIteration, recpy.proximo)

    def test_fin_si(self):
        rec1 = Recorredor(self.lista1)
        rec2 = Recorredor(self.lista2)
        rec3 = Recorredor(self.lista3)

        rec1._actual = 0
        rec2._actual = 1
        rec3._actual = 2

        self.assertTrue(rec1.fin())
        self.assertTrue(rec2.fin())
        self.assertTrue(rec3.fin())

        recpy1 = Recorredor(self.lista_py_1)
        recpy2 = Recorredor(self.lista_py_2)
        recpy3 = Recorredor(self.lista_py_3)

        recpy1._actual = 0
        recpy2._actual = 1
        recpy3._actual = 2

        self.assertTrue(recpy1.fin())
        self.assertTrue(recpy2.fin())
        self.assertTrue(recpy3.fin())
        recpy1 = Recorredor(self.lista_py_1)
        recpy2 = Recorredor(self.lista_py_2)
        recpy3 = Recorredor(self.lista_py_3)

        recpy1._actual = 0
        recpy2._actual = 1
        recpy3._actual = 2

        self.assertTrue(recpy1.fin())
        self.assertTrue(recpy2.fin())
        self.assertTrue(recpy3.fin())

    def test_fin_no(self):
        rec2 = Recorredor(self.lista2)
        rec3 = Recorredor(self.lista3)

        rec2._actual = 0
        rec3._actual = 0

        self.assertFalse(rec2.fin())
        self.assertFalse(rec3.fin())

        rec3._actual = 1
        self.assertFalse(rec3.fin())

        recpy2 = Recorredor(self.lista_py_2)
        recpy3 = Recorredor(self.lista_py_3)

        recpy2._actual = 0
        recpy3._actual = 0

        self.assertFalse(recpy2.fin())
        self.assertFalse(recpy3.fin())

        recpy3._actual = 1
        self.assertFalse(recpy3.fin())

    def test_agregar(self):
        NEW_DUMMY_0 = "new_dummy_0"
        NEW_DUMMY_1 = "new_dummy_1"
        NEW_DUMMY_2 = "new_dummy_2"

        rec = Recorredor(self.lista3)

        rec._actual = 0
        rec.agregar(NEW_DUMMY_0)
        self.assertEqual(NEW_DUMMY_0, rec.elemento())
        self.assertEqual(NEW_DUMMY_0, self.lista3.elemento(0))

        rec._actual = 1
        rec.agregar(NEW_DUMMY_1)
        self.assertEqual(NEW_DUMMY_1, rec.elemento())
        self.assertEqual(NEW_DUMMY_1, self.lista3.elemento(1))

        rec._actual = 2
        rec.agregar(NEW_DUMMY_2)
        self.assertEqual(NEW_DUMMY_2, rec.elemento())
        self.assertEqual(NEW_DUMMY_2, self.lista3.elemento(2))

        recpy = Recorredor(self.lista_py_3)

        recpy._actual = 0
        recpy.agregar(NEW_DUMMY_0)
        self.assertEqual(NEW_DUMMY_0, recpy.elemento())
        self.assertEqual(NEW_DUMMY_0, self.lista_py_3.elemento(0))

        recpy._actual = 1
        recpy.agregar(NEW_DUMMY_1)
        self.assertEqual(NEW_DUMMY_1, recpy.elemento())
        self.assertEqual(NEW_DUMMY_1, self.lista_py_3.elemento(1))

        recpy._actual = 2
        recpy.agregar(NEW_DUMMY_2)
        self.assertEqual(NEW_DUMMY_2, recpy.elemento())
        self.assertEqual(NEW_DUMMY_2, self.lista_py_3.elemento(2))

    def test_eliminar(self):
        rec = Recorredor(self.lista3)
        tamanio = self.lista3.getTamanio()
        rec._actual = 2

        rec.eliminar()
        self.assertEqual(tamanio - 1, self.lista3.getTamanio())

        rec.eliminar()
        self.assertEqual(tamanio - 2, self.lista3.getTamanio())

        rec.eliminar()
        self.assertEqual(tamanio - 3, self.lista3.getTamanio())

        recpy = Recorredor(self.lista_py_3)
        tamanio = self.lista_py_3.getTamanio()
        recpy._actual = 2

        recpy.eliminar()
        self.assertEqual(tamanio - 1, self.lista_py_3.getTamanio())

        recpy.eliminar()
        self.assertEqual(tamanio - 2, self.lista_py_3.getTamanio())

        recpy.eliminar()
        self.assertEqual(tamanio - 3, self.lista_py_3.getTamanio())
Beispiel #23
0
 def setUp(self):
     self.lista = ListaConPyLista()
class TestArbolGeneral(unittest.TestCase):
    def setUp(self):
        #self.DUMMY_0 = 'dummy0'
        #self.DUMMY_1 = 'dummy1'
        #self.DUMMY_2 = 'dummy2'
        #self.DUMMY_3 = 'dummy3'

        #self.lista = ListaConPyLista()
        #self.lista.agregar(self.DUMMY_0, 0)
        #self.lista.agregar(self.DUMMY_1, 1)
        #self.lista.agregar(self.DUMMY_2, 2)
        #self.lista.agregar(self.DUMMY_3, 2)

        #self.nodo_general = NodoGeneral()
        #self.nodo_general.setDato(self.DUMMY_0)
        #self.nodo_general.setHijos(self.lista)
        """
                        1
                        |
                   ----- -----
                  |           |
                  2           3
                  |           |
                -- --       -- --
               |     |     |     |
               4     5     6     7

        """
        self.ng7 = NodoGeneral()
        self.ng6 = NodoGeneral()
        self.ng5 = NodoGeneral()
        self.ng4 = NodoGeneral()
        self.ng2 = NodoGeneral()
        self.ng3 = NodoGeneral()
        self.ng1 = NodoGeneral()

        self.ng7._NodoGeneral__dato = 7
        self.ng6._NodoGeneral__dato = 6
        self.ng5._NodoGeneral__dato = 5
        self.ng4._NodoGeneral__dato = 4
        self.ng3._NodoGeneral__dato = 3
        self.ng2._NodoGeneral__dato = 2
        self.ng1._NodoGeneral__dato = 1

        self.l1 = ListaConPyLista()
        self.l2 = ListaConPyLista()
        self.l3 = ListaConPyLista()
        self.l4 = ListaConPyLista()
        self.l5 = ListaConPyLista()
        self.l6 = ListaConPyLista()
        self.l7 = ListaConPyLista()

        self.ag1 = ArbolGeneral()
        self.ag2 = ArbolGeneral()
        self.ag3 = ArbolGeneral()
        self.ag4 = ArbolGeneral()
        self.ag5 = ArbolGeneral()
        self.ag6 = ArbolGeneral()
        self.ag7 = ArbolGeneral()

        self.l3.agregar(self.ng6, 0)
        self.l3.agregar(self.ng7, 1)
        self.ng3._NodoGeneral__listaHijos = self.l3

        self.l2.agregar(self.ng4, 0)
        self.l2.agregar(self.ng5, 1)
        self.ng2._NodoGeneral__listaHijos = self.l2

        self.l1.agregar(self.ng2, 0)
        self.l1.agregar(self.ng3, 1)
        self.ng1._NodoGeneral__listaHijos = self.l1

        self.arbol_general = ArbolGeneral()
        self.arbol_general._ArbolGeneral__raiz = self.ng1

    def test_inicio(self):
        ag = ArbolGeneral()
        self.assertEqual(None, ag._ArbolGeneral__raiz)

    def test_get_raiz(self):
        self.assertEqual(self.ng1, self.arbol_general._ArbolGeneral__getRaiz())

    def test_set_raiz(self):
        self.arbol_general._ArbolGeneral__setRaiz(self.ng1)
        self.assertEqual(self.ng1, self.arbol_general._ArbolGeneral__raiz)

    def test_get_dato_raiz(self):
        self.arbol_general._ArbolGeneral__raiz = self.ng1
        self.assertEqual(1, self.arbol_general.getDatoRaiz())

    def test_get_hijos(self):
        self.assertEqual(str(self.l1), str(self.arbol_general.getHijos()))

    def test_get_hijos_none(self):
        arbol_dummy = ArbolGeneral()
        arbol_dummy._ArbolGeneral__raiz = self.ng7

        self.assertEqual(str(ListaConPyLista()), str(arbol_dummy.getHijos()))

    def test_agregar_hijo(self):
        ng_nuevo = NodoGeneral()
        l_nuevo = ListaConPyLista()
        ng_nuevo._NodoGeneral__listaHijos = l_nuevo
        ng_nuevo._NodoGeneral__dato = 8

        self.arbol_general.agregarHijo(ng_nuevo)

        self.l1.agregar(ng_nuevo, 2)
        self.assertEqual(str(self.l1), str(self.arbol_general.getHijos()))

    def test_eliminar_hijo(self):
        self.arbol_general.eliminarHijo(self.ng2)

        lista = ListaConPyLista()
        lista.agregar(self.ng3, 0)

        self.assertEqual(str(lista), str(self.arbol_general.getHijos()))
        self.arbol_general.eliminarHijo(self.ng3)

        # No hay mas hijos
        self.assertRaises(StopIteration, self.arbol_general.eliminarHijo,
                          self.ng3)

    def test_altura_sin_datos(self):
        arbol_dummy = ArbolGeneral()
        self.assertEqual(-1, arbol_dummy.altura())

    def test_altura_cero(self):
        arbol_dummy = ArbolGeneral()
        arbol_dummy._ArbolGeneral__raiz = self.ng7

        self.assertEqual(0, arbol_dummy.altura())

    def test_altura_mayor_0(self):
        arbol_dummy2 = ArbolGeneral()
        arbol_dummy2._ArbolGeneral__raiz = self.ng2
        self.assertEqual(1, arbol_dummy2.altura())

        arbol_dummy3 = ArbolGeneral()
        arbol_dummy3._ArbolGeneral__raiz = self.ng2
        self.assertEqual(1, arbol_dummy3.altura())

        self.assertEqual(2, self.arbol_general.altura())

    def test_nivel_sin_datos(self):
        arbol_dummy = ArbolGeneral()
        self.assertEqual(-1, arbol_dummy.nivel(self.ng1))

    def test_nivel_dato_no_existe(self):
        ng_nuevo = NodoGeneral()
        l_nuevo = ListaConPyLista()
        ng_nuevo._NodoGeneral__listaHijos = l_nuevo
        ng_nuevo._NodoGeneral__dato = 8

        self.assertEqual(-1, self.arbol_general.nivel(ng_nuevo))

    def test_nivel_cero(self):
        self.assertEqual(0, self.arbol_general.nivel(self.ng1))

    def test_nivel(self):
        self.assertEqual(1, self.arbol_general.nivel(self.ng2))
        self.assertEqual(1, self.arbol_general.nivel(self.ng3))
        self.assertEqual(2, self.arbol_general.nivel(self.ng4))
        self.assertEqual(2, self.arbol_general.nivel(self.ng5))
        self.assertEqual(2, self.arbol_general.nivel(self.ng6))
        self.assertEqual(2, self.arbol_general.nivel(self.ng7))
class TestArbolGeneral(unittest.TestCase):

    def setUp(self):
        #self.DUMMY_0 = 'dummy0'
        #self.DUMMY_1 = 'dummy1'
        #self.DUMMY_2 = 'dummy2'
        #self.DUMMY_3 = 'dummy3'

        #self.lista = ListaConPyLista()
        #self.lista.agregar(self.DUMMY_0, 0)
        #self.lista.agregar(self.DUMMY_1, 1)
        #self.lista.agregar(self.DUMMY_2, 2)
        #self.lista.agregar(self.DUMMY_3, 2)

        #self.nodo_general = NodoGeneral()
        #self.nodo_general.setDato(self.DUMMY_0)
        #self.nodo_general.setHijos(self.lista)

        """
                        1
                        |
                   ----- -----
                  |           |
                  2           3
                  |           |
                -- --       -- --
               |     |     |     |
               4     5     6     7

        """
        self.ng7 = NodoGeneral()
        self.ng6 = NodoGeneral()
        self.ng5 = NodoGeneral()
        self.ng4 = NodoGeneral()
        self.ng2 = NodoGeneral()
        self.ng3 = NodoGeneral()
        self.ng1 = NodoGeneral()

        self.ng7._NodoGeneral__dato = 7
        self.ng6._NodoGeneral__dato = 6
        self.ng5._NodoGeneral__dato = 5
        self.ng4._NodoGeneral__dato = 4
        self.ng3._NodoGeneral__dato = 3
        self.ng2._NodoGeneral__dato = 2
        self.ng1._NodoGeneral__dato = 1

        self.l1 = ListaConPyLista()
        self.l2 = ListaConPyLista()
        self.l3 = ListaConPyLista()
        self.l4 = ListaConPyLista()
        self.l5 = ListaConPyLista()
        self.l6 = ListaConPyLista()
        self.l7 = ListaConPyLista()

        self.ag1 = ArbolGeneral()
        self.ag2 = ArbolGeneral()
        self.ag3 = ArbolGeneral()
        self.ag4 = ArbolGeneral()
        self.ag5 = ArbolGeneral()
        self.ag6 = ArbolGeneral()
        self.ag7 = ArbolGeneral()

        self.l3.agregar(self.ng6, 0)
        self.l3.agregar(self.ng7, 1)
        self.ng3._NodoGeneral__listaHijos = self.l3

        self.l2.agregar(self.ng4, 0)
        self.l2.agregar(self.ng5, 1)
        self.ng2._NodoGeneral__listaHijos = self.l2

        self.l1.agregar(self.ng2, 0)
        self.l1.agregar(self.ng3, 1)
        self.ng1._NodoGeneral__listaHijos = self.l1

        self.arbol_general = ArbolGeneral()
        self.arbol_general._ArbolGeneral__raiz = self.ng1


    def test_inicio(self):
        ag = ArbolGeneral()
        self.assertEqual(None, ag._ArbolGeneral__raiz)

    def test_get_raiz(self):
        self.assertEqual(self.ng1, self.arbol_general._ArbolGeneral__getRaiz())

    def test_set_raiz(self):
        self.arbol_general._ArbolGeneral__setRaiz(self.ng1)
        self.assertEqual(self.ng1,
            self.arbol_general._ArbolGeneral__raiz)

    def test_get_dato_raiz(self):
        self.arbol_general._ArbolGeneral__raiz = self.ng1
        self.assertEqual(1, self.arbol_general.getDatoRaiz())

    def test_get_hijos(self):
        self.assertEqual(str(self.l1), str(self.arbol_general.getHijos()))

    def test_get_hijos_none(self):
        arbol_dummy = ArbolGeneral()
        arbol_dummy._ArbolGeneral__raiz = self.ng7

        self.assertEqual(str(ListaConPyLista()), str(arbol_dummy.getHijos()))

    def test_agregar_hijo(self):
        ng_nuevo = NodoGeneral()
        l_nuevo = ListaConPyLista()
        ng_nuevo._NodoGeneral__listaHijos = l_nuevo
        ng_nuevo._NodoGeneral__dato = 8

        self.arbol_general.agregarHijo(ng_nuevo)

        self.l1.agregar(ng_nuevo, 2)
        self.assertEqual(str(self.l1), str(self.arbol_general.getHijos()))

    def test_eliminar_hijo(self):
        self.arbol_general.eliminarHijo(self.ng2)

        lista = ListaConPyLista()
        lista.agregar(self.ng3, 0)

        self.assertEqual(str(lista), str(self.arbol_general.getHijos()))
        self.arbol_general.eliminarHijo(self.ng3)

        # No hay mas hijos
        self.assertRaises(StopIteration,
            self.arbol_general.eliminarHijo, self.ng3)

    def test_altura_sin_datos(self):
        arbol_dummy = ArbolGeneral()
        self.assertEqual(-1, arbol_dummy.altura())

    def test_altura_cero(self):
        arbol_dummy = ArbolGeneral()
        arbol_dummy._ArbolGeneral__raiz = self.ng7

        self.assertEqual(0, arbol_dummy.altura())

    def test_altura_mayor_0(self):
        arbol_dummy2 = ArbolGeneral()
        arbol_dummy2._ArbolGeneral__raiz = self.ng2
        self.assertEqual(1, arbol_dummy2.altura())

        arbol_dummy3 = ArbolGeneral()
        arbol_dummy3._ArbolGeneral__raiz = self.ng2
        self.assertEqual(1, arbol_dummy3.altura())

        self.assertEqual(2, self.arbol_general.altura())

    def test_nivel_sin_datos(self):
        arbol_dummy = ArbolGeneral()
        self.assertEqual(-1, arbol_dummy.nivel(self.ng1))

    def test_nivel_dato_no_existe(self):
        ng_nuevo = NodoGeneral()
        l_nuevo = ListaConPyLista()
        ng_nuevo._NodoGeneral__listaHijos = l_nuevo
        ng_nuevo._NodoGeneral__dato = 8

        self.assertEqual(-1, self.arbol_general.nivel(ng_nuevo))

    def test_nivel_cero(self):
        self.assertEqual(0, self.arbol_general.nivel(self.ng1))

    def test_nivel(self):
        self.assertEqual(1, self.arbol_general.nivel(self.ng2))
        self.assertEqual(1, self.arbol_general.nivel(self.ng3))
        self.assertEqual(2, self.arbol_general.nivel(self.ng4))
        self.assertEqual(2, self.arbol_general.nivel(self.ng5))
        self.assertEqual(2, self.arbol_general.nivel(self.ng6))
        self.assertEqual(2, self.arbol_general.nivel(self.ng7))
Beispiel #26
0
class TestRecorredor(unittest.TestCase):
    def setUp(self):
        self.lista_vacia = ListaEnlazada()

        self.ELEM_0 = 'dummy_0'
        self.ELEM_1 = 'dummy_1'
        self.ELEM_2 = 'dummy_2'

        self.lista1 = ListaEnlazada()
        self.lista1.agregar(self.ELEM_0, 0)

        self.lista2 = ListaEnlazada()
        self.lista2.agregar(self.ELEM_0, 0)
        self.lista2.agregar(self.ELEM_1, 1)

        self.lista3 = ListaEnlazada()
        self.lista3.agregar(self.ELEM_0, 0)
        self.lista3.agregar(self.ELEM_1, 1)
        self.lista3.agregar(self.ELEM_2, 2)

        self.lista_vacia_py = ListaConPyLista()

        self.lista_py_1 = ListaConPyLista()
        self.lista_py_1.agregar(self.ELEM_0, 0)

        self.lista_py_2 = ListaConPyLista()
        self.lista_py_2.agregar(self.ELEM_0, 0)
        self.lista_py_2.agregar(self.ELEM_1, 1)

        self.lista_py_3 = ListaConPyLista()
        self.lista_py_3.agregar(self.ELEM_0, 0)
        self.lista_py_3.agregar(self.ELEM_1, 1)
        self.lista_py_3.agregar(self.ELEM_2, 2)

    def test_inicio(self):
        rec = Recorredor(self.lista_vacia)
        self.assertEqual(self.lista_vacia, rec._lista)
        self.assertEqual(None, rec._actual)

        rec2 = Recorredor(self.lista3)
        self.assertEqual(self.lista3, rec2._lista)
        self.assertEqual(None, rec2._actual)

        recpy = Recorredor(self.lista_vacia_py)
        self.assertEqual(self.lista_vacia_py, recpy._lista)
        self.assertEqual(None, recpy._actual)

        rec2 = Recorredor(self.lista3)
        self.assertEqual(self.lista3, rec2._lista)
        self.assertEqual(None, rec2._actual)

    def test_comenzar_vacia(self):
        rec = Recorredor(self.lista_vacia)
        self.assertRaises(StopIteration, rec.comenzar)

        recpy = Recorredor(self.lista_vacia_py)
        self.assertRaises(StopIteration, rec.comenzar)

    def test_comenzar_no_vacia(self):
        rec1 = Recorredor(self.lista1)
        rec2 = Recorredor(self.lista2)
        rec3 = Recorredor(self.lista3)

        rec1.comenzar()
        rec2.comenzar()
        rec3.comenzar()

        self.assertEqual(0, rec1._actual)
        self.assertEqual(0, rec2._actual)
        self.assertEqual(0, rec3._actual)

        recpy1 = Recorredor(self.lista_py_1)
        recpy2 = Recorredor(self.lista_py_2)
        recpy3 = Recorredor(self.lista_py_3)

        recpy1.comenzar()
        recpy2.comenzar()
        recpy3.comenzar()

        self.assertEqual(0, recpy1._actual)
        self.assertEqual(0, recpy2._actual)
        self.assertEqual(0, recpy3._actual)

    def test_elemento(self):
        rec = Recorredor(self.lista3)
        rec.comenzar()

        rec._actual = 0
        self.assertEqual(self.ELEM_0, rec.elemento())

        rec._actual = 1
        self.assertEqual(self.ELEM_1, rec.elemento())

        rec._actual = 2
        self.assertEqual(self.ELEM_2, rec.elemento())

        recpy = Recorredor(self.lista_py_3)
        recpy.comenzar()

        recpy._actual = 0
        self.assertEqual(self.ELEM_0, recpy.elemento())

        recpy._actual = 1
        self.assertEqual(self.ELEM_1, recpy.elemento())

        recpy._actual = 2
        self.assertEqual(self.ELEM_2, recpy.elemento())

    def test_proximo_no_hay(self):
        rec = Recorredor(self.lista1)
        rec.comenzar()
        self.assertRaises(StopIteration, rec.proximo)

        rec2 = Recorredor(self.lista3)
        rec2._actual = 2
        self.assertRaises(StopIteration, rec2.proximo)

        recpy = Recorredor(self.lista_py_1)
        recpy.comenzar()
        self.assertRaises(StopIteration, recpy.proximo)

        recpy2 = Recorredor(self.lista_py_3)
        recpy2._actual = 2
        self.assertRaises(StopIteration, recpy2.proximo)

    def test_proximo(self):
        rec = Recorredor(self.lista3)
        rec.comenzar()
        rec.proximo()

        self.assertEqual(self.ELEM_1, rec.elemento())
        rec.proximo()

        self.assertEqual(self.ELEM_2, rec.elemento())

        self.assertRaises(StopIteration, rec.proximo)

        recpy = Recorredor(self.lista_py_3)
        recpy.comenzar()
        recpy.proximo()

        self.assertEqual(self.ELEM_1, recpy.elemento())
        recpy.proximo()

        self.assertEqual(self.ELEM_2, recpy.elemento())

        self.assertRaises(StopIteration, recpy.proximo)

    def test_fin_si(self):
        rec1 = Recorredor(self.lista1)
        rec2 = Recorredor(self.lista2)
        rec3 = Recorredor(self.lista3)

        rec1._actual = 0
        rec2._actual = 1
        rec3._actual = 2

        self.assertTrue(rec1.fin())
        self.assertTrue(rec2.fin())
        self.assertTrue(rec3.fin())

        recpy1 = Recorredor(self.lista_py_1)
        recpy2 = Recorredor(self.lista_py_2)
        recpy3 = Recorredor(self.lista_py_3)

        recpy1._actual = 0
        recpy2._actual = 1
        recpy3._actual = 2

        self.assertTrue(recpy1.fin())
        self.assertTrue(recpy2.fin())
        self.assertTrue(recpy3.fin())
        recpy1 = Recorredor(self.lista_py_1)
        recpy2 = Recorredor(self.lista_py_2)
        recpy3 = Recorredor(self.lista_py_3)

        recpy1._actual = 0
        recpy2._actual = 1
        recpy3._actual = 2

        self.assertTrue(recpy1.fin())
        self.assertTrue(recpy2.fin())
        self.assertTrue(recpy3.fin())

    def test_fin_no(self):
        rec2 = Recorredor(self.lista2)
        rec3 = Recorredor(self.lista3)

        rec2._actual = 0
        rec3._actual = 0

        self.assertFalse(rec2.fin())
        self.assertFalse(rec3.fin())

        rec3._actual = 1
        self.assertFalse(rec3.fin())

        recpy2 = Recorredor(self.lista_py_2)
        recpy3 = Recorredor(self.lista_py_3)

        recpy2._actual = 0
        recpy3._actual = 0

        self.assertFalse(recpy2.fin())
        self.assertFalse(recpy3.fin())

        recpy3._actual = 1
        self.assertFalse(recpy3.fin())

    def test_agregar(self):
        NEW_DUMMY_0 = 'new_dummy_0'
        NEW_DUMMY_1 = 'new_dummy_1'
        NEW_DUMMY_2 = 'new_dummy_2'

        rec = Recorredor(self.lista3)

        rec._actual = 0
        rec.agregar(NEW_DUMMY_0)
        self.assertEqual(NEW_DUMMY_0, rec.elemento())
        self.assertEqual(NEW_DUMMY_0, self.lista3.elemento(0))

        rec._actual = 1
        rec.agregar(NEW_DUMMY_1)
        self.assertEqual(NEW_DUMMY_1, rec.elemento())
        self.assertEqual(NEW_DUMMY_1, self.lista3.elemento(1))

        rec._actual = 2
        rec.agregar(NEW_DUMMY_2)
        self.assertEqual(NEW_DUMMY_2, rec.elemento())
        self.assertEqual(NEW_DUMMY_2, self.lista3.elemento(2))

        recpy = Recorredor(self.lista_py_3)

        recpy._actual = 0
        recpy.agregar(NEW_DUMMY_0)
        self.assertEqual(NEW_DUMMY_0, recpy.elemento())
        self.assertEqual(NEW_DUMMY_0, self.lista_py_3.elemento(0))

        recpy._actual = 1
        recpy.agregar(NEW_DUMMY_1)
        self.assertEqual(NEW_DUMMY_1, recpy.elemento())
        self.assertEqual(NEW_DUMMY_1, self.lista_py_3.elemento(1))

        recpy._actual = 2
        recpy.agregar(NEW_DUMMY_2)
        self.assertEqual(NEW_DUMMY_2, recpy.elemento())
        self.assertEqual(NEW_DUMMY_2, self.lista_py_3.elemento(2))

    def test_eliminar(self):
        rec = Recorredor(self.lista3)
        tamanio = self.lista3.getTamanio()
        rec._actual = 2

        rec.eliminar()
        self.assertEqual(tamanio - 1, self.lista3.getTamanio())

        rec.eliminar()
        self.assertEqual(tamanio - 2, self.lista3.getTamanio())

        rec.eliminar()
        self.assertEqual(tamanio - 3, self.lista3.getTamanio())

        recpy = Recorredor(self.lista_py_3)
        tamanio = self.lista_py_3.getTamanio()
        recpy._actual = 2

        recpy.eliminar()
        self.assertEqual(tamanio - 1, self.lista_py_3.getTamanio())

        recpy.eliminar()
        self.assertEqual(tamanio - 2, self.lista_py_3.getTamanio())

        recpy.eliminar()
        self.assertEqual(tamanio - 3, self.lista_py_3.getTamanio())
class TestListaConPyListas(unittest.TestCase):
    def setUp(self):
        self.lista = ListaConPyLista()

    def test_lista_inicio_none(self):
        self.assertEqual([], self.lista._datos)

    def test_lista_vacia_si(self):
        self.assertTrue(self.lista.esVacia())

    def test_lista_vacia_no(self):
        self.lista._datos = [1, 2, 3, 4]
        self.lista._tamanio = 4
        self.assertFalse(self.lista.esVacia())

    def test_str(self):
        self.assertEqual("[]", str(self.lista))
        self.lista._datos = [1, 2, 3, 4]
        self.lista._tamanio = 4
        self.assertEqual("[1, 2, 3, 4]", str(self.lista))

    def test_elemento_lista_vacia(self):
        self.assertRaises(IndexError, self.lista.elemento, 0)
        self.assertRaises(IndexError, self.lista.elemento, 2)

    def test_elemento_pos_menor_cero(self):
        self.assertRaises(IndexError, self.lista.elemento, -1)

    def test_elemento_en_posiciones_ordenadas(self):
        self.lista._datos = ["dummy_0", "dummy_1", "dummy_2", "dummy_3"]
        self.lista._tamanio = 4

        self.assertEqual("dummy_0", self.lista.elemento(0))
        self.assertEqual("dummy_1", self.lista.elemento(1))
        self.assertEqual("dummy_2", self.lista.elemento(2))
        self.assertEqual("dummy_3", self.lista.elemento(3))

    def test_elemento_en_posiciones_desordenadas(self):
        self.lista._datos = ["dummy_0", "dummy_1", "dummy_2", "dummy_3"]
        self.lista._tamanio = 4

        self.assertEqual("dummy_3", self.lista.elemento(3))
        self.assertEqual("dummy_1", self.lista.elemento(1))
        self.assertEqual("dummy_0", self.lista.elemento(0))
        self.assertEqual("dummy_2", self.lista.elemento(2))

    def test_agregar_a_lista_pos_menor_0(self):
        self.assertRaises(IndexError, self.lista.agregar, "dummy", -1)

    def test_agregar_a_lista_pos_mayor_tamanio_lista(self):
        self.assertRaises(IndexError, self.lista.agregar, "dummy", 1)
        self.lista._tamanio = 1
        self.assertRaises(IndexError, self.lista.agregar, "dummy", 2)

    def test_agregar_a_lista_nueva(self):
        self.lista.agregar("dummy_0", 0)
        self.assertEqual("dummy_0", self.lista.elemento(0))

        self.lista.agregar("dummy_1", 1)
        self.assertEqual("dummy_1", self.lista.elemento(1))

        self.lista.agregar("dummy_2", 0)
        self.assertEqual("dummy_2", self.lista.elemento(0))
        self.assertEqual("dummy_0", self.lista.elemento(1))
        self.assertEqual("dummy_1", self.lista.elemento(2))

    def test_incluye_lista_vacia(self):
        self.assertFalse(self.lista.incluye("dummy_0"))

    def test_incluye_existe(self):
        self.lista._datos = ["dummy_0", "dummy_1", "dummy_2", "dummy_3"]
        self.lista._tamanio = 4

        self.assertTrue(self.lista.incluye("dummy_0"))
        self.assertTrue(self.lista.incluye("dummy_1"))
        self.assertTrue(self.lista.incluye("dummy_2"))
        self.assertTrue(self.lista.incluye("dummy_3"))

    def test_incluye_no_existe(self):
        self.lista._datos = ["dummy_0", "dummy_1", "dummy_2", "dummy_3"]
        self.assertFalse(self.lista.incluye("dummy_4"))
        self.assertFalse(self.lista.incluye("dummy_5"))

    def test_eliminar_index_error(self):
        lista = ListaEnlazada()
        lista.agregar("dummy_0", 0)
        lista.agregar("dummy_1", 1)
        lista.agregar("dummy_2", 2)
        lista.agregar("dummy_3", 3)

    def test_eliminar_ok(self):
        self.lista._datos = ["dummy_0"]
        self.lista._tamanio = 1
        self.lista.eliminar(0)
        self.assertTrue(self.lista.esVacia())
        self.assertFalse(self.lista.incluye("dummy0"))

        self.lista._datos = ["dummy_0", "dummy_1", "dummy_2", "dummy_3"]
        self.lista._tamanio = 4
        tamanio = self.lista.getTamanio()

        self.lista.eliminar(2)
        self.assertEqual(tamanio - 1, self.lista.getTamanio())
        self.assertFalse(self.lista.incluye("dummy2"))

        self.lista.eliminar(2)
        self.assertEqual(tamanio - 2, self.lista.getTamanio())
        self.assertFalse(self.lista.incluye("dummy3"))

        self.lista.eliminar(0)
        self.assertEqual(tamanio - 3, self.lista.getTamanio())
        self.assertFalse(self.lista.incluye("dummy0"))

        self.lista.eliminar(0)
        self.assertEqual(tamanio - 4, self.lista.getTamanio())
        self.assertFalse(self.lista.incluye("dummy1"))

    def test_eliminar_pos_error(self):
        self.lista._datos = ["dummy_0", "dummy_1", "dummy_2"]
        self.lista._tamanio = 34

        tamanio = self.lista.getTamanio()

        self.assertRaises(IndexError, self.lista.eliminar, 3)
        self.assertRaises(IndexError, self.lista.eliminar, 4)
        self.assertRaises(IndexError, self.lista.eliminar, -1)

        self.assertEqual(tamanio, self.lista.getTamanio())
        self.assertTrue(self.lista.incluye("dummy_0"))
        self.assertTrue(self.lista.incluye("dummy_1"))
        self.assertTrue(self.lista.incluye("dummy_2"))