class TestArrayQueue(unittest.TestCase):
def setUp(self):
self.q = ArrayQueue()
self.q.enqueue(1)
self.q.enqueue(2)
self.q.enqueue(3)
def test_instantiation(self):
print('Can create an instance')
self.assertIsInstance(self.q, ArrayQueue)
def test_length_checking(self):
print('Can check the length of the queue')
self.assertEqual(len(self.q), 3)
def test_first_method(self):
print('Can return the first element of the queue')
self.assertEqual(self.q.first(), 1)
def test_enqueue_method(self):
print('Can add elements to the queue')
self.q.enqueue(4)
self.q.enqueue(5)
self.assertEqual(len(self.q), 5)
self.assertEqual(self.q.first(), 1)
def test_dequeue_method(self):
print('Can remove elements from the front of the queue')
self.q.enqueue(4)
self.q.enqueue(5)
self.q.dequeue()
self.assertEqual(self.q.dequeue(), 2)
self.assertEqual(len(self.q), 3)
self.assertEqual(self.q.first(), 3)
def test_is_empty_method(self):
print('Can check if the queue is empty')
self.q.dequeue()
self.q.dequeue()
self.q.dequeue()
self.assertEqual(self.q.is_empty(), True)
def test_exception_raising(self):
print(
'Can raise exception while performing action(s) on an empty queue')
self.q.dequeue()
self.q.dequeue()
self.q.dequeue()
with self.assertRaises(Empty):
self.q.first()
self.q.dequeue()
def breadth_first_print(self):
Q = ArrayQueue()
Q.enqueue(self.root())
while not Q.is_empty():
p = Q.dequeue()
print(p)
for c in self.children(p):
Q.enqueue(c)
def breath_first(self):
from ArrayQueue import ArrayQueue
fringe = ArrayQueue()
fringe.enqueue(self.root())
while not fringe.is_empty():
p = fringe.dequeue()
yield p
for c in p.children():
fringe.enqueue(c)
def breadth_first(self):
if (self.is_empty()):
return
line = ArrayQueue()
line.enqueue(self.root)
while (line.is_empty() == False):
curr_node = line.dequeue()
yield curr_node
if (curr_node.left is not None):
line.enqueue(curr_node.left)
if (curr_node.right is not None):
line.enqueue(curr_node.right)
def invert_binary_tree2(root):
if (root is None):
return
line = ArrayQueue()
line.enqueue(root)
while (line.is_empty() == False):
curr_node = line.dequeue()
curr_node.left, curr_node.right \
= curr_node.right, curr_node.left
if (curr_node.left is not None):
line.enqueue(curr_node.left)
if (curr_node.right is not None):
line.enqueue(curr_node.right)
def __str__(self):
str_return = ''
q_uttt = ArrayQueue()
q_uttt.enqueue(self._root)
last_depth = 0
while not q_uttt.is_empty():
child = q_uttt.dequeue()
if last_depth != child.get_depth():
str_return += "\n"
str_return += child.get_meta().get_meta_int() + ' '
last_depth = child.get_depth()
for grand_child in child.get_children():
q_uttt.enqueue(grand_child)
return str_return
def is_complete(root):
if (root is None):
return True
line = ArrayQueue()
line.enqueue(root)
level = 0
while (line.is_empty() == False):
if (len(line) != 2**level):
return False
for i in range(2**level):
curr_node = line.dequeue()
if (curr_node.left is not None):
line.enqueue(curr_node.left)
if (curr_node.right is not None):
line.enqueue(curr_node.right)
level += 1
return True
def print_tree_level(bin_Tree, level):
output = []
if (bin_Tree.is_empty()):
return
line = ArrayQueue()
line.enqueue((bin_Tree.root, 0))
while (line.is_empty() == False):
curr = line.dequeue()
output.append(curr)
depth = curr[1]
if (curr[0].left is not None):
line.enqueue((curr[0].left, depth + 1))
if (curr[0].right is not None):
line.enqueue((curr[0].right, depth + 1))
i = 0
outputlst = []
for i in output:
if i[1] == level:
outputlst.append(i[0].data)
print(outputlst)
class Tower:
def __init__(self):
self._priority_queue = LinkedQueue()
self._queue = ArrayQueue()
self._current_plane = None
self._total_plane_wait_time = 0
self._planes_served = 0
self._planes_crashed = 0
self._metrics = {
"longest_wait_takeoff": 0,
"longest_wait_landing": 0,
"served_takeoff": 0,
"served_landing": 0
}
def add_to_Q(self, c):
self._queue.add(c)
def add_to_PriorityQ(self, c):
self._priority_queue.add(c)
def set_metrics(self, plane, cur_time):
"""
set class' metrics
:param plane:
:param cur_time:
"""
if plane is not None:
#check takeoff metrics
if plane.status == "Takeoff":
wait_time = cur_time - self._current_plane.arrival_time
self._metrics["longest_wait_takeoff"] += wait_time
if wait_time > self._metrics["longest_wait_takeoff"]:
self._metrics["longest_wait_takeoff"] = wait_time
#check landing metrics
if plane.status == "Landing":
wait_time = cur_time - self._current_plane.arrival_time
self._metrics["longest_wait_landing"] += wait_time
if wait_time > self._metrics["longest_wait_landing"]:
self._metrics["longest_wait_landing"] = wait_time
def check_if_complete(self, plane):
if plane is not None:
#if plane is complete
if plane.transaction_time == 0:
if plane.status == "Takeoff":
self._metrics["served_takeoff"] += 1
else:
self._metrics["served_landing"] += 1
self._current_plane = None
self._planes_served += 1
def serve_plane(self, cur_time):
"""
:param curr_time: int clock_tick
"""
if self._current_plane is None:
# No plane is being helped and queue is empty, do nothing
if self._queue.is_empty() and self._priority_queue.is_empty():
return
else:
# set the planes
try:
if len(self._priority_queue) > 0:
self._current_plane = self._priority_queue.pop()
self._current_plane.minus_fuel()
# crashed plane
if self._current_plane.fuel == 0:
self._current_plane = None
self._planes_crashed += 1
else:
if self._queue.peek() is not None:
self._current_plane = self._queue.pop()
except:
pass
self.set_metrics(self._current_plane, cur_time)
if self._current_plane is not None:
self._current_plane.serve()
self.check_if_complete(self._current_plane)
@property
def queue(self):
return self._queue
@property
def priority_queue(self):
return self._priority_queue
def __str__(self):
return_string = "\naverage time spent waiting for take off: " + str(
self._metrics["longest_wait_takeoff"] /
(round(self._metrics["served_takeoff"] + 1, 3)))
return_string += "\naverage time spent waiting for to land: " + str(
self._metrics["longest_wait_landing"] /
round(self._metrics["served_landing"] + 1, 3))
return_string += "\nlongest time spent waiting for take off: " + str(
self._metrics["longest_wait_takeoff"])
return_string += "\nlongest time spent waiting for to land: " + str(
self._metrics["longest_wait_landing"])
return_string += "\nPlanes Crashed: " + str(self._planes_crashed)
return_string += "\nPlanes served: " + str(self._planes_served)
return_string += f"\nPlanes in queues {len(self._priority_queue) + len(self._queue)}"
return return_string
# What is the average time spent waiting for take off?
# What is the average time spent waiting to land?
# What is the longest time spent waiting for take off?
# What is the longest time spent waiting to land?
# How many planes crashed?
# print(f"{len(tower.priority_queue)} {len(tower.queue)}")
# How many planes total took off and landed during the simulation?
run_lst = []
block_lst = []
job_is_running_time = 0 # to calc cpu utilization
job_is_blocking_time = 0 # to calc i/o utilization
if detailed_mode:
print(
"\nThis detailed printout gives the state and remaining burst for each process.\n"
)
while job_incomplete > 0:
# one time unit is one cycle
if detailed_mode:
cycle_report(time, jobs_lst)
# scan status for change
scan_job(Q, jobs_lst, time)
if not Q.is_empty() and cpu_can_run:
cur_job = Q.dequeue()
cur_job.start_run()
job_running_in_cur_cycle = False
job_is_blocking_in_cur_cycle = False
for j in jobs_lst:
if j.get_state() == 'running':
j.run_controller()
job_running_in_cur_cycle = True
elif j.get_state() == 'blocked':
j.block_controller()
job_is_blocking_in_cur_cycle = True
elif j.get_state() == 'ready':
j.increment_waiting_time()
