def test_stack_is_empty(self):
stk = Stack()
random_values = get_random_values()
self.assertEqual(stk.is_empty(), True)
for v in random_values:
stk.push(v)
self.assertEqual(stk.is_empty(), False)
for v in random_values[::-1]:
self.assertEqual(stk.is_empty(), False)
stk.pop()
self.assertEqual(stk.is_empty(), True)
def brackets_match(string):
"""Check if all brackets in the string are correctly matched.
Return True if they are, otherwise False.
Only consider round and square brackets, i.e. () and []. For example:
>>> brackets_match("No brackets is fine")
True
>>> brackets_match("After ( and [ comes ] and )")
True
>>> brackets_match("After ( and [ it cannot be ) and ]")
False
>>> brackets_match("A ( without closing bracket")
False
>>> brackets_match("A ] without opening bracket")
False
>>> brackets_match("Snarks are rarely seen (according to Smith (1999)).")
True
"""
expected = Stack()
for character in string:
if character == "(":
expected.push(")")
elif character == "[":
expected.push("]")
elif character == ")" or character == "]":
if expected and character == expected.top():
expected.pop()
else:
return False
return expected.is_empty()
def test_stack_push(self):
stk = Stack()
random_values = get_random_values()
for v in random_values:
stk.push(v)
self.assertEqual(stk.is_empty(), False)
self.assertEqual(stk.peek(), v)
self.assertEqual(stk.pop(), v)
def test_stack_init(self):
stk = Stack()
self.assertEqual(stk.size(), 0)
self.assertEqual(stk.is_empty(), True)
with self.assertRaises(IndexError):
stk.pop()
with self.assertRaises(IndexError):
stk.peek()
class TestStack(unittest.TestCase):
def setUp(self):
# Create stacks for the tests to use
self.new = Stack()
self.empty = Stack()
self.empty.push('hi')
self.empty.pop()
# Don't add in ascending or descending order
self.non_empty = Stack()
self.non_empty.push(5)
self.non_empty.push(2)
self.non_empty.push(7)
self.non_empty.push(2)
def test_length(self):
self.assertEqual(len(self.new), 0)
self.assertEqual(len(self.empty), 0)
self.assertEqual(len(self.non_empty), 4)
def test_is_empty(self):
self.assertTrue(self.new.is_empty())
self.assertTrue(self.empty.is_empty())
self.assertFalse(self.non_empty.is_empty())
def test_lifo_order(self):
self.assertEqual(self.non_empty.pop(), 2)
self.assertEqual(self.non_empty.pop(), 7)
self.assertEqual(self.non_empty.pop(), 2)
self.assertEqual(self.non_empty.pop(), 5)
def test_access_to_empty(self):
with self.assertRaises(AssertionError):
self.new.top()
with self.assertRaises(AssertionError):
self.empty.top()
with self.assertRaises(AssertionError):
self.new.pop()
with self.assertRaises(AssertionError):
self.empty.pop()
def test_membership(self):
self.assertFalse(2 in self.new)
self.assertFalse(2 in self.empty)
self.assertTrue(2 in self.non_empty)
self.assertTrue(5 in self.non_empty)
self.assertTrue(7 in self.non_empty)
def sort_stack(stack):
sorted_stack = stack
stack = Stack()
while not sorted_stack.is_empty():
stack.push(sorted_stack.pop())
while not stack.is_empty():
tmp = stack.pop()
while not sorted_stack.is_empty() and sorted_stack.peek() < tmp:
stack.push(sorted_stack.pop())
sorted_stack.push(tmp)
def test_stack_pop(self):
stk = Stack()
random_values = get_random_values()
for v in random_values:
stk.push(v)
for v in random_values[::-1]:
stk.pop()
self.assertEqual(stk.is_empty(), True)
with self.assertRaises(IndexError):
stk.pop()
with self.assertRaises(IndexError):
stk.peek()
def traversal_graph_dfs(self, ip_address):
if not self.graph_db:
msg = "Traversal graph by dfs requires initialization of a graph database!"
throw_error(msg, TraversalGraphException)
self.graph = {}
self.graph_db.start_db()
try:
next_vertex_id = self.get_next_vertex_id()
default_ports = set_api_default_port()
root_id = self.get_vertex_id_with_ip(ip_address)
if not root_id:
if root_id != 0:
root_id = next_vertex_id
next_vertex_id += 1
root_basic_info = [ip_address, root_id, default_ports[0]]
self.add_vertex_to_table_nodes_id(root_basic_info)
root_name = ''
root_nonce = ''
root = Node(root_id, ip_address, default_ports, root_name,
root_nonce)
self.root_update = False
self.graph.update({ip_address: root})
node_stack = Stack()
node_stack.push(ip_address)
start_time = timeit.default_timer()
while not node_stack.is_empty():
_vertex_ip = node_stack.pop()
_vertex = self.graph[_vertex_ip]
if not _vertex.visited:
_vertex.visited = True
if _vertex.status:
node_start_time = timeit.default_timer()
url = _vertex.link
peers = get_peer_nodes(url)
if peers:
if peers[0][
'applicationName'] != self.application_name:
_vertex.status = False
_vertex.link = 'wrong application'
continue
peers_id = []
for item in peers:
[_peer_ip, port, peer_name,
peer_nonce] = parse_ip_port_name_nonce(item)
_peer_id = self.get_vertex_id_with_ip(_peer_ip)
if not _peer_id:
if _peer_id != 0:
_peer_id = next_vertex_id
new_node = Node(_peer_id, _peer_ip,
default_ports + [port],
peer_name, peer_nonce)
new_node_basic_info = [
_peer_ip, _peer_id, new_node.port
]
self.add_vertex_to_table_nodes_id(
new_node_basic_info)
next_vertex_id += 1
if _peer_ip not in self.graph:
self.graph.update({_peer_ip: new_node})
else:
if _peer_ip not in self.graph:
new_node = Node(
_peer_id, _peer_ip,
default_ports + [port], peer_name,
peer_nonce)
self.graph.update({_peer_ip: new_node})
else:
if _peer_ip not in self.graph:
new_node = Node(_peer_id, _peer_ip,
default_ports + [port],
peer_name, peer_nonce)
self.graph.update({_peer_ip: new_node})
_peer = self.graph[_peer_ip]
if _peer_ip != _vertex_ip:
peers_id.append(_peer_id)
self.update_root_name_nonce(
root, _peer_id, peer_name, peer_nonce)
if not _peer.visited:
node_stack.push(_peer_ip)
_vertex.peers = list(dict.fromkeys(peers_id))
node_stop_time = timeit.default_timer()
_vertex.time_get_basic_info = node_stop_time - node_start_time
stop_time = timeit.default_timer()
self.time_traversal_graph = stop_time - start_time
except TraversalGraphException:
msg = "Traversal graph by dfs has error!"
throw_error(msg, TraversalGraphException)
# finally:
# self.graph_db.close_db()
print("time of traversing the current graph: ",
self.time_traversal_graph)
print("total number of vertex in the current graph: ", len(self.graph))
