def test_kosaraju(self):
graph = g.newGraph(12, self.comparenames, directed=True)
idscc = m.newMap(12,
maptype='PROBING',
comparefunction=self.comparenames)
pre = q.newQueue()
post = q.newQueue()
reversepost = s.newStack()
marked = m.newMap(12, comparefunction=self.comparenames)
grmarked = m.newMap(12,
maptype='PROBING',
comparefunction=self.comparenames)
grpre = q.newQueue()
grpost = q.newQueue()
grreversepost = s.newStack()
# se inicializa el grafo
self.loadgraph(graph)
self.assertEqual(g.numVertex(graph), 12)
self.assertEqual(g.numEdges(graph), 14)
# Se calcula el grafo reverso de G
greverse = self.reverse(graph)
self.assertEqual(g.numVertex(greverse), 12)
self.assertEqual(g.numEdges(greverse), 14)
# Se recorre el grafor reverso de G, utilizando DepthFirstOrder.
self.dfo(greverse, grmarked, grpre, grpost, grreversepost)
lst = self.lstReversePost(grreversepost)
#lst contiene los vertices retornados por reversepost (G-reverso)
#Se recorre el grafo en el orden dado por reverspost (G-reverso)
iterlst = it.newIterator(lst)
scc = 1
while (it.hasNext(iterlst)):
vert = it.next(iterlst)
if not m.contains(marked, vert):
self.sccCount(graph, vert, marked, idscc, scc)
scc += 1
self.assertTrue(self.stronglyConnected(idscc, 'Pedro', 'Maria'))
self.assertTrue(self.stronglyConnected(idscc, 'Martin', 'Gloria'))
self.assertTrue(self.stronglyConnected(idscc, 'Susana', 'Tere'))
self.assertFalse(self.stronglyConnected(idscc, 'Pedro', 'Gloria'))
self.assertFalse(self.stronglyConnected(idscc, 'Camila', 'Jose'))
self.assertFalse(self.stronglyConnected(idscc, 'Gloria', 'Luz'))
def pathTo(search, v):
if hasPathTo(search, v)==False:
return None
path= stk.newStack()
# Loop through previous vertices (edgeTo) until source vertex:
# Add each previous vertex to the path
# At the end of the loop, add the source vertex to the path
return path
def pathTo(search, v):
if hasPathTo(search, v)==False:
return None
path= stk.newStack()
while v != search['s']:
stk.push(path,v)
v = map.get(search['visitedMap'],v)['value']['edgeTo']
stk.push(path,search['s'])
return path
def test_error_pop():
"""
Este test busca comprobar que es imposible eliminar un objeto de una pila vacia
"""
stack = st.newStack(list_type)
assert (st.size(stack) == 0)
assert (st.isEmpty(stack))
with pytest.raises(Exception):
st.pop(stack)
def pathTo(search, v):
if hasPathTo(search, v) == False:
return None
path = stk.newStack()
while v != search['s']:
visited_v = map.get(search['visitedMap'], v)['value']
edge = visited_v['edgeTo']
stk.push(path, edge)
v = e.either(edge)
return path
def pathTo(search, v):
if hasPathTo(search, v) == False:
return None
path = stk.newStack()
while v != search['s']:
stk.push(path, v)
v = map.get(search['visitedMap'], v)['value']['edgeTo']
stk.push(path, search['s'])
# Loop through previous vertices (edgeTo) until source vertex:
# Add each previous vertex to the path
# At the end of the loop, add the source vertex to the path
return path
def test_push_pop():
"""
Este test prueba que la cola pueda manejar inserciones y eliminaciones de forma correcta siguiendo
un orden establecido, y que no quede referencia al objeto sacado despues de haberlo removido de la
cola
"""
stack = st.newStack(list_type)
assert (st.size(stack) == 0)
assert (st.isEmpty(stack))
st.push(stack, book5)
assert (st.size(stack) == 1)
assert (st.top(stack) == st.pop(stack))
assert (st.size(stack) == 0)
st.push(stack, book6)
assert (st.size(stack) == 1)
assert (st.top(stack) == st.pop(stack))
assert (st.size(stack) == 0)
st.push(stack, book3)
assert (st.size(stack) == 1)
assert (st.top(stack) == st.pop(stack))
assert (st.size(stack) == 0)
st.push(stack, book10)
assert (st.size(stack) == 1)
assert (st.top(stack) == st.pop(stack))
assert (st.size(stack) == 0)
st.push(stack, book1)
assert (st.size(stack) == 1)
assert (st.top(stack) == st.pop(stack))
assert (st.size(stack) == 0)
st.push(stack, book2)
assert (st.size(stack) == 1)
assert (st.top(stack) == st.pop(stack))
assert (st.size(stack) == 0)
st.push(stack, book8)
st.push(stack, book4)
st.push(stack, book7)
st.push(stack, book9)
assert (st.size(stack) == 4)
assert book9 == st.pop(stack)
assert book7 == st.pop(stack)
assert book4 == st.pop(stack)
assert book8 == st.pop(stack)
assert (st.size(stack) == 0)
def test_sizeStack(self):
"""
"""
self.stack = st.newStack(self.list_type)
self.assertEqual(st.size(self.stack), 0)
self.assertTrue(st.isEmpty(self.stack))
st.push(self.stack, self.movie5)
st.push(self.stack, self.movie6)
st.push(self.stack, self.movie3)
st.push(self.stack, self.movie10)
st.push(self.stack, self.movie1)
st.push(self.stack, self.movie2)
st.push(self.stack, self.movie8)
st.push(self.stack, self.movie4)
st.push(self.stack, self.movie7)
st.push(self.stack, self.movie9)
self.assertEqual(st.size(self.stack), 10)
def test_sizeStack (self):
"""
"""
self.stack = st.newStack(self.list_type)
self.assertEqual (st.size(self.stack), 0)
self.assertTrue (st.isEmpty(self.stack))
st.push (self.stack, self.book5)
st.push (self.stack, self.book6)
st.push (self.stack, self.book3)
st.push (self.stack, self.book10)
st.push (self.stack, self.book1)
st.push (self.stack, self.book2)
st.push (self.stack, self.book8)
st.push (self.stack, self.book4)
st.push (self.stack, self.book7)
st.push (self.stack, self.book9)
self.assertEqual (st.size(self.stack), 10)
def test_sizeStack():
"""
Se prueba la creacion de una cola y la relacion con el tamaño al ingresar datos
"""
stack = st.newStack(list_type)
assert (st.size(stack) == 0)
assert (st.isEmpty(stack))
st.push(stack, book5)
st.push(stack, book6)
st.push(stack, book3)
st.push(stack, book10)
st.push(stack, book1)
st.push(stack, book2)
st.push(stack, book8)
st.push(stack, book4)
st.push(stack, book7)
st.push(stack, book9)
assert st.size(stack) == 10
def test_topological(self):
graph = g.newGraph(10, self.comparenames, directed=True)
pre = q.newQueue()
post = q.newQueue()
reversepost = s.newStack()
marked = m.newMap(10, comparefunction=self.comparenames)
g.insertVertex(graph, 'Calculo1')
g.insertVertex(graph, 'Calculo2')
g.insertVertex(graph, 'Diseno1')
g.insertVertex(graph, 'Diseno2')
g.insertVertex(graph, 'Electiva')
g.insertVertex(graph, 'Fisica1')
g.insertVertex(graph, 'Ingles')
g.insertVertex(graph, 'IP1')
g.insertVertex(graph, 'IP2')
g.insertVertex(graph, 'ProyectoFinal')
g.addEdge(graph, 'Calculo1', 'Calculo2')
g.addEdge(graph, 'Calculo2', 'IP2')
g.addEdge(graph, 'Calculo2', 'Fisica1')
g.addEdge(graph, 'Diseno1', 'Diseno2')
g.addEdge(graph, 'Diseno2', 'ProyectoFinal')
g.addEdge(graph, 'Electiva', 'ProyectoFinal')
g.addEdge(graph, 'Fisica1', 'Diseno2')
g.addEdge(graph, 'Ingles', 'ProyectoFinal')
g.addEdge(graph, 'IP1', 'Diseno1')
g.addEdge(graph, 'IP1', 'IP2')
self.assertEqual(g.numEdges(graph), 10)
self.assertEqual(g.numVertex(graph), 10)
#DFO
lstvert = g.vertices(graph)
vertiterator = it.newIterator(lstvert)
while it.hasNext(vertiterator):
vert = it.next(vertiterator)
if not (m.contains(marked, vert)):
self.dfs(graph, vert, marked, pre, post, reversepost)
self.printTopological(reversepost)
def test_pushElements():
"""
Se prueba la creacion de una nueva pila, se agregan todos los datos creados por sistema y se imprime su valor
"""
stack = st.newStack(list_type)
st.push(stack, book5)
st.push(stack, book6)
st.push(stack, book3)
st.push(stack, book10)
st.push(stack, book1)
st.push(stack, book2)
st.push(stack, book8)
st.push(stack, book4)
st.push(stack, book7)
st.push(stack, book9)
iterator = it.newIterator(stack)
while it.hasNext(iterator):
element = it.next(iterator)
result = "".join(str(key) + ": " + str(value) + ", " for key, value in element.items())
print(result)
def test_pushElements (self):
"""
"""
self.stack = st.newStack(self.list_type)
st.push (self.stack, self.book5)
st.push (self.stack, self.book6)
st.push (self.stack, self.book3)
st.push (self.stack, self.book10)
st.push (self.stack, self.book1)
st.push (self.stack, self.book2)
st.push (self.stack, self.book8)
st.push (self.stack, self.book4)
st.push (self.stack, self.book7)
st.push (self.stack, self.book9)
iterator = it.newIterator(self.stack)
while it.hasNext(iterator):
element = it.next(iterator)
result = "".join(str(key) + ": " + str(value) + ", " for key, value in element.items())
print (result)
def test_infoElements():
"""
Este test busca confirmar que los datos se almacenen de forma correcta y que
sean los valores correctos en el orden apropiado de la estructura.
"""
stack = st.newStack(list_type)
assert (st.size(stack) == 0)
assert (st.isEmpty(stack))
st.push(stack, book5)
st.push(stack, book6)
st.push(stack, book3)
st.push(stack, book10)
st.push(stack, book1)
st.push(stack, book2)
st.push(stack, book8)
st.push(stack, book4)
st.push(stack, book7)
st.push(stack, book9)
elem = st.top(stack)
assert (st.size(stack) == 10)
assert (elem == book9)
elem = st.pop(stack)
assert (st.size(stack) == 9)
assert (elem == book9)
elem = st.pop(stack)
assert (st.size(stack) == 8)
assert (elem == book7)
elem = st.top(stack)
assert (st.size(stack) == 8)
assert (elem == book4)
st.push(stack, book9)
assert (st.size(stack) == 9)
elem = st.top(stack)
assert (elem == book9)
def test_pushElements(self):
"""
"""
self.stack = st.newStack(self.list_type)
st.push(self.stack, self.movie5)
st.push(self.stack, self.movie6)
st.push(self.stack, self.movie3)
st.push(self.stack, self.movie10)
st.push(self.stack, self.movie1)
st.push(self.stack, self.movie2)
st.push(self.stack, self.movie8)
st.push(self.stack, self.movie4)
st.push(self.stack, self.movie7)
st.push(self.stack, self.movie9)
iterator = it.newIterator(self.stack)
while it.hasNext(iterator):
element = it.next(iterator)
result = "".join(
str(key) + ": " + str(value) + ", "
for key, value in element.items())
print(result)
def test_infoElements(self):
"""
"""
self.stack = st.newStack(self.list_type)
self.assertEqual(st.size(self.stack), 0)
self.assertTrue(st.isEmpty(self.stack))
st.push(self.stack, self.movie5)
st.push(self.stack, self.movie6)
st.push(self.stack, self.movie3)
st.push(self.stack, self.movie10)
st.push(self.stack, self.movie1)
st.push(self.stack, self.movie2)
st.push(self.stack, self.movie8)
st.push(self.stack, self.movie4)
st.push(self.stack, self.movie7)
st.push(self.stack, self.movie9)
elem = st.top(self.stack)
self.assertEqual(st.size(self.stack), 10)
self.assertDictEqual(elem, self.movie9)
elem = st.pop(self.stack)
self.assertEqual(st.size(self.stack), 9)
self.assertDictEqual(elem, self.movie9)
elem = st.pop(self.stack)
self.assertEqual(st.size(self.stack), 8)
self.assertDictEqual(elem, self.movie7)
elem = st.top(self.stack)
self.assertEqual(st.size(self.stack), 8)
self.assertDictEqual(elem, self.movie4)
st.push(self.stack, self.movie9)
self.assertEqual(st.size(self.stack), 9)
elem = st.top(self.stack)
self.assertDictEqual(elem, self.movie9)
def test_infoElements (self):
"""
"""
self.stack = st.newStack(self.list_type)
self.assertEqual (st.size(self.stack), 0)
self.assertTrue (st.isEmpty(self.stack))
st.push (self.stack, self.book5)
st.push (self.stack, self.book6)
st.push (self.stack, self.book3)
st.push (self.stack, self.book10)
st.push (self.stack, self.book1)
st.push (self.stack, self.book2)
st.push (self.stack, self.book8)
st.push (self.stack, self.book4)
st.push (self.stack, self.book7)
st.push (self.stack, self.book9)
elem = st.top (self.stack)
self.assertEqual (st.size(self.stack), 10)
self.assertDictEqual (elem, self.book9)
elem = st.pop (self.stack)
self.assertEqual (st.size(self.stack), 9)
self.assertDictEqual (elem, self.book9)
elem = st.pop (self.stack)
self.assertEqual (st.size(self.stack), 8)
self.assertDictEqual (elem, self.book7)
elem = st.top (self.stack)
self.assertEqual (st.size(self.stack), 8)
self.assertDictEqual (elem, self.book4)
st.push (self.stack, self.book9)
self.assertEqual (st.size(self.stack), 9)
elem = st.top (self.stack)
self.assertDictEqual (elem, self.book9)
def test_top_pop():
"""
Este test prueba la creacion de una cola y que el orden de salida sea el correcto para la
estructura en cuestion, y que el tamaño se reduzca para cada salida de objeto
"""
stack = st.newStack(list_type)
assert st.size(stack) == 0
assert st.isEmpty(stack)
st.push(stack, book5)
st.push(stack, book6)
st.push(stack, book3)
st.push(stack, book10)
st.push(stack, book1)
st.push(stack, book2)
st.push(stack, book8)
st.push(stack, book4)
st.push(stack, book7)
st.push(stack, book9)
total = st.size(stack)
while not (st.isEmpty(stack)):
top = st.top(stack)
assert (st.pop(stack) == top)
total -= 1
assert (total == st.size(stack))
