def test_is_full(self): # DONE
"""Creating full queue"""
my_q = Queue(5)
my_q.enqueue(100)
my_q.enqueue(-100)
my_q.enqueue(-95)
my_q.enqueue(100.5)
my_q.enqueue(0)
self.assertTrue(my_q.is_full())
"""Testing empty queue"""
my_q2 = Queue(5)
self.assertFalse(my_q2.is_full())
def test_is_empty(self):
array = Queue(5)
self.assertTrue(array.is_empty())
array.enqueue(1)
self.assertFalse(array.is_empty())
def queue_test(a):
"""
-------------------------------------------------------
Tests queue implementation.
Use: queue_test(a)
-------------------------------------------------------
Preconditions:
a - list of data (list of ?)
Postconditions:
the methods of Queue are tested for both empty and
non-empty queues using the data in a:
empty, insert, remove, peek
-------------------------------------------------------
"""
q = Queue()
# tests for the queue methods go here
# print the results of the method calls and verify by hand
print("Empty queue: {}".format(q.is_empty()))
for i in a:
q.insert(i)
print("Items inserted into queue:")
for j in q:
print("{}".format(j))
print()
print("Remove: {}".format(q.remove()))
print()
if not q.is_empty():
print("Peek: {}".format(q.peek()))
else:
print("Queue is empty.")
return
def levelorder(self):
"""
-------------------------------------------------------
Copies the contents of the tree in levelorder order to a 2D list.
Use: values = bst.levelorder()
-------------------------------------------------------
Postconditions:
returns
values - a list containing the values of bst in levelorder.
(list of ?)
-------------------------------------------------------
"""
a = []
q = Queue()
node = self._root
if node is not None:
q.insert(node)
while not q.is_empty():
temp = q.remove()
a.append(temp._value)
if temp._left is not None:
q.insert(temp._left)
if temp._right is not None:
q.insert(temp._right)
return a
def test_dq_ret(self):
q = Queue(3)
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
self.assertEqual(q.dequeue(), 1)
self.assertEqual(q.dequeue(), 2)
def test_queue(self):
'''Trivial test to ensure method names and parameters are correct'''
q = Queue(5)
self.assertTrue(q.is_empty())
self.assertFalse(q.is_full())
q.enqueue(3)
q.enqueue(5)
self.assertEqual(q.size(), 2)
q.enqueue(8)
q.enqueue(9)
q.enqueue(7)
with self.assertRaises(IndexError):
q.enqueue(8)
self.assertFalse(q.is_empty())
self.assertTrue(q.is_full())
q.dequeue()
self.assertEqual(q.dequeue(), 5)
self.assertEqual(q.size(), 3)
q.dequeue()
q.dequeue()
self.assertEqual(q.dequeue(), 7)
self.assertEqual(q.size(), 0)
with self.assertRaises(IndexError):
q.dequeue()
q.enqueue(3)
q.enqueue(5)
q.enqueue(7)
q.enqueue(4)
q.enqueue(8)
self.assertEqual(q.dequeue(), 3)
q.enqueue(2)
q.dequeue()
self.assertEqual(q.dequeue(), 7)
def test_queue(self):
q = Queue(5)
self.assertEqual(q.is_empty(), True)
self.assertEqual(q.is_full(), False)
q.enqueue('thing')
self.assertEqual(q.dequeue(), 'thing')
self.assertEqual(q.size(), 0)
def queue_test(a):
"""
-------------------------------------------------------
Tests queue implementation.
Use: queue_test(a)
-------------------------------------------------------
Preconditions:
a - list of data (list of ?)
Postconditions:
the methods of Queue are tested for both empty and
non-empty queues using the data in a:
empty, insert, remove, peek
-------------------------------------------------------
"""
q = Queue()
# tests for the queue methods go here
print("***Is_empty test 1: {}".format(q.is_empty()))
print("***Array_to_queue ->")
array_to_queue(q, a)
print("***Is_empty test 2: {}".format(q.is_empty()))
print("***Tests remove(): {}".format(q.remove()))
print("***Peek test: {}".format(q.peek()))
print("***Insert '21' to the back of the queue: ")
q.insert(21)
for v in q:
print(v)
# print the results of the method calls and verify by hand
return
def test_none1(self):
"""Testing None"""
q = Queue(5)
q.enqueue(None)
q.enqueue(1)
self.assertFalse(q.is_empty())
self.assertFalse(q.is_full())
self.assertEqual(q.size(), 2)
def test_queue(self):
'''Trivial test to ensure method names and parameters are correct'''
q = Queue(5)
q.is_empty()
q.is_full()
q.enqueue('thing')
q.dequeue()
q.size()
def test_is_empty(self): # DONE
"""Created and testing empty queue"""
my_q = Queue(5)
self.assertTrue(my_q.is_empty())
self.assertEqual(my_q.__repr__(), "Queue(5, [])")
"""Testing non-empty queue"""
my_q.enqueue(3)
self.assertFalse(my_q.is_empty())
def test_queue(self):
'''Trivial test to ensure method names and parameters are correct'''
q = Queue(5)
self.assertTrue(q.is_empty())
self.assertFalse(q.is_full())
q.enqueue('thing')
self.assertEqual(q.dequeue(), 'thing')
self.assertEqual(q.size(), 0)
def test_queue04(self):
q = Queue(3)
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
self.assertEqual(q.dequeue(), 1)
q.enqueue(4)
with self.assertRaises(IndexError):
q.enqueue(5)
def test_queue01(self):
q = Queue(10)
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
self.assertFalse(q.is_empty())
self.assertFalse(q.is_full())
self.assertEqual(q.size(), 3)
self.assertEqual(q.dequeue(), 1)
def test_queue(self):
'''Trivial test to ensure method names and parameters are correct'''
q = Queue(5)
self.assertTrue(q.is_empty())
self.assertFalse(q.is_full())
q.enqueue('thing')
self.assertEqual(q.dequeue(), 'thing')
self.assertEqual(q.size(), 0)
for i in range(5):
q.enqueue(i)
self.assertTrue(q.is_full())
self.assertFalse(q.is_empty())
with self.assertRaises(IndexError):
q.enqueue(1)
self.assertEqual(q.size(), 5)
with self.assertRaises(IndexError):
e = Queue(1)
e.dequeue()
def test_queue2(self):
q = Queue(3)
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
q.dequeue()
q.dequeue()
q.dequeue()
q.enqueue(4)
self.assertFalse(q.is_full())
def test_is_full(self):
array = Queue(4)
array.enqueue(1)
self.assertFalse(array.is_full())
array.enqueue(2)
array.enqueue(3)
array.enqueue(4)
self.assertTrue(array.is_full())
def test_repr(self):
"""Creating empty queue"""
my_q = Queue(4)
"""enqueueing node"""
my_q.enqueue('Luis')
my_q.enqueue('Gomez')
my_q.enqueue('is')
my_q.enqueue('chill')
self.assertEqual(my_q.__repr__(),
"Queue(4, ['Luis', 'Gomez', 'is', 'chill'])")
def test_queue02(self):
q = Queue(5)
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
q.enqueue(4)
q.enqueue(5)
self.assertTrue(q.is_full())
self.assertFalse(q.is_empty())
self.assertEqual(q.size(), 5)
def test_queue(self):
'''Trivial test to ensure method names and parameters are correct'''
q = Queue(5)
q.is_empty()
q.is_full()
q.enqueue('thing')
self.assertEqual(q.peek(), 'thing')
q.dequeue()
with self.assertRaises(IndexError):
q.peek()
q.size()
def test_queue06(self):
q = Queue(5)
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
q.enqueue(4)
q.enqueue(5)
q.dequeue()
q.enqueue(6)
self.assertTrue(q.is_full())
self.assertEqual(q.size(), 5)
def test_enqueue(self):
"""Creating empty queue"""
my_q = Queue(4)
"""enqueueing node"""
my_q.enqueue('Luis')
my_q.enqueue('Gomez')
my_q.enqueue('is')
my_q.enqueue('chill')
"""queue is full, enqueue returns index error"""
with self.assertRaises(IndexError):
my_q.enqueue(4)
def test_queue2(self):
q = Queue(3)
q.enqueue('1')
q.enqueue('2')
q.enqueue('3')
self.assertEqual(q.is_full(), True)
q.dequeue()
q.dequeue()
q.enqueue('4')
q.enqueue('5')
self.assertEqual(q.dequeue(), '3')
self.assertEqual(q.dequeue(), '4')
def test_two(self):
r = Queue(5)
r.enqueue(1)
r.enqueue(2)
r.enqueue(3)
self.assertEqual(r.num_items, 3)
self.assertEqual(r.dequeue(), 1)
self.assertEqual(r.dequeue(), 2)
self.assertEqual(r.num_items, 1)
with self.assertRaises(IndexError):
while True:
r.enqueue(1)
self.assertEqual(r.num_items, r.capacity)
def level_order_list(self): # (breadth first search)
# return Python list of BST keys representing level-order traversal of BST
# You MUST use your queue_array data structure from lab 3 to implement this method
if self.is_empty():
raise IndexError("levelorder not possible, empty tree")
key_list = []
q = Queue(25000) # Don't change this!
HEIGHT = self.tree_height_helper(self.root)
for desired_level in range(HEIGHT + 1):
q = self.level_order_list_helper(q, self.root, HEIGHT,
desired_level)
while q.size() != 0:
key_list.append(q.dequeue())
return key_list
def level_order_list(
self
): # return Python list of BST keys representing level-order traversal of BST
# You MUST use your queue_array data structure from lab 3 to implement this method
q = Queue(25000) # Don't change this!
lst = []
q.enqueue(self.root)
while not q.is_empty():
temp = q.dequeue()
if temp is not None:
lst.append(temp.key)
q.enqueue(temp.left)
q.enqueue(temp.right)
return lst
def level_order_list(
self
): # return Python list of BST keys representing level-order traversal of BST
# You MUST use your queue_array data structure from lab 3 to implement this method
q = Queue(25000) # Don't change this!
q.enqueue(self.root)
l = []
while not q.is_empty():
node = q.dequeue()
l.append(node.key)
if node.left != None:
q.enqueue(node.left)
if node.right != None:
q.enqueue(node.right)
return l
def test_queue1(self):
q = Queue(3)
with self.assertRaises(IndexError): # uses context manager to check exception
q.dequeue()
q.enqueue('emily')
q.enqueue('helene')
self.assertEqual(q.size(), 2)
q.dequeue()
self.assertEqual(q.size(), 1)
q.enqueue('serina')
q.enqueue('dennis')
self.assertEqual(q.is_empty(), False)
self.assertEqual(q.is_full(), True)
with self.assertRaises(IndexError): # uses context manager to check exception
q.enqueue('hello')
self.assertEqual(q.dequeue(), 'helene')
def level_order_list(
self
): # return Python list of BST keys representing level-order traversal of BST
# You MUST use your queue_array data structure from lab 3 to implement this method
q = Queue(25000) # Don't change this!
l = []
q.enqueue(self.root)
if self.is_empty():
return l
while q.size() > 0:
x = q.dequeue()
l.append(x.key)
if x.left is not None:
q.enqueue(x.left)
if x.right is not None:
q.enqueue(x.right)
return l
def test_queue07(self):
q = Queue(6)
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
q.enqueue(4)
q.enqueue(5)
q.enqueue(6)
self.assertEqual(q.dequeue(), 1)
self.assertEqual(q.dequeue(), 2)
self.assertEqual(q.dequeue(), 3)
self.assertEqual(q.dequeue(), 4)
self.assertEqual(q.dequeue(), 5)
self.assertEqual(q.dequeue(), 6)
self.assertTrue(q.is_empty())
self.assertFalse(q.is_full())
self.assertEqual(q.size(), 0)