Example #1
0
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()
Example #2
0
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())
Example #3
0
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)
Example #4
0
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 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()
Example #7
0
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
Example #8
0
 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
Example #9
0
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]
Example #10
0
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()
Example #12
0
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()
Example #13
0
 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
Example #14
0
 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)
Example #15
0
 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()
Example #17
0
    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
Example #18
0
    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
Example #19
0
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)
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)
Example #22
0
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()
Example #23
0
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())
Example #24
0
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))
Example #26
0
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))
Example #27
0
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")
Example #28
0
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()
Example #29
0
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!")
Example #30
0
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))
Example #31
0
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:
Example #32
0
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__())