def test_find_path_direct_connection():
a = Vertex("A13")
b = Vertex("A14")
a.add_edge(Edge(b))
assert find_path(a, b) == [a, b]
# Path is only in one direction
assert find_path(b, a) == []
def action_link_down(args, test_step, expected, params_list):
analyzer_name = choose_analyzer(params_list, 0)
checks = []
affected_talkers = set()
# Expect all the connections which cross the relay to be lost
for c,n in state.get_current().active_connections.iteritems():
if not n:
continue
path = graph.find_path(state.get_current(), c.talker.src, c.listener.dst)
if path and analyzer_name in path:
affected_talkers |= set([c.talker])
checks += [Expected(c.listener.dst, "ADP: Removing entity who timed out -> GUID", 30)]
checks += sequences.analyzer_listener_disconnect_seq(test_step,
c.talker.src, c.talker.src_stream,
c.listener.dst, c.listener.dst_stream)
state.get_next().disconnect(c.talker.src, c.talker.src_stream, c.listener.dst, c.listener.dst_stream)
for talker in affected_talkers:
if not state.get_next().talker_active_count(talker.src, talker.src_stream):
checks += [Expected(talker.src, "Talker stream #%d off" % talker.src_stream, 30)]
# Send the command to close the relay '(r)elay (c)lose'
args.master.sendLine(analyzer_name, "r o")
state.get_next().set_relay_open(analyzer_name)
if test_step.do_checks and checks:
expected += [AllOf(checks)]
yield args.master.expect(None)
else:
# At least allow time for the relay to actually be closed
yield base.sleep(0.1)
def analyzer_qav_seq(test_step, src, dst, action, user):
""" Get the expected sequence for any QAV analyzers active.
"""
analyzer_expect = []
for analyzer_name,analyzer in analyzers.get_all().iteritems():
if analyzer['type'] != 'qav':
continue
# If the analyzer is a QAV analyzer then it will detect the stream through
# the packets being forwarded through it
if analyzer_name in graph.find_path(state.get_current(), src, dst):
guid_string = endpoints.guid_in_ascii(user, endpoints.get(src))
stream_string = endpoints.stream_from_guid(guid_string)
if action == 'connect':
action_string = "Adding"
completionFn = hook_register_error
else:
action_string = "Removing"
completionFn = hook_unregister_error
analyzer_expect += [Expected(analyzer_name, "%s stream 0x%s" % (action_string, stream_string),
timeoutTime=10,
completionFn=completionFn,
completionArgs=(analyzer_name, ['ERROR']))]
return analyzer_expect
def test_find_path_chain():
a = Vertex("A15")
b = Vertex("A16")
c = Vertex("A17")
a.add_edge(Edge(b))
b.add_edge(Edge(c))
assert find_path(a, c) == [a, b, c]
def action_disconnect(args, test_step, expected, params_list):
src = choose_src(params_list, 0)
src_stream = choose_src_stream(params_list, 1)
dst = choose_dst(params_list, 2)
dst_stream = choose_dst_stream(params_list, 3)
controller_disconnect(args, test_step, expected, src, dst_stream, dst, dst_stream)
(talker_expect, listener_expect, controller_expect) = get_expected(
args, test_step, src, src_stream, dst, dst_stream, 'disconnect')
# Find the path between the src and dst and check whether there are any nodes between them
forward_disable = []
nodes = endpoints.get_path_endpoints(graph.find_path(state.get_current(), src, dst))
for node in get_dual_port_nodes(nodes):
if graph.node_will_see_stream_disable(state.get_current(), src, src_stream, dst, dst_stream, node):
forward_disable += sequences.expected_seq('stream_forward_disable')(test_step, args.user,
endpoints.get(node), endpoints.get(src))
forward_disable += sequences.expected_seq('port_shaper_disconnect')(test_step, endpoints.get(node),
src, src_stream, dst, dst_stream)
# If there are any nodes in the chain then the forward disabling is expected before the
# audio will be seen to be lost
if forward_disable and listener_expect:
listener_expect = [Sequence([AllOf(forward_disable)] + listener_expect)]
elif forward_disable:
listener_expect = forward_disable
elif listener_expect:
listener_expect = listener_expect
else:
listener_expect = []
# Expect not to see any disables from other nodes
not_forward_disable = []
temp_nodes = set(endpoints.get_all().keys()) - set(nodes)
for node in get_dual_port_nodes(temp_nodes):
not_forward_disable += sequences.expected_seq('stream_forward_disable')(test_step, args.user,
endpoints.get(node), endpoints.get(src))
if not_forward_disable:
if test_step.checkpoint is None:
not_forward_disable = [NoneOf(not_forward_disable)]
else:
not_forward_disable = []
for node in get_dual_port_nodes(temp_nodes):
not_forward_disable += sequences.expected_seq('port_shaper_disconnect')(test_step, endpoints.get(node),
src, src_stream, dst, dst_stream)
if test_step.checkpoint:
final_port_shaper_states = sequences.get_and_clear_final_port_shaper_states()
else:
final_port_shaper_states = []
if test_step.do_checks and (talker_expect or listener_expect or controller_expect or
not_forward_disable or final_port_shaper_states):
expected += [AllOf(talker_expect + listener_expect + controller_expect +
not_forward_disable + final_port_shaper_states)]
yield args.master.expect(None)
def get_talker_state(self, src, src_stream, dst, dst_stream, action):
if graph.find_path(self, src, dst) is None:
state = 'talker_redundant'
elif action == 'connect':
if self.connected(src, src_stream, dst, dst_stream):
state = 'talker_redundant'
else:
if self.listener_active_count(dst, dst_stream):
state = 'talker_redundant'
elif self.talker_active_count(src, src_stream):
state = 'talker_existing'
else:
state = 'talker_new'
elif action == 'disconnect':
if not self.connected(src, src_stream, dst, dst_stream):
state = 'talker_redundant'
else:
if self.talker_active_count(src, src_stream) == 1:
state = 'talker_all'
else:
state = 'talker_existing'
else:
base.testError("Unknown action '%s'" % action, critical=True)
log_debug("get_talker_state for %s %d %s %d: %s" % (src, src_stream, dst, dst_stream, state))
return (state + '_' + action)
def connect(self, src, src_stream, dst, dst_stream):
""" A connection will occur if the connection doesn't already exist
and the listener is not in use. There must also be a valid path
between the two endpoints and the src and dst must be different.
"""
if (self.connected(src, src_stream, dst, dst_stream) or
self.listener_active_count(dst, dst_stream)):
return
# If it is a self-connect the talker will still be made ready
self.talker_on_count[src] = self.talker_on_count.get(src, 0) + 1
if src == dst:
return
path = graph.find_path(self, src, dst)
if not path:
return
talker = Talker(src, src_stream)
listener = Listener(dst, dst_stream)
connection = Connection(talker, listener)
self.active_talkers[talker] = self.active_talkers.get(talker, 0) + 1
self.active_listeners[listener] = 1 # Listeners can only accept one connection
self.active_connections[connection] = self.active_connections.get(connection, 0) + 1
def test_find_path_cycle():
a = Vertex("A33")
b = Vertex("A34")
c = Vertex("A35")
a.add_edge(Edge(b))
b.add_edge(Edge(a))
b.add_edge(Edge(c))
assert find_path(a, c) == [a, b, c]
def test_find_path_ignores_weights():
a = Vertex(Vertex._make_test_vertex())
b = Vertex(Vertex._make_test_vertex())
a.add_edge(Edge(b, 1))
c = Vertex(Vertex._make_test_vertex())
a.add_edge(Edge(c, 100))
b.add_edge(Edge(c, 1))
assert find_path(a, c) == [a, c]
def action_link_downup(args, test_step, expected, params_list):
""" Expect all connections which bridge the relay to be lost and restored if there
is a quick link down/up event. The first argument is the analyzer controlling
the relay. The second is the time to sleep before restoring the link.
"""
analyzer_name = choose_analyzer(params_list, 0)
sleep_time = int(params_list[1])
lost = []
# Expect all the connections which cross the relay to be lost
for c,n in state.get_current().active_connections.iteritems():
if n and analyzer_name in graph.find_path(state.get_current(), c.talker.src, c.listener.dst):
lost += sequences.analyzer_listener_disconnect_seq(test_step,
c.talker.src, c.talker.src_stream,
c.listener.dst, c.listener.dst_stream)
# Send the command to open the relay '(r)elay (o)pen'
args.master.sendLine(analyzer_name, "r o")
state.get_next().set_relay_open(analyzer_name)
if test_step.do_checks and lost:
expected += [AllOf(lost)]
# Perform a sleep as defined by the second argument
yield base.sleep(sleep_time)
found = []
# Expect all the connections which cross the relay to be restored
state.get_next().set_relay_closed(analyzer_name)
for c,n in state.get_current().active_connections.iteritems():
if n and analyzer_name in graph.find_path(state.get_current(), c.talker.src, c.listener.dst):
found += sequences.analyzer_listener_connect_seq(test_step,
c.talker.src, c.talker.src_stream,
c.listener.dst, c.listener.dst_stream)
# Send the command to close the relay '(r)elay (c)lose'
args.master.sendLine(analyzer_name, "r c")
if test_step.do_checks and found:
expected += [AllOf(found)]
yield args.master.expect(None)
def find_path(self, start, end, skips=None, callback=None, _=''):
cherrypy.response.headers["Access-Control-Allow-Origin"] = "*"
if callback:
cherrypy.response.headers['Content-Type']= 'text/javascript'
else:
cherrypy.response.headers['Content-Type']= 'application/json'
start_time = time.time()
skips = make_list(skips)
status, path = graph.find_path(start, end, skips)
results = {}
results['status'] = status
if path:
results['path'] = [graph.get_artist(id) for id in path]
results['time'] = time.time() - start_time
return to_json(results, callback)
def find_path_to_end(self, g, start):
'''
Find the start and end points in order for the solution route to be the longest
possible with no backtracking. Uses dynamic programming(???).
Arg: reached is a dictionary whose keys are the vertices that can be reached
the maze start and reached[u] is the vertex that discovered u in the search
Returns the route as a list with the first entry as the start and the last
entry as the end.
'''
paths = [] # store all possible paths from the start
vertices = list(g.vertices())
reached = graph.search(g, start)
for v in vertices:
# find the path from start to v
paths.append(graph.find_path(g, start, v, reached))
# return the longest path
# the last entry is the end of the maze
return max(paths, key=len)
def test_find_path_start_is_end():
a = Vertex("A12")
assert find_path(a, a) == [a]
def test_find_path_no_path():
a = Vertex("A10")
b = Vertex("A11")
assert find_path(a, b) == []
points = graph.articulation_point(g)
print("Os pontos de articulação são:")
print("\n".join(points))
elif choice == 4:
bridges = graph.bridges(g)
print("As pontes são:")
for key, value in bridges.items():
if not key: continue
print(key + " - " + ", ".join(value))
else:
c1 = raw_input("Personagem 1 >>> ")
c2 = raw_input("Personagem 2 >>> ")
c1 = c1.lower().capitalize()
c2 = c2.lower().capitalize()
if choice == 1:
dist = graph.distance_between(g, c1, c2)
print("A distância entre [{0}] e [{1}] é {2}".format(c1, c2, dist))
elif choice == 2:
path = graph.find_path(g, c1, c2)
if path != []:
print(" - ".join(path))
else:
print("O caminho entre [{0}] e [{1}] não existe!".format(c1, c2))
print("\n\nNovamente? (s/n)")
ans = raw_input(">>> ")
utils.clear()
print("Bye bye!")
