예제 #1
0
파일: CalculatorTest.py 프로젝트: fx46/3430
    def test_b_UnionQueue(self):
        queue1 = Queue(3)
        queue2 = Queue(3)

        numbers = [1, 2, 3, 4, 5, 6]
        numbersqueue1 = [1, 2, 3]
        numbersqueue2 = [4, 5, 6]

        for i in numbersqueue1:
            queue1.enqueue(i)

        for i in numbersqueue2:
            queue2.enqueue(i)

        unitedStack = Calculator.union(queue1, queue2)

        numbersContained = 0
        for i in numbers:
            number = unitedStack.dequeue().value
            if number in numbers:
                numbersContained += 1
                numbers.remove(number)

        self.assertEqual(numbersContained, len(numbers))
        self.assertEqual(unitedStack.max_size,
                         queue1.max_size + queue2.max_size)
예제 #2
0
파일: CalculatorTest.py 프로젝트: fx46/3430
    def test_c_UnionStack(self):
        stack1 = Stack(3)
        stack2 = Stack(3)

        numbers = [1, 2, 3, 4, 5, 6]
        numbersstack1 = [1, 2, 3]
        numbersstack2 = [4, 5, 6]

        for i in numbersstack1:
            stack1.push(i)

        for i in numbersstack2:
            stack2.push(i)

        unitedStack = Calculator.union(stack1, stack2)

        numbersContained = 0
        for i in numbers:
            number = unitedStack.pop().value
            if number in numbers:
                numbersContained += 1
                numbers.remove(number)

        self.assertEqual(numbersContained, len(numbers))
        self.assertEqual(unitedStack.max_size,
                         stack1.max_size + stack2.max_size)
예제 #3
0
    def testUnionTwoQueues(self):

        for i in range(5):
            for j in range(5):

                queue1 = Queue(20)

                for k in range(10):
                    queue1.enqueue(k+i*100)

                queue2 = Queue(20)

                for k in range(10):
                    queue2.enqueue(k+j*1000)

                resultat = Calculator.union(queue1, queue2)

                self.assertIsInstance(resultat, Queue)

                self.assertEqual(resultat.max_size, queue1.max_size + queue2.max_size)
                self.assertEqual(resultat.size(), queue1.size() + queue2.size())

                for k in range(10):
                    self.assertEqual(resultat.dequeue(), k+i*100)

                for k in range(10):
                    self.assertEqual(resultat.dequeue(), k+j*1000)
예제 #4
0
    def testUnionTwoStacks(self):

        for i in range(5):
            for j in range(5):

                stack1 = Stack(20)

                for k in range(10):
                    stack1.push(k+i*100)

                stack2 = Stack(20)

                for k in range(10):
                    stack2.push(k+j*1000)

                resultat = Calculator.union(stack1, stack2)

                self.assertIsInstance(resultat, Stack)

                self.assertEqual(resultat.max_size, stack1.max_size + stack2.max_size)
                self.assertEqual(resultat.size(), stack1.size() + stack2.size())

                for k in range(9, -1, -1):
                    self.assertEqual(resultat.pop(), k+j*1000)

                for k in range(9, -1, -1):
                    self.assertEqual(resultat.pop(), k+i*100)
예제 #5
0
    def testUnionTwoLinkedLists(self):

        listes = []

        for n in range(5):
            liste = LinkedList()

            for i in range(10):
                liste.append(i + n*100)

            listes.append(liste)

        for i in range(len(listes)):
            for j in range(i):
                resultat = Calculator.union(listes[i], listes[j])

                self.assertIsInstance(resultat, LinkedList)
                self.assertNotIsInstance(resultat, Stack)
                self.assertNotIsInstance(resultat, Queue)

                self.assertEqual(resultat.size(), listes[i].size() + listes[j].size())

                for k in range(len(listes)):
                    if k==i:
                        for elem in listes[k].list:
                            self.assertTrue(contient(resultat, elem))
                            
                    elif k==j:
                        for elem in listes[k].list:
                            self.assertTrue(contient(resultat, elem))
                    else:
                        for elem in listes[k].list:
                            self.assertFalse(contient(resultat, elem))
