def setUp(self):
self.data = ["d1", "d2"]
self.l1 = Queue()
self.l2 = Queue()
self.l3 = Queue()
self.l2.add(self.data[0])
for datum in self.data:
self.l3.add(datum)
def test_enqueue(self):
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(13)
queue.enqueue(31)
self.assertEqual(queue.items.walk(), [1, 2, 13, 31])
def bfs(start):
start.setDistance(0)
start.setPred(None)
# Queue for hold vertexes.
vertQueue = Queue()
vertQueue.enqueue(start)
while vertQueue.size() > 0:
# Get first value from queue.
curVertex = vertQueue.dequeue()
# Go through all the neigbors of the current vertex.
for nbr in curVertex.getConnections():
# Check if the neighbor was not achieved.
if nbr.getColor() == 'white':
# Mark neighbor as achieved.
nbr.setColor('grey')
# Compute distance between current vertex and neighbor.
nbr.setDistance(curVertex.getDistance() + 1)
# Set predecessor as a current vertex for,
# for afterwards recreate the path.
nbr.setPred(curVertex)
# Add neighbor to end of queue.
vertQueue.enqueue(nbr)
# Mark current vertex as passed.
curVertex.setColor('black')
def test_enqueue_five_elements_and_iterate_queue(self):
queue = Queue()
langs = ['python', 'java', 'ruby', 'php', 'go']
for lang in langs:
queue.enqueue(lang)
self.assertEqual(len(langs), queue.size())
for element in queue:
self.assertIn(element, langs)
def bfs(g, start):
start.set_distance(0)
start.set_pred(None)
vert_queue = Queue()
vert_queue.enqueue(start)
while vert_queue.size() > 0:
current_vert = vert_queue.dequeue()
def test_peak(self):
queue = Queue()
queue.enqueue(1)
self.assertEqual(queue.peek(), 1)
queue.enqueue(2)
self.assertEqual(queue.peek(), 1)
queue.enqueue(13)
self.assertEqual(queue.peek(), 1)
queue.dequeue()
self.assertEqual(queue.peek(), 2)
def test_dequeue(self):
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(13)
queue.enqueue(31)
# assert that the item dequeued was the item at the head
self.assertEqual(queue.dequeue(), 1)
# assert that the item at the head of the linked list was removed
self.assertEqual(queue.items.walk(), [2, 13, 31])
def _bfs(self, node_name):
search_queue = Queue()
search_queue.add(self.root)
while len(search_queue) > 0:
n = search_queue.remove()
if n.name == node_name:
return n
for c in n.get_children():
search_queue.add(c)
return None
def test_enqueue_five_elements_to_queue_and_dequeue_two_elements(self):
queue = Queue()
langs = ['python', 'java', 'ruby', 'php', 'go']
for lang in langs:
queue.enqueue(lang)
self.assertEqual(len(langs), queue.size())
element1 = queue.dequeue()
element2 = queue.dequeue()
self.assertEqual('python', element1)
self.assertEqual('java', element2)
self.assertEqual(3, queue.size())
def test_queue(self):
q = Queue(1)
q.enqueue(2)
q.enqueue(3)
assert q.peek() == 1
assert q.dequeue() == 1
q.enqueue(4)
assert q.dequeue() == 2
assert q.dequeue() == 3
assert q.dequeue() == 4
q.enqueue(5)
assert q.peek() == 5
def breadth_first(self):
visited = Queue()
visited.enqueue(self)
while visited:
try:
node = visited.dequeue()
except LookupError:
return
if node.left:
visited.enqueue(node.left)
if node.right:
visited.enqueue(node.right)
yield node
def bfs(self, current):
# Implementation: Iterative 1
if current is None:
return
queue = Queue()
queue.enqueue(current)
while current is not None:
current = current.next_sibling
if queue and current is None:
current = queue.dequeue().first_child
if current and current.first_child:
queue.enqueue(current)
def _get_node(self, element):
queue = Queue()
queue.enqueue(self.root)
while queue:
current = queue.dequeue()
if current.element == element:
return current
children = current.get_children()
if children:
for child in children:
queue.enqueue(child)
return None
def test_enqueue_five_elements_to_queue_and_dequeue_all_elements(self):
queue = Queue()
langs = ['python', 'java', 'ruby', 'php', 'go']
for lang in langs:
queue.enqueue(lang)
self.assertEqual(len(langs), queue.size())
element1 = queue.dequeue()
element2 = queue.dequeue()
element3 = queue.dequeue()
element4 = queue.dequeue()
element5 = queue.dequeue()
self.assertEqual('python', element1)
self.assertEqual('java', element2)
self.assertEqual('ruby', element3)
self.assertEqual('php', element4)
self.assertEqual('go', element5)
self.assertTrue(queue.is_empty())
def test_queue(self):
q = Queue()
q.append(2)
q.append(3)
self.assertEqual(q.size() == 2, True)
val = q.pop()
self.assertEqual(val == 2, True)
self.assertEqual(q.size() == 1, True)
self.assertEqual(q.pop() == 3, True)
self.assertEqual(q.pop() == None, True)
val = [1, 2, 3, 4, 5]
for v in val:
q.append(v)
for v in val:
self.assertEqual(q.pop() == v, True)
def move(self, element, parent):
moving_node = self._get_node(element)
destination_node = self._get_node(parent)
if not moving_node:
raise ElementNotFoundError(
"Could not find element {}".format(element))
if not destination_node:
raise ElementNotFoundError(
"Could not find parent {}".format(parent))
if moving_node == self.root:
raise MovingRootError("Cannot move root node.")
parent_node = None
previous_sibling_node = None
queue = Queue()
queue.enqueue(self.root)
while queue:
current = queue.dequeue()
if current.first_child == moving_node:
parent_node = current
if current.next_sibling == moving_node:
previous_sibling_node = current
if current == moving_node:
break
children = current.get_children()
if children:
for child in children:
queue.enqueue(child)
if parent_node:
parent_node.first_child = moving_node.next_sibling
if previous_sibling_node:
previous_sibling_node.next_sibling = moving_node.next_sibling
next_sibling_node = destination_node.first_child
destination_node.first_child = moving_node
moving_node.next_sibling = next_sibling_node
def bft_print_tree(self):
"""breadth first traversal method to print a tree """
if self is None:
return None
# make a queue, add thehfirst node
current = self
lst = Queue()
lst.enqueue(current.value)
# while queue is not empty
while len(lst) > 0:
# remove the current, and print it
print(lst.dequeue())
# add all children of the current
if current.left:
current = current.left
lst.enqueue(current.value)
if current.right:
current = current.right
lst.enqueue(current.value)
def __init__(self, main_window):
Gtk.Grid.__init__(self)
self.main_window = main_window
self.set_column_homogeneous = True
self.queue = Queue()
self.set_column_spacing(100)
results_box = Gtk.ListBox()
self.results_line = Gtk.ListBox()
results_box.set_border_width(4)
results_box.add(self.results_line)
schedule_button = Gtk.Button('Schedule')
schedule_button.connect('clicked', self.schedule)
results_box.set_hexpand(True)
results_box.add(schedule_button)
self.attach(results_box, 0, 0, 1, 1)
processes_box = Gtk.ListBox()
self.process_lines = Gtk.ListBox()
processes_box.add(self.process_lines)
add_process_button = Gtk.Button('Add Process')
add_process_button.connect('clicked', self.add_process_dialog)
processes_box.set_hexpand(True)
processes_box.set_border_width(5)
processes_box.add(add_process_button)
self.attach(processes_box, 3, 0, 1, 1)
self.gantt_chart_box = Gtk.Box()
self.gantt_chart_box.add(Gtk.Label('GANTT CHART GOES HERE'))
self.attach(self.gantt_chart_box, 0, 1, 3, 1)
def test_no_element_in_queue(self):
queue = Queue()
self.assertTrue(queue.is_empty())
def __init__(self):
self._queue_one = Queue()
self._queue_two = Queue()
def test_empty_list(self):
queue = Queue()
# assert that an empty linked list is created
self.assertEqual(queue.items.head, None)
self.assertEqual(queue.items.tail, None)
self.assertEqual(queue.items.walk(), [])
def test_enqueue_one_element_to_queue(self):
queue = Queue()
queue.enqueue('python')
self.assertEqual(1, queue.size())
def setUp(self):
self.queue = Queue()
