class AnimalQueue(object): def __init__(self): self.cat_queue = Queue() self.dog_queue = Queue() self.time = 0 def enqueue(self, animal): if type(animal) is Dog: self.dog_queue.add(animal) elif type(animal) is Cat: self.cat_queue.add(animal) else: raise ValueError("invalid type") animal.order = self.time self.time += 1 def dequeueDog(self): return self.dog_queue.remove() def dequeueCat(self): return self.cat_queue.remove() def dequeueAny(self): if self.dog_queue.isEmpty(): return self.dequeueCat() elif self.cat_queue.isEmpty(): return self.dequeueDog() topDog = self.dog_queue.peek() topCat = self.cat_queue.peek() if topDog.order < topCat.order: return self.dequeueDog() else: return self.dequeueCat()
class TestQueue(unittest.TestCase): def setUp(self): self.our_queue = Queue() def test_is_empty(self): self.assertTrue(self.our_queue.is_empty()) def test_enqueue(self): self.our_queue.enqueue(5) self.assertEqual(5, self.our_queue.peek()) def test_is_not_empty(self): self.our_queue.enqueue(5) self.assertFalse(self.our_queue.is_empty()) def test_dequeue(self): self.our_queue.enqueue(5) self.our_queue.enqueue(8) self.our_queue.enqueue(5) self.assertEqual(5, self.our_queue.peek()) self.assertEqual(5, self.our_queue.dequeue()) self.assertEqual(8, self.our_queue.peek()) def test_get_size(self): self.our_queue.enqueue(5) self.our_queue.enqueue(8) self.our_queue.enqueue(5) self.assertEqual(3, self.our_queue.size_of())
class AnimalQueue(object): def __init__(self): self.dogs = Queue() self.cats = Queue() def adoptDog(self): return self.dogs.pop() def adoptCat(self): return self.cats.pop() def adoptAny(self): if self.dogs.peek().order < self.cats.peek().order: return self.dogs.pop() else: return self.cats.pop() def enQueAnimals(self, a): if (type(a) == Dog): self.dogs.push(a) if (type(a) == Cat): self.cats.push(a)
class AnimalShelter: def __init__(self): self.dogQueue = Queue() self.catQueue = Queue() def enqueue(self, newAnimal): if isinstance(newAnimal, Dog): self.dogQueue.enqueue(newAnimal) elif isinstance(newAnimal, Cat): self.catQueue.enqueue(newAnimal) else: assert(False) def dequeueAny(self): firstDog = self.dogQueue.peek() firstCat = self.catQueue.peek() if firstDog == None: return self.catQueue.dequeue() if firstCat == None: return self.dogQueue.dequeue() if firstDog.order < firstCat.order: return self.dogQueue.dequeue() else: return self.catQueue.dequeue() def dequeueDog(self): return self.dogQueue.dequeue() def dequeueCat(self): return self.catQueue.dequeue()
def test_empty_queue(self): queue = Queue() self.assertEqual(queue.head, None) self.assertEqual(queue.tail, None) self.assertTrue(queue.is_empty()) with self.assertRaises(Queue.Empty): queue.peek() with self.assertRaises(Queue.Empty): queue.dequeue()
def breadth_first(t): breadth_first_list = [] q = Queue() q.enqueue(t) while not q.is_empty(): l = q.peek().get_left() if l != None: q.enqueue(l) r = q.peek().get_right() if r != None: q.enqueue(r) breadth_first_list.append(q.dequeue().get_data()) return breadth_first_list
def findDeepestNode(self): q = Queue() q.createQueue() q.enqueque(self.root) while not q.isEmpty(): if q.peek().left: q.enqueque(q.peek().left) if q.peek().right: q.enqueque(q.peek().right) try: tmp = q.dequeue() except ValueError: continue return tmp
def test_peek(): """Test peek method.""" from Queue import Queue q = Queue() q.enqueue(data[0]) q.enqueue(data[1]) assert q.peek() == data[1]
def test_peeking_the_queue(): q = Queue() q.add("hello") q.add("blob") assert q.peek().value == "hello"
def _test_queue(self): queue = Queue() assert queue.is_empty() for item in self._test_items: queue.push(item) assert queue.size() == 4, "expected queue to be of size 4" assert ( queue.peek() == "firstItem" ), "expected first item in queue to be firstItem" popped = queue.pop() assert queue.size() == 3 assert queue.peek() == "secondItem" assert popped == "firstItem" while not queue.is_empty(): queue.pop() assert queue.is_empty()
class AnimalShelter(): def __init__(self): self.cats = Queue() self.dogs = Queue() def enqueue(self, animal): if animal.__class__ == Cat: self.cats.add(animal.name) else: self.dogs.add(animal.name) def dequeueAny(self): if not self.dogs.isEmpty(): return self.dequeueDog() else: self.dequeueCat() def dequeueCat(self): if self.cats.isEmpty(): return None else: cat = self.cats.peek() self.cats.remove() return cat def dequeueDog(self): if self.dogs.isEmpty(): return None else: dog = self.dogs.peek() self.dogs.remove() return dog def print_shelter(self): print() print('Our Cats : ') for i in self.cats.my_queue: print(i) print() print('Our Dogs : ') for i in self.dogs.my_queue: print(i) print()
def __levelOrderTraversalFunction__(self, root, f): q = Queue() q.createQueue() q.enqueque(root) while not q.isEmpty(): if q.peek().left: q.enqueque(q.peek().left) if q.peek().right: q.enqueque(q.peek().right) try: tmp = q.dequeue() f(tmp) except ValueError: continue except BreakError: if tmp: return tmp return True return False
def test_queue(self): myQueue = Queue(10) self.assertIsNone(myQueue.dequeue()) self.assertTrue(myQueue.isEmpty()) self.assertFalse(myQueue.isFull()) self.assertIsNone(myQueue.peek()) myQueue.enqueue(1) myQueue.enqueue(2) myQueue.enqueue(3) self.assertEqual(myQueue.dequeue(), 1) self.assertEqual(myQueue.dequeue(), 2) self.assertEqual(myQueue.dequeue(), 3)
def levelorder_print(self, start): # same level if start is None: return q = Queue() q.enqueue(self.root) order = "" while q: order += str(q.peek()) + "-" node = q.dequeue() if node.left: q.enqueue(node.left) if node.right: q.enqueue(node.right) return order
class AnimalShelter: def __init__(self): self.dog_queue = Queue(10) self.cat_queue = Queue(10) def enqueue(self, animal): if isinstance(animal, Dog): self.dog_queue.enqueue(animal) elif isinstance(animal, Cat): self.cat_queue.enqueue(animal) def dequeue_dog(self): if self.dog_queue.is_empty(): raise Exception('No Dogs Left') return self.dog_queue.dequeue() def dequeue_cat(self): if self.cat_queue.is_empty(): raise Exception('No Cats Left') return self.cat_queue.dequeue() def dequeue_any(self): dog = self.dog_queue.peek() cat = self.cat_queue.peek() if not dog and not cat: raise Exception('No Animals Left') elif dog and not cat: return self.dog_queue.dequeue() elif cat and not dog: return self.cat_queue.dequeue() if dog.timestamp < cat.timestamp: return self.dog_queue.dequeue() else: return self.cat_queue.dequeue()
def levelOrderTraversal(self,start): if start is None: return queue = Queue() queue.enqueue(start) traveral = "" while len(queue) > 0: traveral += str(queue.peek()) + "-" node = queue.dequeue() if node.left: queue.enqueue(node.left) if node.right: queue.enqueue(node.right) return traveral
def levelOrderTraverse(self, start): from Queue import Queue if start is None: return myQu = Queue() myQu.enqueue(start) traversal = "" while len(myQu) > 0: traversal += str(myQu.peek()) + "->" deqNode = myQu.dequeue() if deqNode.left: myQu.enqueue(deqNode.left) if deqNode.right: myQu.enqueue(deqNode.right) return traversal
def bfs(root, item): if root is None: return False else: queue = Queue() queue.enqueue(root) while not queue.is_empty(): root = queue.peek() print(root.value) if root.value == item: return True queue.deque() if root.left is not None: queue.enqueue(root.left) if root.right is not None: queue.enqueue(root.right)
class QueueTest(unittest.TestCase): def setUp(self): self.queue = Queue() self.queue.enqueue(1) self.queue.enqueue(2) self.queue.enqueue(3) self.queue.enqueue(4) self.queue.enqueue(5) def test_empty_queue(self): queue = Queue() self.assertEqual(queue.head, None) self.assertEqual(queue.tail, None) self.assertTrue(queue.is_empty()) with self.assertRaises(Queue.Empty): queue.peek() with self.assertRaises(Queue.Empty): queue.dequeue() def test_size(self): self.assertEqual(self.queue.size(), 5) def test_enqueue(self): self.queue.enqueue(6) self.assertEqual(self.queue.size(), 6) self.assertEqual(self.queue.tail.get_data(), 6) def test_dequeue(self): self.assertEqual(self.queue.dequeue(), 1) self.assertEqual(self.queue.dequeue(), 2) def test_peek(self): self.assertEqual(self.queue.peek(), 1) self.assertEqual(self.queue.peek(), 1)
deli_line.enqueue("bacon, egg, and cheese on a roll") deli_line.enqueue("toasted sesame bagel with butter and jelly") deli_line.enqueue("toasted roll with butter") deli_line.enqueue("bacon, egg, and cheese on a plain bagel") deli_line.enqueue("two fried eggs with home fries and ketchup") deli_line.enqueue("egg and cheese on a roll with jalapeos") deli_line.enqueue("plain bagel with plain cream cheese") deli_line.enqueue("blueberry muffin toasted with butter") deli_line.enqueue("bacon, egg, and cheese on a roll") # ------------------------ # # Uncomment the line below: # deli_line.enqueue("western omelet with home fries") # ------------------------ # print("------------\nOur first order will be " + deli_line.peek()) print("------------\nNow serving...\n------------") deli_line.dequeue() deli_line.dequeue() deli_line.dequeue() deli_line.dequeue() deli_line.dequeue() deli_line.dequeue() deli_line.dequeue() deli_line.dequeue() deli_line.dequeue() deli_line.dequeue() # ------------------------ # # Uncomment the line below: # deli_line.dequeue()
from Queue import Queue # Setup q = Queue(1) q.enqueue(2) q.enqueue(3) # Test peek # Should be 1 print(q.peek()) # Test dequeue # Should be 1 print(q.dequeue()) # Test enqueue q.enqueue(4) # Should be 2 print(q.dequeue()) # Should be 3 print(q.dequeue()) # Should be 4 print(q.dequeue()) q.enqueue(5) # Should be 5 print(q.peek())
from Queue import Queue queue = Queue() print(queue.has_space()) queue.enqueue(3) queue.enqueue(2) queue.enqueue(1) queue.enqueue(7) queue.dequeue() print(queue.peek()) print(queue.stringify())
class DSQTester(unittest.TestCase): def setUp(self): self.__deque = get_deque() self.__stack = Stack() self.__queue = Queue() #_________STACK TEST CASES_____________ #_________EMPTY STACK TESTS_____________ def test_empty_stack_len(self): self.assertEqual(0, len(self.__stack)) #tests size of an empty stack def test_empty_stack_str(self): self.assertEqual('[ ]', str(self.__stack)) #tests string representation of an empty stack def test_empty_stack_pop_len(self): self.__stack.pop() self.assertEqual(0, len(self.__stack)) #tests size of an empty stack after trying to pop off a value def test_empty_stack_pop_str(self): self.__stack.pop() self.assertEqual('[ ]', str(self.__stack)) #tests string representation of an empty stack after trying to pop off a value def test_empty_stack_pop_return(self): self.assertEqual(None, self.__stack.pop()) #tests returned value after a pop method is called by an empty stack def test_empty_stack_peek_return(self): self.assertEqual(None, self.__stack.peek()) #tests returned value after a peek function is called by an empty stack #_________________________________________________________________________________________ #_________PUSH TESTS_____________(first value in the list = top of the stack | last value in the list = bottom of the stack) def test_push_stack_str(self): self.__stack.push(1) self.assertEqual('[ 1 ]', str(self.__stack)) #tests if push adds a value into a stack def test_push3_stack_str(self): self.__stack.push(3) self.__stack.push(2) self.__stack.push(1) self.assertEqual('[ 1, 2, 3 ]', str(self.__stack)) #tests if push adds values in the correct order def test_push_stack_len(self): self.__stack.push(1) self.assertEqual(1, len(self.__stack)) #tests size of a stack after a value has been pushed into it def test_push3_stack_len(self): self.__stack.push(3) self.__stack.push(2) self.__stack.push(1) self.assertEqual(3, len(self.__stack)) #tests size of a stack after many values have been pushed into it #_________________________________________________________________________________________ #_________POP TESTS_____________ def test_pop_push_stack_return(self): self.__stack.push(1) self.assertEqual(1, self.__stack.pop()) #tests if returned value after a pop method is the value from a stack with a value pushed into it def test_pop_push3_stack_return(self): self.__stack.push(3) self.__stack.push(2) self.__stack.push(1) self.assertEqual(1, self.__stack.pop()) #tests if returned value after a pop method is the value from the top of a stack with many values pushed into it def test_pop3_push3_stack_return(self): self.__stack.push(3) self.__stack.push(2) self.__stack.push(1) self.__stack.pop() self.__stack.pop() self.assertEqual(3, self.__stack.pop()) #tests if returned value after many pop methods is the value from the bottom of a stack with many values pushed into it def test_pop_push_stack_str(self): self.__stack.push(1) self.__stack.pop() self.assertEqual('[ ]', str(self.__stack)) #tests if pop removes a value from a stack with a value pushed into it def test_pop_push3_stack_str(self): self.__stack.push(3) self.__stack.push(2) self.__stack.push(1) self.__stack.pop() self.assertEqual('[ 2, 3 ]', str(self.__stack)) #tests if pop removes the value from the top of a stack with many values pushed into it def test_pop3_push3_stack_str(self): self.__stack.push(3) self.__stack.push(2) self.__stack.push(1) self.__stack.pop() self.__stack.pop() self.__stack.pop() self.assertEqual('[ ]', str(self.__stack)) #tests if pop removes all the values from a stack with many values pushed into it def test_pop_push_stack_len(self): self.__stack.push(1) self.__stack.pop() self.assertEqual(0, len(self.__stack)) #tests size of a stack after popping a value off a stack with a value pushed into it def test_pop_push3_stack_len(self): self.__stack.push(3) self.__stack.push(2) self.__stack.push(1) self.__stack.pop() self.assertEqual(2, len(self.__stack)) #tests size of a stack after popping a value off a stack with many values pushed into it def test_pop3_push3_stack_len(self): self.__stack.push(3) self.__stack.push(2) self.__stack.push(1) self.__stack.pop() self.__stack.pop() self.__stack.pop() self.assertEqual(0, len(self.__stack)) #tests size of a stack after popping many values off a stack with many values pushed into it #_________________________________________________________________________________________________________ #_________PEEK TESTS_____________ def test_peek_push_stack_return(self): self.__stack.push(1) self.assertEqual(1, self.__stack.peek()) #tests peek function of a stack after a value has been pushed into it def test_peek_push3_stack_return(self): self.__stack.push(3) self.__stack.push(2) self.__stack.push(1) self.assertEqual(1, self.__stack.peek()) #tests if peek returns value from the top of a stack def test_peek_push_stack_str(self): self.__stack.push(1) self.__stack.peek() self.assertEqual('[ 1 ]', str(self.__stack)) #tests that peek function does not change the contents of a stack with a value pushed into it def test_peek_push3_stack_str(self): self.__stack.push(3) self.__stack.push(2) self.__stack.push(1) self.__stack.peek() self.assertEqual('[ 1, 2, 3 ]', str(self.__stack)) #tests that peek function does not change the contents of a stack with many values pushed into it def test_peek_push_stack_len(self): self.__stack.push(1) self.__stack.peek() self.assertEqual(1, len(self.__stack)) #tests that peek function does not change the length of a stack with a value pushed into it def test_peek_push3_stack_len(self): self.__stack.push(3) self.__stack.push(2) self.__stack.push(1) self.__stack.peek() self.assertEqual(3, len(self.__stack)) #tests that peek function does not change the length of a stack with many values pushed into it #________________________________________________________________________________________________ #_________QUEUE TEST CASES_____________(first value in the list = front of the queue | last value in the list = back of the queue) #_________EMPTY QUEUE TESTS_____________ def test_empty_queue_len(self): self.assertEqual(0, len(self.__queue)) #tests size of an empty queue def test_empty_queue_str(self): self.assertEqual('[ ]', str(self.__queue)) #tests string representation of an empty queue def test_empty_queue_dequeue_len(self): self.__queue.dequeue() self.assertEqual(0, len(self.__queue)) #tests size of a queue after dequeuing a value from an empty queue def test_empty_queue_dequeue_str(self): self.__queue.dequeue() self.assertEqual('[ ]', str(self.__queue)) #tests string representation of a queue after trying to dequeue a value in an empty queue def test_empty_queue_dequeue_return(self): self.assertEqual(None, self.__queue.dequeue()) #tests returned value after a dequeue method is called by an empty queue def test_empty_queue_peek_return(self): self.assertEqual(None, self.__queue.peek()) #tests peek function of an empty queue #____________________________________________________________ #_________ENQUEUE TESTS_____________ def test_enqueue_queue_str(self): self.__queue.enqueue(1) self.assertEqual('[ 1 ]', str(self.__queue)) #tests if enqueue adds a value into a queue def test_enqueue3_queue_str(self): self.__queue.enqueue(1) self.__queue.enqueue(2) self.__queue.enqueue(3) self.assertEqual('[ 1, 2, 3 ]', str(self.__queue)) #tests if enqueue adds values in the correct order def test_enqueue_queue_len(self): self.__queue.enqueue(1) self.assertEqual(1, len(self.__queue)) #tests size of a queue after a value has been enqueued into it def test_enqueue3_queue_len(self): self.__queue.enqueue(1) self.__queue.enqueue(1) self.__queue.enqueue(1) self.assertEqual(3, len(self.__queue)) #tests size of a queue after many values have been enqueued into it #_________________________________________________________________________________________ #_________DEQUEUE TESTS_____________ def test_dequeue_enqueue_queue_return(self): self.__queue.enqueue(1) self.assertEqual(1, self.__queue.dequeue()) #tests if returned value after a dequeue method is the value from a queue with a value enqueued into it def test_dequeue_enqueue3_queue_return(self): self.__queue.enqueue(1) self.__queue.enqueue(2) self.__queue.enqueue(3) self.assertEqual(1, self.__queue.dequeue()) #tests if returned value after a dequeue method is the value from the front of a queue with many values enqueued into it def test_dequeue3_enqueue3_queue_return(self): self.__queue.enqueue(1) self.__queue.enqueue(2) self.__queue.enqueue(3) self.__queue.dequeue() self.__queue.dequeue() self.assertEqual(3, self.__queue.dequeue()) #tests if returned value after many dequeue methods is the value from the back of a queue with many values enqueued into it def test_dequeue_enqueue_queue_str(self): self.__queue.enqueue(1) self.__queue.dequeue() self.assertEqual('[ ]', str(self.__queue)) #tests if dequeue removes a value from a queue with a value enqueued into it def test_dequeue_enqueue3_queue_str(self): self.__queue.enqueue(1) self.__queue.enqueue(2) self.__queue.enqueue(3) self.__queue.dequeue() self.assertEqual('[ 2, 3 ]', str(self.__queue)) #tests if dequeue removes the value from the front of a queue with many values enqueued into it def test_dequeue3_enqueue3_queue_str(self): self.__queue.enqueue(1) self.__queue.enqueue(2) self.__queue.enqueue(3) self.__queue.dequeue() self.__queue.dequeue() self.__queue.dequeue() self.assertEqual('[ ]', str(self.__queue)) #tests if dequeue removes all the values from a queue with many values enqueued into it def test_dequeue_enqueue_queue_len(self): self.__queue.enqueue(1) self.__queue.dequeue() self.assertEqual(0, len(self.__queue)) #tests size of a queue after dequeuing a value off a queue with a value enqueued into it def test_dequeue_enqueue3_queue_len(self): self.__queue.enqueue(1) self.__queue.enqueue(2) self.__queue.enqueue(3) self.__queue.dequeue() self.assertEqual(2, len(self.__queue)) #tests size of a queue after dequeuing a value off a queue with many values enqueued into it def test_dequeue3_enqueue3_queue_len(self): self.__queue.enqueue(1) self.__queue.enqueue(2) self.__queue.enqueue(3) self.__queue.dequeue() self.__queue.dequeue() self.__queue.dequeue() self.assertEqual(0, len(self.__queue)) #tests size of a queue after dequeuing all values off a queue with many values enqueued into it #_________________________________________________________________________________________________________ #_________PEEK TESTS_____________ def test_peek_enqueue_queue_return(self): self.__queue.enqueue(1) self.assertEqual(1, self.__queue.peek()) #tests peek function of a queue after a value has been enqueued into a queue it def test_peek_enqueue3_queue_return(self): self.__queue.enqueue(1) self.__queue.enqueue(2) self.__queue.enqueue(3) self.assertEqual(1, self.__queue.peek()) #tests if peek returns value from the front of a queue def test_peek_enqueue_queue_str(self): self.__queue.enqueue(1) self.__queue.peek() self.assertEqual('[ 1 ]', str(self.__queue)) #tests that peek function does not change the contents of a queue with a value enqueued into it def test_peek_enqueue3_queue_str(self): self.__queue.enqueue(1) self.__queue.enqueue(2) self.__queue.enqueue(3) self.__queue.peek() self.assertEqual('[ 1, 2, 3 ]', str(self.__queue)) #tests that peek function does not change the contents of a queue with many values enqueued into it def test_peek_enqueue_queue_len(self): self.__queue.enqueue(1) self.__queue.peek() self.assertEqual(1, len(self.__queue)) #tests that peek function does not change the size of a queue with a value enqueued into it def test_peek_enqueue3_queue_len(self): self.__queue.enqueue(1) self.__queue.enqueue(2) self.__queue.enqueue(3) self.__queue.peek() self.assertEqual(3, len(self.__queue)) #tests that peek function does not change the size of a queue with many values enqueued into it #________________________________________________________________________________________________ #_________DEQUE TEST CASES_____________(first value in the list = front of the deque | last value in the list = back of the deque) #_________EMPTY DEQUE TESTS_____________ def test_empty_deque_len(self): self.assertEqual(0, len(self.__deque)) #tests size of an empty deque def test_empty_deque_str(self): self.assertEqual('[ ]', str(self.__deque)) #tests string representation of an empty deque def test_empty_deque_popfront_len(self): self.__deque.pop_front() self.assertEqual(0, len(self.__deque)) #tests size of an empty deque after trying to pop off a value from the front def test_empty_deque_popback_len(self): self.__deque.pop_back() self.assertEqual(0, len(self.__deque)) #tests size of an empty deque after trying to pop off a value from the back def test_empty_deque_popfront_str(self): self.__deque.pop_front() self.assertEqual('[ ]', str(self.__deque)) #tests string representation of an empty deque after trying to pop off a value from the front def test_empty_deque_popback_str(self): self.__deque.pop_back() self.assertEqual('[ ]', str(self.__deque)) #tests string representation of an empty deque after trying to pop off a value from the back def test_empty_deque_popfront_return(self): self.assertEqual(None, self.__deque.pop_front()) #tests returned value after a pop front method is called by an empty deque def test_empty_deque_popback_return(self): self.assertEqual(None, self.__deque.pop_back()) #tests returned value after a pop back method is called by an empty deque def test_empty_deque_peekfront_return(self): self.assertEqual(None, self.__deque.peek_front()) #tests returned value after a peek front function is called by an empty deque def test_empty_deque_peekback_return(self): self.assertEqual(None, self.__deque.peek_back()) #tests returned value after a peek back function is called by an empty deque #____________________________________________________________ #_________PUSH FRONT TESTS_____________ def test_pushfront_deque_str(self): self.__deque.push_front(1) self.assertEqual('[ 1 ]', str(self.__deque)) #tests if push front adds a value into a deque def test_pushfront3_deque_str(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.assertEqual('[ 1, 2, 3 ]', str(self.__deque)) #tests if push front adds values in the correct order def test_pushfront_deque_len(self): self.__deque.push_front(1) self.assertEqual(1, len(self.__deque)) #tests size of a deque after a value has been pushed to the front of it def test_pushfront3_deque_len(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.assertEqual(3, len(self.__deque)) #tests size of a deque after many value has been pushed to the front of it #_________________________________________________________________________________________ #_________PUSH BACK TESTS_____________ def test_pushback_deque_str(self): self.__deque.push_back(1) self.assertEqual('[ 1 ]', str(self.__deque)) #tests if push back adds a value into a deque def test_pushback3_deque_str(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.assertEqual('[ 1, 2, 3 ]', str(self.__deque)) #tests if push back adds values in the correct order def test_pushback_deque_len(self): self.__deque.push_back(1) self.assertEqual(1, len(self.__deque)) #tests size of a deque after a value has been pushed to the back of it def test_pushback3_deque_len(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.assertEqual(3, len(self.__deque)) #tests size of a deque after many value has been pushed to the back of it #_________________________________________________________________________________________ #_________POP FRONT TESTS_____________ def test_popfront_pushfront_deque_return(self): self.__deque.push_front(1) self.assertEqual(1, self.__deque.pop_front()) #tests if returned value after a pop front method is the value from a deque with a value pushed to the front of it def test_popfront_pushback_deque_return(self): self.__deque.push_back(1) self.assertEqual(1, self.__deque.pop_front()) #tests if returned value after a pop front method is the value from a deque with a value pushed to the back of it def test_popfront_pushfront3_deque_return(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.assertEqual(1, self.__deque.pop_front()) #tests if returned value after a pop front method is the value from the front of a deque with many values pushed to the front of it def test_popfront3_pushfront3_deque_return(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.__deque.pop_front() self.__deque.pop_front() self.assertEqual(3, self.__deque.pop_front()) #tests if returned value after many pop front methods is the value from the back of a deque with many values pushed to the front of it def test_popfront_pushback3_deque_return(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.assertEqual(1, self.__deque.pop_front()) #tests if returned value after a pop front method is the value from the front of a dqeue with many values pushed to the back of it def test_popfront3_pushback3_deque_return(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.__deque.pop_front() self.__deque.pop_front() self.assertEqual(3, self.__deque.pop_front()) #tests if returned value after many pop front methods is the value from the front of a deque with many values pushed to the front of it def test_popfront_pushfront_deque_str(self): self.__deque.push_front(1) self.__deque.pop_front() self.assertEqual('[ ]', str(self.__deque)) #tests if pop front removes a value from a deque with a value pushed to the front of it def test_popfront_pushback_deque_str(self): self.__deque.push_back(1) self.__deque.pop_front() self.assertEqual('[ ]', str(self.__deque)) #tests if pop front removes a value from a deque with a value pushed to the back of it def test_popfront_pushfront3_deque_str(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.__deque.pop_front() self.assertEqual('[ 2, 3 ]', str(self.__deque)) #tests if pop front removes the value from the front of a deque with many values pushed to the front of it def test_popfront3_pushfront3_deque_str(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.__deque.pop_front() self.__deque.pop_front() self.__deque.pop_front() self.assertEqual('[ ]', str(self.__deque)) #tests if many pop front calls removes all the values from a deque with three values pushed to the front of a deque def test_popfront_pushback3_deque_str(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.__deque.pop_front() self.assertEqual('[ 2, 3 ]', str(self.__deque)) #tests if pop front removes the value from the front of a deque with many values pushed to the back of it def test_popfront3_pushfront3_deque_str(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.__deque.pop_front() self.__deque.pop_front() self.__deque.pop_front() self.assertEqual('[ ]', str(self.__deque)) #tests if many pop front calls removes all the values from a deque with three values pushed to the back of a deque def test_popfront_pushfront_deque_len(self): self.__deque.push_front(1) self.__deque.pop_front() self.assertEqual(0, len(self.__deque)) #tests size of a deque after popping a value off of the front after a value has been pushed to the front def test_popfront_pushback_deque_len(self): self.__deque.push_back(1) self.__deque.pop_front() self.assertEqual(0, len(self.__deque)) #tests size of a deque after popping a value off of the front after a value has been pushed to the back def test_popfront_pushfront3_queue_len(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.__deque.pop_front() self.assertEqual(2, len(self.__deque)) #tests size of a deque after popping a value off the front after many values have been pushed to the front def test_popfront3_pushfront3_queue_len(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.__deque.pop_front() self.__deque.pop_front() self.__deque.pop_front() self.assertEqual(0, len(self.__deque)) #tests size of a deque after popping all the values off the front after many values have been pushed to the front def test_popfront_pushback3_queue_len(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.__deque.pop_front() self.assertEqual(2, len(self.__deque)) #tests size of a deque after popping a value off the front after many values have been pushed to the back def test_popfront3_pushback3_queue_len(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.__deque.pop_front() self.__deque.pop_front() self.__deque.pop_front() self.assertEqual(0, len(self.__deque)) #tests size of a deque after popping all the values off the front after many values have been pushed to the back #_________________________________________________________________________________________________________ #_________POP BACK TESTS_____________ def test_popback_pushfront_deque_return(self): self.__deque.push_front(1) self.assertEqual(1, self.__deque.pop_back()) #tests if returned value after a pop back method is the value from a deque with a value pushed to the front of it def test_popback_pushback_deque_return(self): self.__deque.push_back(1) self.assertEqual(1, self.__deque.pop_back()) #tests if returned value after a pop back method is the value from a deque with a value pushed to the back of it def test_popback_pushfront3_deque_return(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.assertEqual(3, self.__deque.pop_back()) #tests if returned value after a pop back method is the value from the back of a deque with many values pushed to the front of it def test_popback3_pushfront3_deque_return(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.__deque.pop_back() self.__deque.pop_back() self.assertEqual(1, self.__deque.pop_back()) #tests if returned value after many pop back methods is the value from the back of a deque with many values pushed to the front of it def test_popback_pushback3_deque_return(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.assertEqual(3, self.__deque.pop_back()) #tests if returned value after a pop back method is the value from the front of a deque with many values pushed to the back of it def test_popback3_pushback3_deque_return(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.__deque.pop_back() self.__deque.pop_back() self.assertEqual(1, self.__deque.pop_back()) #tests if returned value after many pop back method is the value from the front of a deque with many values pushed to the back of it def test_popback_pushfront_deque_str(self): self.__deque.push_front(1) self.__deque.pop_back() self.assertEqual('[ ]', str(self.__deque)) #tests if pop back removes a value from a deque with a value pushed to the front of it def test_popback_pushback_deque_str(self): self.__deque.push_back(1) self.__deque.pop_back() self.assertEqual('[ ]', str(self.__deque)) #tests if pop back removes a value from a deque with a value pushed to the back of it def test_popback_pushfront3_deque_str(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.__deque.pop_back() self.assertEqual('[ 1, 2 ]', str(self.__deque)) #tests if pop back removes the value from the back of a deque with many values pushed to the front of it def test_popback3_pushfront3_deque_str(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.__deque.pop_back() self.__deque.pop_back() self.__deque.pop_back() self.assertEqual('[ ]', str(self.__deque)) #tests if many pop back calls removes all the values from a deque with many values pushed to the front of it def test_popback_pushback3_deque_str(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.__deque.pop_back() self.assertEqual('[ 1, 2 ]', str(self.__deque)) #tests if pop back removes the value from the back of a deque with many values pushed to the back of it def test_popback3_pushback3_deque_str(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.__deque.pop_back() self.__deque.pop_back() self.__deque.pop_back() self.assertEqual('[ ]', str(self.__deque)) #tests if many pop back calls removes all the values from a deque with many values pushed to the back of it def test_popback_pushfront_deque_len(self): self.__deque.push_front(1) self.__deque.pop_back() self.assertEqual(0, len(self.__deque)) #tests size of a deque after popping a value off of the back after a value has been pushed to the front of it def test_popback_pushback_deque_len(self): self.__deque.push_back(1) self.__deque.pop_back() self.assertEqual(0, len(self.__deque)) #tests size of a deque after popping a value off of the back after a value has been pushed to the back of it def test_popback_pushfront3_queue_len(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.__deque.pop_back() self.assertEqual(2, len(self.__deque)) #tests size of a deque after popping a value off the back after many values have been pushed to the front of it def test_popback3_pushfront3_queue_len(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.__deque.pop_back() self.__deque.pop_back() self.__deque.pop_back() self.assertEqual(0, len(self.__deque)) #tests size of a deque after popping all the values off the back after many values have been pushed to the front of it def test_popback_pushback3_queue_len(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.__deque.pop_back() self.assertEqual(2, len(self.__deque)) #tests size of a deque after popping a value off the back after many values have been pushed to the back of it def test_popback3_pushback3_queue_len(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.__deque.pop_back() self.__deque.pop_back() self.__deque.pop_back() self.assertEqual(0, len(self.__deque)) #tests size of a deque after popping a value off the back after many values have been pushed to the back of it #_________________________________________________________________________________________________________ #_________PEEK FRONT TESTS_____________ def test_peekfront_pushfront_deque_return(self): self.__deque.push_front(1) self.assertEqual(1, self.__deque.peek_front()) #tests peek front function of a deque after a value has been pushed to the front of it def test_peekfront_pushback_deque_return(self): self.__deque.push_back(1) self.assertEqual(1, self.__deque.peek_front()) #tests peek front function of a deque after a value has been pushed to the back of it def test_peekfront_pushfront3_deque_return(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.assertEqual(1, self.__deque.peek_front()) #tests if peek front returns value from the front of a deque after many values have been pushed to the front of it def test_peekfront_pushback3_deque_return(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.assertEqual(1, self.__deque.peek_front()) #tests if peek front returns value from the front of a deque after many values have been pushed to the back of it def test_peekfront_pushfront_deque_str(self): self.__deque.push_front(1) self.__deque.peek_front() self.assertEqual('[ 1 ]', str(self.__deque)) #tests that the peek front function does not change the contents of a deque with a value pushed to the front of it def test_peekfront_pushback_deque_str(self): self.__deque.push_back(1) self.__deque.peek_front() self.assertEqual('[ 1 ]', str(self.__deque)) #tests that the peek front function does not change the contents of a deque with a value pushed to the back of it def test_peekfront_pushfront3_deque_str(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.__deque.peek_front() self.assertEqual('[ 1, 2, 3 ]', str(self.__deque)) #tests that the peek front function does not change the contents of a deque with many values pushed to the front of it def test_peekfront_pushback3_deque_str(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.__deque.peek_front() self.assertEqual('[ 1, 2, 3 ]', str(self.__deque)) #tests that the peek front function does not change the contents of a deque with many values pushed to the back of it def test_peekfront_pushfront_deque_len(self): self.__deque.push_front(1) self.__deque.peek_front() self.assertEqual(1, len(self.__deque)) #tests that the peek front function does not change the size of a deque with a value pushed to the front of it def test_peekfront_pushback_deque_len(self): self.__deque.push_back(1) self.__deque.peek_front() self.assertEqual(1, len(self.__deque)) #tests that the peek front function does not change the size of a deque with a value pushed to the back of it def test_peekfront_pushfront3_deque_len(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.__deque.peek_front() self.assertEqual(3, len(self.__deque)) #tests that the peek front function does not change the size of a deque with many values pushed to the front of it def test_peekfront_pushback3_deque_len(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.__deque.peek_front() self.assertEqual(3, len(self.__deque)) #tests that the peek front function does not change the size of a deque with many values pushed to the back of it #________________________________________________________________________________________________ #_________PEEK BACK TESTS_____________ def test_peekback_pushfront_deque_return(self): self.__deque.push_front(1) self.assertEqual(1, self.__deque.peek_back()) #tests peek back function of a deque after a value has been pushed to the front of it def test_peekback_pushback_deque_return(self): self.__deque.push_back(1) self.assertEqual(1, self.__deque.peek_back()) #tests peek back function of a deque after a value has been pushed to the back of it def test_peekback_pushfront3_deque_return(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.assertEqual(3, self.__deque.peek_back()) #tests if peek back returns value from the front of a deque after many values have been pushed to the front of it def test_peekback_pushback3_deque_return(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.assertEqual(3, self.__deque.peek_back()) #tests if peek back returns value from the front of a deque after many values have been pushed to the back of it def test_peekback_pushfront_deque_str(self): self.__deque.push_front(1) self.__deque.peek_back() self.assertEqual('[ 1 ]', str(self.__deque)) #tests that the peek back function does not change the contents of a deque with a value pushed to the front of it def test_peekback_pushback_deque_str(self): self.__deque.push_back(1) self.__deque.peek_back() self.assertEqual('[ 1 ]', str(self.__deque)) #tests that the peek back function does not change the contents of a deque with a value pushed to the back of it def test_peekback_pushfront3_deque_str(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.__deque.peek_back() self.assertEqual('[ 1, 2, 3 ]', str(self.__deque)) #tests that the peek back function does not change the contents of a deque with many values pushed to the front of it def test_peekback_pushback3_deque_str(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.__deque.peek_back() self.assertEqual('[ 1, 2, 3 ]', str(self.__deque)) #tests that the peek back function does not change the contents of a deque with many values pushed to the back of it def test_peekback_pushfront_deque_len(self): self.__deque.push_front(1) self.__deque.peek_back() self.assertEqual(1, len(self.__deque)) #tests that the peek back function does not change the size of a deque with a value pushed to the front of it def test_peekback_pushback_deque_len(self): self.__deque.push_back(1) self.__deque.peek_back() self.assertEqual(1, len(self.__deque)) #tests that the peek back function does not change the size of a deque with a value pushed to the back of it def test_peekback_pushfront3_deque_len(self): self.__deque.push_front(3) self.__deque.push_front(2) self.__deque.push_front(1) self.__deque.peek_front() self.assertEqual(3, len(self.__deque)) #tests that the peek back function does not change the size of a deque with many values pushed to the front of it def test_peekback_pushback3_deque_len(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.__deque.peek_front() self.assertEqual(3, len(self.__deque))
class DSQTester(unittest.TestCase): def setUp(self): self.__deque = get_deque() self.__stack = Stack() self.__queue = Queue() # TODO add your test methods here. Like Linked_List_Test.py, # each test should me in a method whose name begins with test_ def test_empty_list_string(self): self.assertEqual('[ ]', str(self.__deque), "Empty list should print as [ ]") self.assertEqual('[ ]', str(self.__stack), "Empty list should print as [ ]") self.assertEqual('[ ]', str(self.__queue), "Empty list should print as [ ]") def test_add_to_empty_stack(self): self.__stack.push('Test') self.assertEqual('[ Test ]', str(self.__stack)) def test_add_to_empty_queue(self): self.__queue.enqueue('Test') self.assertEqual('[ Test ]', str(self.__queue)) def test_push_front_to_empty_deque(self): self.__deque.push_front('Test') self.assertEqual('[ Test ]', str(self.__deque)) def test_push_back_to_empty_deque(self): self.__deque.push_back('Test') self.assertEqual('[ Test ]', str(self.__deque)) def test_push_to_stack_size_one(self): self.__stack.push('Royale') self.__stack.push('Victory') self.assertEqual('[ Victory, Royale ]', str(self.__stack)) def test_enqueue_size_one(self): self.__queue.enqueue('Victory') self.__queue.enqueue('Royale') self.assertEqual('[ Victory, Royale ]', str(self.__queue)) def test_push_front_deque_size_one(self): self.__deque.push_front('Royale') self.__deque.push_front('Victory') self.assertEqual('[ Victory, Royale ]', str(self.__deque)) def test_push_back_deque_size_one(self): self.__deque.push_front('Victory') self.__deque.push_back('Royale') self.assertEqual('[ Victory, Royale ]', str(self.__deque)) def test_push_to_stack_size_two(self): self.__stack.push('You') self.__stack.push('Love') self.__stack.push('I') self.assertEqual('[ I, Love, You ]', str(self.__stack)) def test_push_to_stack_size_three(self): self.__stack.push('McKinney') self.__stack.push('Alf') self.__stack.push('Hope') self.__stack.push('Katherine') self.assertEqual('[ Katherine, Hope, Alf, McKinney ]', str(self.__stack)) def test_enqueue_size_two(self): self.__queue.enqueue('I') self.__queue.enqueue('Love') self.__queue.enqueue('You') self.assertEqual('[ I, Love, You ]', str(self.__queue)) def test_enqueue_size_three(self): self.__queue.enqueue('Katherine') self.__queue.enqueue('Hope') self.__queue.enqueue('Alf') self.__queue.enqueue('McKinney') self.assertEqual('[ Katherine, Hope, Alf, McKinney ]', str(self.__queue)) def test_push_front_size_two(self): self.__deque.push_front('Love') self.__deque.push_back('You') self.__deque.push_front('I') self.assertEqual('[ I, Love, You ]', str(self.__deque)) def test_push_back_size_two(self): self.__deque.push_front('I') self.__deque.push_back('Love') self.__deque.push_back('You') self.assertEqual('[ I, Love, You ]', str(self.__deque)) def test_push_front_size_three(self): self.__deque.push_front('One') self.__deque.push_front('Two') self.__deque.push_front('Three') self.__deque.push_front('Four') self.assertEqual('[ Four, Three, Two, One ]', str(self.__deque)) def test_push_back_size_three(self): self.__deque.push_front('One') self.__deque.push_front('Two') self.__deque.push_front('Three') self.__deque.push_back('Four') self.assertEqual('[ Three, Two, One, Four ]', str(self.__deque)) def test_push_front_size_four(self): self.__deque.push_front('One') self.__deque.push_front('Two') self.__deque.push_front('Three') self.__deque.push_front('Four') self.__deque.push_front('Five') self.assertEqual('[ Five, Four, Three, Two, One ]', str(self.__deque)) def test_push_back_size_four(self): self.__deque.push_front('One') self.__deque.push_front('Two') self.__deque.push_front('Three') self.__deque.push_front('Four') self.__deque.push_back('Five') self.assertEqual('[ Four, Three, Two, One, Five ]', str(self.__deque)) def test_pop_stack_return(self): self.__stack.push('One') self.__stack.push('Two') self.__stack.push('Three') self.__stack.push('Four') returned = self.__stack.pop() self.assertEqual('Four', returned) def test_pop_stack_remaining_list(self): self.__stack.push('One') self.__stack.push('Two') self.__stack.push('Three') self.__stack.push('Four') returned = self.__stack.pop() self.assertEqual('[ Three, Two, One ]', str(self.__stack)) def test_pop_queue_return(self): self.__queue.enqueue('One') self.__queue.enqueue('Two') self.__queue.enqueue('Three') self.__queue.enqueue('Four') returned = self.__queue.dequeue() self.assertEqual('One', returned) def test_pop_queue_remaining_list(self): self.__queue.enqueue('One') self.__queue.enqueue('Two') self.__queue.enqueue('Three') self.__queue.enqueue('Four') returned = self.__queue.dequeue() self.assertEqual('[ Two, Three, Four ]', str(self.__queue)) def test_deque_pop_back_return(self): self.__deque.push_back('For') self.__deque.push_back('The') self.__deque.push_back('Tali') self.__deque.push_back('Boys') returned = self.__deque.pop_back() self.assertEqual('Boys', returned) def test_deque_pop_back_remaining(self): self.__deque.push_back('For') self.__deque.push_back('The') self.__deque.push_back('Tali') self.__deque.push_back('Boys') returned = self.__deque.pop_back() self.assertEqual('[ For, The, Tali ]', str(self.__deque)) def test_deque_pop_front_return(self): self.__deque.push_back('For') self.__deque.push_back('The') self.__deque.push_back('Tali') self.__deque.push_back('Boys') returned = self.__deque.pop_front() self.assertEqual('For', returned) def test_deque_pop_front_remaining(self): self.__deque.push_back('For') self.__deque.push_back('The') self.__deque.push_back('Tali') self.__deque.push_back('Boys') returned = self.__deque.pop_front() self.assertEqual('[ The, Tali, Boys ]', str(self.__deque)) def test_stack_peek(self): self.__stack.push('One') self.__stack.push('Two') self.__stack.push('Three') self.__stack.push('Four') peek = self.__stack.peek() self.assertEqual('Four', peek) def test_stack_peek_remainder(self): self.__stack.push('One') self.__stack.push('Two') self.__stack.push('Three') self.__stack.push('Four') peek = self.__stack.peek() self.assertEqual('[ Four, Three, Two, One ]', str(self.__stack)) def test_queue_peek(self): self.__queue.enqueue('One') self.__queue.enqueue('Two') self.__queue.enqueue('Three') self.__queue.enqueue('Four') peek = self.__queue.peek() self.assertEqual('One', peek) def test_queue_peek_remainder(self): self.__queue.enqueue('One') self.__queue.enqueue('Two') self.__queue.enqueue('Three') self.__queue.enqueue('Four') peek = self.__queue.peek() self.assertEqual('[ One, Two, Three, Four ]', str(self.__queue)) def test_deque_peek_back_return(self): self.__deque.push_back('For') self.__deque.push_back('The') self.__deque.push_back('Tali') self.__deque.push_back('Boys') returned = self.__deque.peek_back() self.assertEqual('Boys', returned) def test_deque_peek_back_remaining(self): self.__deque.push_back('For') self.__deque.push_back('The') self.__deque.push_back('Tali') self.__deque.push_back('Boys') returned = self.__deque.peek_back() self.assertEqual('[ For, The, Tali, Boys ]', str(self.__deque)) def test_deque_peek_front_return(self): self.__deque.push_back('For') self.__deque.push_back('The') self.__deque.push_back('Tali') self.__deque.push_back('Boys') returned = self.__deque.peek_front() self.assertEqual('For', returned) def test_deque_peek_front_remaining(self): self.__deque.push_back('For') self.__deque.push_back('The') self.__deque.push_back('Tali') self.__deque.push_back('Boys') returned = self.__deque.peek_front() self.assertEqual('[ For, The, Tali, Boys ]', str(self.__deque)) def test_deque_length(self): self.__deque.push_back('For') self.__deque.push_back('The') self.__deque.push_back('Tali') self.__deque.push_back('Boys') self.assertEqual(4, len(self.__deque)) def test_stack_length(self): self.__stack.push('For') self.__stack.push('The') self.__stack.push('Tali') self.__stack.push('Boys') self.assertEqual(4, len(self.__stack)) def test_queue_length(self): self.__queue.enqueue('For') self.__queue.enqueue('The') self.__queue.enqueue('Tali') self.__queue.enqueue('Boys') self.assertEqual(4, len(self.__queue)) def test_deque_length_after_pop_front(self): self.__deque.push_back('For') self.__deque.push_back('The') self.__deque.push_back('Tali') self.__deque.push_back('Boys') self.__deque.pop_front() self.assertEqual(3, len(self.__deque)) def test_deque_length_after_pop_back(self): self.__deque.push_back('For') self.__deque.push_back('The') self.__deque.push_back('Tali') self.__deque.push_back('Boys') self.__deque.pop_back() self.assertEqual(3, len(self.__deque)) def test_stack_length_after_pop(self): self.__stack.push('For') self.__stack.push('The') self.__stack.push('Tali') self.__stack.push('Boys') self.__stack.pop() self.assertEqual(3, len(self.__stack)) def test_queue_length_after_dequeue(self): self.__queue.enqueue('For') self.__queue.enqueue('The') self.__queue.enqueue('Tali') self.__queue.enqueue('Boys') self.__queue.dequeue() self.assertEqual(3, len(self.__queue)) def test_deque_length_after_peek_front(self): self.__deque.push_back('For') self.__deque.push_back('The') self.__deque.push_back('Tali') self.__deque.push_back('Boys') self.__deque.peek_front() self.assertEqual(4, len(self.__deque)) def test_deque_length_after_peek_back(self): self.__deque.push_back('For') self.__deque.push_back('The') self.__deque.push_back('Tali') self.__deque.push_back('Boys') self.__deque.peek_back() self.assertEqual(4, len(self.__deque)) def test_stack_length_after_peek(self): self.__stack.push('For') self.__stack.push('The') self.__stack.push('Tali') self.__stack.push('Boys') self.__stack.peek() self.assertEqual(4, len(self.__stack)) def test_queue_length_after_peek(self): self.__queue.enqueue('For') self.__queue.enqueue('The') self.__queue.enqueue('Tali') self.__queue.enqueue('Boys') self.__queue.peek() self.assertEqual(4, len(self.__queue)) def test_empty_stack_peek_return(self): to_return = self.__stack.peek() self.assertEqual(None, to_return) def test_empty_stack_peek_remainder(self): self.__stack.peek() self.assertEqual('[ ]', str(self.__stack)) def test_empty_queue_peek_remainder(self): self.__queue.peek() self.assertEqual('[ ]', str(self.__queue)) def test_empty_queue_peek_return(self): to_return = self.__queue.peek() self.assertEqual(None, to_return) def test_empty_deque_peek_front_return(self): to_return = self.__deque.peek_front() self.assertEqual(None, to_return) def test_empty_deque_peek_front_remainder(self): self.__deque.peek_front() self.assertEqual('[ ]', str(self.__deque)) def test_empty_deque_peek_back_return(self): to_return = self.__deque.peek_back() self.assertEqual(None, to_return) def test_empty_deque_peek_back_remainder(self): self.__deque.peek_back() self.assertEqual('[ ]', str(self.__deque)) def test_empty_stack_pop_return(self): to_return = self.__stack.pop() self.assertEqual(None, to_return) def test_empty_stack_pop_remainder(self): self.__stack.pop() self.assertEqual('[ ]', str(self.__stack)) def test_empty_queue_dequeue_remainder(self): self.__queue.dequeue() self.assertEqual('[ ]', str(self.__queue)) def test_empty_queue_dequeue_return(self): to_return = self.__queue.dequeue() self.assertEqual(None, to_return) def test_empty_deque_pop_front_return(self): to_return = self.__deque.pop_front() self.assertEqual(None, to_return) def test_empty_deque_pop_front_remainder(self): self.__deque.pop_front() self.assertEqual('[ ]', str(self.__deque)) def test_empty_deque_pop_back_return(self): to_return = self.__deque.pop_back() self.assertEqual(None, to_return) def test_empty_deque_pop_back_remainder(self): self.__deque.pop_back() self.assertEqual('[ ]', str(self.__deque))
class Operation: def __init__(self): self.IBSTree = BSTree(None) self.IQueue = Queue() # Load file to data set def loadFile(self,file): try: fh = open(file,"r") fh.readline() for line in fh: arr = list(line.rstrip().split(',')) # New person person = Person(arr[0],arr[1],arr[2],arr[3]) # Add person to Tree self.IBSTree.insert(person) print("The file is loaded successfully!") except: print("File path is correct!") # Add person to dataset def addNewPerson(self): IDExist = True ID = None while IDExist: ID = input("Please insert the new ID:") # Check ID is existed person = self.IBSTree.findPerson(ID) if person is None: IDExist = False else: print("This ID has been chosen, please choose anothor ID!") name = input("Please insert the Name:") birthplace = input("Please insert the Birthplace:") birthofDate = input("Please insert the Birth of Date:") person = Person(ID,name,birthofDate,birthplace) # Add to Tree self.IBSTree.insert(person) print("New ID:", person.ID) print("Name:", person.Name) print("Birthplace:",person.Birthplace) print("Date of birth:",person.DayofBirth) input("Please tyoe anything to come back to the main memu") # Inorder : Left to Right def InorderTraverse(self): lists = self.IBSTree.Inorder(self.IBSTree) print("ID | Name | Day of Birth | Birthplace") for person in lists: person.printDetail() input("Please tyoe anything to come back to the main memu") # Queue def Bfs(self): print("ID | Name | Day of Birth | Birthplace") if self.IBSTree is None: return self.IQueue.add(self.IBSTree) # Loop Queue and Print while self.IQueue.peek() is not None: current_node = self.IQueue.remove() current_node.person.printDetail() if (current_node.left is not None): self.IQueue.add(current_node.left) if (current_node.right is not None): self.IQueue.add(current_node.right) input("Please tyoe anything to come back to the main memu") # Search Person def SearchbyID(self,ID): print("Search for ID = ",ID) person = self.IBSTree.findPerson(ID) if person is not None: print("ID | Name | Day of Birth | Birthplace") person.printDetail() else: print("The searched ID is not valid") input("Please tyoe anything to come back to the main memu") # Delete by ID def DeleteByID(self,ID): #Search Person personFound = self.IBSTree.findPerson(ID) if personFound is not None: # Delete Person self.IBSTree.delete(self.IBSTree,ID) print("ID | Name | Day of Birth | Birthplace") personFound.printDetail() else: print("The searched ID is not valid") input("Please tyoe anything to come back to the main memu")
my_stack.push("Costa Rica") my_stack.push("Peru") my_stack.push("Ghana") my_stack.push("Indonesia") my_queue = Queue(N) my_queue.enqueue("Australia") my_queue.enqueue("India") my_queue.enqueue("Costa Rica") my_queue.enqueue("Peru") my_queue.enqueue("Ghana") my_queue.enqueue("Indonesia") # Print the first values in the stack and queue print("The top value in my stack is: {0}".format(my_stack.peek())) print("The front value of my queue is: {0}".format(my_queue.peek())) # Get First Value added to Queue first_value_added_to_queue = my_queue.dequeue() # Checkpoint 2 print("\nThe first value enqueued to the queue was {0}".format( first_value_added_to_queue)) queue_runtime = "1" # Checkpoint 3 print("The runtime of getting the front of the queue is O({0})".format( queue_runtime)) # Get First Value added to Stack # Write Code Here for #Checkpoint 4 while not my_stack.is_empty(): first_value_added_to_stack = my_stack.pop()
print("Inserting Values into Queue") q.enqueue(d) q.enqueue(d2) q.enqueue(d3) q.enqueue(d4) q.enqueue(d5) print("Checking if queue is not Empty:") if not q.isEmpty(): # Print false print("Test successful!") else: print("Test unsuccessful") print("Dequeue Test:") q.dequeue() if q.peek() == 2: print("Test successful!") else: print("Test unsuccessful") print("Dequeue Test:") q.dequeue() if q.peek() == 3: print("Test successful!") else: print("Test unsuccessful") print("Dequeue Test:") q.dequeue() if q.peek() == 4: print("Test successful!")
class DSQTester(unittest.TestCase): def setUp(self): self.__deque = get_deque() self.__stack = Stack() self.__queue = Queue() def test_empty_LL_deque_string(self): self.assertEqual('[ ]', str(self.__deque), 'Empty deque should print as "[ ]"') def test_empty_LL_deque_push_front(self): self.__deque.push_front(1) self.assertEqual('[ 1 ]', str(self.__deque)) def test_empty_LL_deque_push_back(self): self.__deque.push_back(1) self.assertEqual('[ 1 ]', str(self.__deque)) def test_empty_LL_deque_pop_front_return(self):#tests if pop method returns correctly, should return None. returned = self.__deque.pop_front() self.assertEqual(None, returned) def test_empty_LL_deque_pop_back_return(self): returned = self.__deque.pop_back() self.assertEqual(None, returned) def test_empty_LL_deque_pop_front(self):#tests if pop method works correctly when the deque is empty. self.__deque.pop_front() self.assertEqual('[ ]', str(self.__deque)) def test_empty_LL_deque_pop_back(self): self.__deque.pop_back() self.assertEqual('[ ]', str(self.__deque)) def test_empty_LL_deque_peek_front(self): returned = self.__deque.peek_front() self.assertEqual(None, returned) def test_empty_LL_deque_peek_back(self): returned = self.__deque.peek_back() self.assertEqual(None, returned) def test_empty_LL_deque_len(self): self.assertEqual(0, len(self.__deque)) def test_one_LL_deque_string(self):#same testing for a deque of size 1. self.__deque.push_front(1) self.assertEqual('[ 1 ]', str(self.__deque)) def test_one_LL_deque_push_front(self): self.__deque.push_front(1) self.__deque.push_front(2) self.assertEqual('[ 2, 1 ]', str(self.__deque)) def test_one_LL_deque_push_back(self): self.__deque.push_back(1) self.__deque.push_back(2) self.assertEqual('[ 1, 2 ]', str(self.__deque)) def test_one_LL_deque_pop_front_return(self):#tests if pop method returns correctly. self.__deque.push_front(1) returned = self.__deque.pop_front() self.assertEqual(1, returned) def test_one_LL_deque_pop_back_return(self): self.__deque.push_front(1) returned = self.__deque.pop_back() self.assertEqual(1, returned) def test_one_LL_deque_pop_front(self):#tests if pop method removes correctly. self.__deque.push_front(1) self.__deque.pop_front() self.assertEqual('[ ]', str(self.__deque)) def test_one_LL_deque_pop_back(self): self.__deque.push_front(1) self.__deque.pop_back() self.assertEqual('[ ]', str(self.__deque)) def test_one_LL_deque_peek_front(self): self.__deque.push_front(1) returned = self.__deque.peek_front() self.assertEqual(1, returned) def test_one_LL_deque_peek_back(self): self.__deque.push_front(1) returned = self.__deque.peek_back() self.assertEqual(1, returned) def test_one_LL_deque_len(self): self.__deque.push_front(1) self.assertEqual(1, len(self.__deque)) def test_two_LL_deque_string(self):#same tests for a deque with size 2. self.__deque.push_front(1) self.__deque.push_front(2) self.assertEqual('[ 2, 1 ]', str(self.__deque)) def test_two_LL_deque_push_front(self): self.__deque.push_front(1) self.__deque.push_front(2) self.__deque.push_front(3) self.assertEqual('[ 3, 2, 1 ]', str(self.__deque)) def test_two_LL_deque_push_back(self): self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.assertEqual('[ 1, 2, 3 ]', str(self.__deque)) def test_two_LL_deque_pop_front_return(self):#tests if pop method returns correctly. self.__deque.push_front(1) self.__deque.push_front(2) returned = self.__deque.pop_front() self.assertEqual(2, returned) def test_two_LL_deque_pop_back_return(self): self.__deque.push_front(1) self.__deque.push_front(2) returned = self.__deque.pop_back() self.assertEqual(1, returned) def test_two_LL_deque_pop_front(self):#tests if pop method removes correctly. self.__deque.push_front(1) self.__deque.push_front(2) self.__deque.pop_front() self.assertEqual('[ 1 ]', str(self.__deque)) def test_two_LL_deque_pop_back(self): self.__deque.push_front(1) self.__deque.push_front(2) self.__deque.pop_back() self.assertEqual('[ 2 ]', str(self.__deque)) def test_two_LL_deque_peek_front(self): self.__deque.push_front(1) self.__deque.push_front(2) returned = self.__deque.peek_front() self.assertEqual(2, returned) def test_two_LL_deque_peek_back(self): self.__deque.push_front(1) self.__deque.push_front(2) returned = self.__deque.peek_back() self.assertEqual(1, returned) def test_two_LL_deque_len(self): self.__deque.push_front(1) self.__deque.push_front(2) self.assertEqual(2, len(self.__deque)) def test_LL_deque_push_pop(self):#test if multiple push and pop work correctly self.__deque.push_front(1) self.__deque.push_front(2) self.__deque.push_back(2) self.__deque.pop_back() self.__deque.push_front(3) self.__deque.pop_front() self.assertEqual('[ 2, 1 ]', str(self.__deque)) def test_empty_ARR_deque_string(self): self.__deque = get_deque(1) self.assertEqual('[ ]', str(self.__deque), 'Empty deque should print as "[ ]"') def test_empty_ARR_deque_push_front(self): self.__deque = get_deque(1) self.__deque.push_front(1) self.assertEqual('[ 1 ]', str(self.__deque)) def test_empty_ARR_deque_push_back(self): self.__deque = get_deque(1) self.__deque.push_back(1) self.assertEqual('[ 1 ]', str(self.__deque)) def test_empty_ARR_deque_pop_front_return(self):#tests if pop method returns correctly, should return None. self.__deque = get_deque(1) returned = self.__deque.pop_front() self.assertEqual(None, returned) def test_empty_ARR_deque_pop_back_return(self): self.__deque = get_deque(1) returned = self.__deque.pop_back() self.assertEqual(None, returned) def test_empty_ARR_deque_pop_front(self):#tests if pop method works correctly when the deque is empty. self.__deque = get_deque(1) self.__deque.pop_front() self.assertEqual('[ ]', str(self.__deque)) def test_empty_ARR_deque_pop_back(self): self.__deque = get_deque(1) self.__deque.pop_back() self.assertEqual('[ ]', str(self.__deque)) def test_empty_ARR_deque_peek_front(self): self.__deque = get_deque(1) returned = self.__deque.peek_front() self.assertEqual(None, returned) def test_empty_ARR_deque_peek_back(self): self.__deque = get_deque(1) returned = self.__deque.peek_back() self.assertEqual(None, returned) def test_empty_ARR_deque_len(self): self.__deque = get_deque(1) self.assertEqual(0, len(self.__deque)) def test_one_ARR_deque_string(self):#same testing for a deque of size 1. self.__deque = get_deque(1) self.__deque.push_front(1) self.assertEqual('[ 1 ]', str(self.__deque)) def test_one_ARR_deque_push_front(self):#also tests if __grow works self.__deque = get_deque(1) self.__deque.push_front(1) self.__deque.push_front(2) self.assertEqual('[ 2, 1 ]', str(self.__deque)) def test_one_ARR_deque_push_back(self):#also tests if __grow works self.__deque = get_deque(1) self.__deque.push_back(1) self.__deque.push_back(2) self.assertEqual('[ 1, 2 ]', str(self.__deque)) def test_one_ARR_deque_pop_front_return(self):#tests if pop method returns correctly. self.__deque = get_deque(1) self.__deque.push_front(1) returned = self.__deque.pop_front() self.assertEqual(1, returned) def test_one_ARR_deque_pop_back_return(self): self.__deque = get_deque(1) self.__deque.push_front(1) returned = self.__deque.pop_back() self.assertEqual(1, returned) def test_one_ARR_deque_pop_front(self):#tests if pop method removes correctly. self.__deque = get_deque(1) self.__deque.push_front(1) self.__deque.pop_front() self.assertEqual('[ ]', str(self.__deque)) def test_one_ARR_deque_pop_back(self): self.__deque = get_deque(1) self.__deque.push_front(1) self.__deque.pop_back() self.assertEqual('[ ]', str(self.__deque)) def test_one_ARR_deque_peek_front(self): self.__deque = get_deque(1) self.__deque.push_front(1) returned = self.__deque.peek_front() self.assertEqual(1, returned) def test_one_ARR_deque_peek_back(self): self.__deque = get_deque(1) self.__deque.push_front(1) returned = self.__deque.peek_back() self.assertEqual(1, returned) def test_one_ARR_deque_len(self): self.__deque = get_deque(1) self.__deque.push_front(1) self.assertEqual(1, len(self.__deque)) def test_two_ARR_deque_string(self):#same tests for a deque with size 2. self.__deque = get_deque(1) self.__deque.push_front(1) self.__deque.push_front(2) self.assertEqual('[ 2, 1 ]', str(self.__deque)) def test_two_ARR_deque_push_front(self): self.__deque = get_deque(1) self.__deque.push_front(1) self.__deque.push_front(2) self.__deque.push_front(3) self.assertEqual('[ 3, 2, 1 ]', str(self.__deque)) def test_two_ARR_deque_push_back(self): self.__deque = get_deque(1) self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.assertEqual('[ 1, 2, 3 ]', str(self.__deque)) def test_two_ARR_deque_pop_front_return(self):#tests if pop method returns correctly. self.__deque = get_deque(1) self.__deque.push_front(1) self.__deque.push_front(2) returned = self.__deque.pop_front() self.assertEqual(2, returned) def test_two_ARR_deque_pop_back_return(self): self.__deque = get_deque(1) self.__deque.push_front(1) self.__deque.push_front(2) returned = self.__deque.pop_back() self.assertEqual(1, returned) def test_two_ARR_deque_pop_front(self):#tests if pop method removes correctly. self.__deque = get_deque(1) self.__deque.push_front(1) self.__deque.push_front(2) self.__deque.pop_front() self.assertEqual('[ 1 ]', str(self.__deque)) def test_two_ARR_deque_pop_back(self): self.__deque = get_deque(1) self.__deque.push_front(1) self.__deque.push_front(2) self.__deque.pop_back() self.assertEqual('[ 2 ]', str(self.__deque)) def test_two_ARR_deque_peek_front(self): self.__deque = get_deque(1) self.__deque.push_front(1) self.__deque.push_front(2) returned = self.__deque.peek_front() self.assertEqual(2, returned) def test_two_ARR_deque_peek_back(self): self.__deque = get_deque(1) self.__deque.push_front(1) self.__deque.push_front(2) returned = self.__deque.peek_back() self.assertEqual(1, returned) def test_two_ARR_deque_len(self): self.__deque = get_deque(1) self.__deque.push_front(1) self.__deque.push_front(2) self.assertEqual(2, len(self.__deque)) def test_ARR_deque_push_pop(self):#test if multiple push and pops work expectedly self.__deque = get_deque(1) self.__deque.push_front(1) self.__deque.push_front(2) self.__deque.push_back(2) self.__deque.pop_back() self.__deque.push_front(3) self.__deque.pop_front() self.assertEqual('[ 2, 1 ]', str(self.__deque)) def test_ARR_deque_push_front_circularity(self):#tests push_front when front index is 0. self.__deque = get_deque(1) self.__deque.push_front(1) self.__deque.push_front(2) self.__deque.push_front(3) self.assertEqual('[ 3, 2, 1 ]', str(self.__deque)) def test_ARR_deque_push_back_circularity(self):#similarly,tests if circular array works self.__deque = get_deque(1) self.__deque.push_back(1) self.__deque.push_back(2) self.__deque.push_back(3) self.assertEqual('[ 1, 2, 3 ]', str(self.__deque)) def test_ARR_deque_pop_front_circularity(self):#tests pop_front when front index is capacity-1. self.__deque = get_deque(1) self.__deque.push_front(1) self.__deque.push_front(2) self.__deque.pop_front() self.assertEqual('[ 1 ]', str(self.__deque)) def test_ARR_deque_pop_back_circularity(self):#tests pop_back when back index is 0. self.__deque = get_deque(1) self.__deque.push_front(1) self.__deque.push_front(2) self.__deque.pop_back() self.assertEqual('[ 2 ]', str(self.__deque)) def test_empty_stack_str(self): self.assertEqual('[ ]', str(self.__stack)) def test_empty_stack_len(self): self.assertEqual(0, len(self.__stack)) def test_empty_stack_push(self): self.__stack.push(1) self.assertEqual('[ 1 ]', str(self.__stack)) def test_empty_stack_pop_return(self):#tests if pop returns value correctly self.assertEqual(None, self.__stack.pop()) def test_empty_stack_pop_remove(self):#tests if pop removes value correctly self.__stack.pop() self.assertEqual('[ ]', str(self.__stack)) def test_empty_stack_peek(self): self.assertEqual(None, self.__stack.peek()) def test_one_stack_str(self): self.__stack.push(1) self.assertEqual('[ 1 ]', str(self.__stack)) def test_one_stack_len(self): self.__stack.push(1) self.assertEqual(1, len(self.__stack)) def test_one_stack_push(self):#notice that the top of stack is the at back of the deque, so the printed string from left to right is from bottom to top. self.__stack.push(1) self.__stack.push(2) self.assertEqual('[ 1, 2 ]', str(self.__stack)) def test_one_stack_pop_return(self):#tests if pop returns value correctly self.__stack.push(1) self.assertEqual(1, self.__stack.pop()) def test_one_stack_pop_remove(self):#tests if pop removes value correctly self.__stack.push(1) self.__stack.pop() self.assertEqual('[ ]', str(self.__stack)) def test_one_stack_peek(self): self.__stack.push(1) self.assertEqual(1, self.__stack.peek()) def test_two_stack_str(self):#notice that the top of stack is the at back of the deque self.__stack.push(1) self.__stack.push(2) self.assertEqual('[ 1, 2 ]', str(self.__stack)) def test_two_stack_len(self): self.__stack.push(1) self.__stack.push(2) self.assertEqual(2, len(self.__stack)) def test_two_stack_push(self):#notice that the top of stack is the at back of the deque self.__stack.push(1) self.__stack.push(2) self.__stack.push(3) self.assertEqual('[ 1, 2, 3 ]', str(self.__stack)) def test_two_stack_pop_return(self):#tests if pop returns value correctly self.__stack.push(1) self.__stack.push(2) self.assertEqual(2, self.__stack.pop()) def test_two_stack_pop_remove(self):#tests if pop removes value correctly self.__stack.push(1) self.__stack.push(2) self.__stack.pop() self.assertEqual('[ 1 ]', str(self.__stack)) def test_two_stack_peek(self): self.__stack.push(1) self.__stack.push(2) self.assertEqual(2, self.__stack.peek()) def test_stack_multiple_push_pop(self):#test if multiple push and pops work as expected self.__stack.push(1) self.__stack.push(2) self.__stack.pop() self.__stack.push(4) self.__stack.pop() self.__stack.push(6) self.__stack.push(7) self.__stack.push(8) self.__stack.pop() self.assertEqual('[ 1, 6, 7 ]', str(self.__stack)) def test_empty_queue_str(self): self.assertEqual('[ ]', str(self.__queue)) def test_empty_queue_len(self): self.assertEqual(0, len(self.__queue)) def test_empty_queue_enqueue(self): self.__queue.enqueue(1) self.assertEqual('[ 1 ]', str(self.__queue)) def test_empty_queue_dequeue_return(self):#tests if dequeue returns value correctly self.assertEqual(None, self.__queue.dequeue()) def test_empty_queue_dequeue_remove(self):#tests if dequeue removes value correctly self.__queue.dequeue() self.assertEqual('[ ]', str(self.__queue)) def test_empty_queue_peek(self): self.assertEqual(None, self.__queue.peek()) def test_one_queue_str(self): self.__queue.enqueue(1) self.assertEqual('[ 1 ]', str(self.__queue)) def test_one_queue_len(self): self.__queue.enqueue(1) self.assertEqual(1, len(self.__queue)) def test_one_queue_enqueue(self):#notice that the right end of string representation is the back of queue. self.__queue.enqueue(1) self.__queue.enqueue(2) self.assertEqual('[ 1, 2 ]', str(self.__queue)) def test_one_queue_dequeue_return(self):#tests if dequeue returns value correctly self.__queue.enqueue(1) self.assertEqual(1, self.__queue.dequeue()) def test_one_queue_dequeue_remove(self):#tests if dequeue removes value correctly self.__queue.enqueue(1) self.__queue.dequeue() self.assertEqual('[ ]', str(self.__queue)) def test_one_queue_peek(self): self.__queue.enqueue(1) self.assertEqual(1, self.__queue.peek()) def test_two_queue_str(self): self.__queue.enqueue(1) self.__queue.enqueue(2) self.assertEqual('[ 1, 2 ]', str(self.__queue)) def test_two_queue_len(self): self.__queue.enqueue(1) self.__queue.enqueue(2) self.assertEqual(2, len(self.__queue)) def test_two_queue_enqueue(self):#notice that the right end of string representation is the back of queue. self.__queue.enqueue(1) self.__queue.enqueue(2) self.__queue.enqueue(3) self.assertEqual('[ 1, 2, 3 ]', str(self.__queue)) def test_two_queue_dequeue_return(self):#tests if dequeue returns value correctly self.__queue.enqueue(1) self.__queue.enqueue(2) self.assertEqual(1, self.__queue.dequeue()) def test_two_queue_dequeue_remove(self):#tests if dequeue removes value correctly self.__queue.enqueue(1) self.__queue.enqueue(2) self.__queue.dequeue() self.assertEqual('[ 2 ]', str(self.__queue)) def test_two_queue_peek(self): self.__queue.enqueue(1) self.__queue.enqueue(2) self.assertEqual(1, self.__queue.peek()) def test_queue_multiple_enqueue_dequeue(self):#test if multiple enqueues and dequeues work as expected self.__queue.enqueue(1) self.__queue.enqueue(2) self.__queue.dequeue() self.__queue.enqueue(4) self.__queue.dequeue() self.__queue.enqueue(6) self.__queue.enqueue(7) self.__queue.enqueue(8) self.__queue.dequeue() self.assertEqual('[ 6, 7, 8 ]', str(self.__queue))
Created on Sun Dec 13 16:46:28 2020 @author: Anjali Venugopal @secondary-author: Abhiram Shibu """ from Queue import Queue testpass=True myQueue = Queue(10) if(myQueue.dequeue()!=None): testpass=False if(myQueue.isEmpty()!=True): testpass=False if(myQueue.isFull()!=False): testpass=False if(myQueue.peek()!=None): testpass=False myQueue.enqueue(1) myQueue.enqueue(2) myQueue.enqueue(3) if(myQueue.dequeue()!=1): testpass=False if(myQueue.dequeue()!=2): testpass=False if(myQueue.dequeue()!=3): testpass=False if(myQueue.dequeue()!=None): testpass=False if(testPass==True): print("Test Passed!") else:
from Queue import Queue arr = Queue() # for x in range(1, 10, 2): # data.enqueue(x) # # print(data) # print(len(data)) # print(data[0]) arr.enqueue(1) arr.enqueue(2) arr.enqueue(3) print(arr.isEmpty()) print(arr.peek()) arr.dequeue() print(arr.peek()) arr.dequeue() print(arr.peek()) for x in range(1, 100, 3): arr.enqueue(x) print(arr.__len__()) print(arr.__str__())