예제 #6
0
    def testUnionStackAndQueue(self):
        stacks = []

        for n in range(5):
            stack = Stack(20)

            for i in range(10):
                stack.push(i+n*100)

            stacks.append(stack)

        queues = []

        for n in range(5):
            queue = Queue(20)

            for i in range(10):
                queue.enqueue(i+n*1000)

            queues.append(queue)

        for stack in stacks:
            for queue in queues:
                resultat = Calculator.union(stack, queue)

                self.assertIsInstance(resultat, LinkedList)
                self.assertNotIsInstance(resultat, Stack)
                self.assertNotIsInstance(resultat, Queue)

                self.assertEqual(resultat.size(), stack.size() + queue.size())


                noeud = stack.first

                while noeud.next:
                    self.assertTrue(contient(resultat, noeud.value))
                    noeud = noeud.next


                noeud = queue.first

                while noeud.next:
                    self.assertTrue(contient(resultat, noeud.value))
                    noeud = noeud.next
예제 #7
0
파일: CalculatorTest.py 프로젝트: fx46/3430
    def test_a_UnionLinkedList(self):
        # If list1 is bigger
        list1 = LinkedList()
        list2 = LinkedList()
        numbers = [1, 2, 3, 4, 5]
        numbersList1 = [1, 2, 3]
        numbersList2 = [4, 5]

        for i in numbersList1:
            list1.append(i)

        for i in numbersList2:
            list2.append(i)

        UnitedList = Calculator.union(list1, list2)
        numbersContained = 0
        for i in numbersList1 + numbersList2:
            number = UnitedList.peek().value
            if number in numbersList1 + numbersList2:
                numbersContained += 1
                numbers.remove(number)
        self.assertEqual(numbersContained, len(numbersList1 + numbersList2))

        # If list2 is bigger
        list1 = LinkedList()
        list2 = LinkedList()
        numbers = [1, 2, 3, 4, 5]
        numbersList1 = [1, 2]
        numbersList2 = [3, 4, 5]

        for i in numbersList1:
            list1.append(i)

        for i in numbersList2:
            list2.append(i)

        UnitedList = Calculator.union(list1, list2)
        numbersContained = 0
        for i in numbersList1 + numbersList2:
            number = UnitedList.peek().value
            if number in numbersList1 + numbersList2:
                numbersContained += 1
                numbers.remove(number)
        self.assertEqual(numbersContained, len(numbersList1 + numbersList2))

        # If lists are the same size
        list1 = LinkedList()
        list2 = LinkedList()
        numbers = [1, 2, 3, 4]
        numbersList1 = [1, 2]
        numbersList2 = [3, 4]

        for i in numbersList1:
            list1.append(i)

        for i in numbersList2:
            list2.append(i)

        UnitedList = Calculator.union(list1, list2)
        numbersContained = 0
        for i in numbersList1 + numbersList2:
            number = UnitedList.peek().value
            if number in numbersList1 + numbersList2:
                numbersContained += 1
                numbers.remove(number)
        self.assertEqual(numbersContained, len(numbersList1 + numbersList2))
예제 #8
0
 def test_04_should_return_first_element_of_merged_stack(self):
     unionList = Calculator.union(self.stack, self.stack)
     self.assertEqual(unionList.list[0], 15)
예제 #9
0
 def test_04_should_return_new_size_of_merged_queue(self):
     unionList = Calculator.union(self.stack, self.stack)
     self.assertEqual(unionList.size(), 6)
예제 #10
0
 def test_04_should_return_first_element_of_merged_queue(self):
     unionList = Calculator.union(self.queue, self.queue)
     self.assertEqual(unionList.first.value, 16)