SimulationTuplesort/Roundabouts.py

import unittest



class Roundabout:
    def __init__(self, rotation = 0):
        self.coatHangers = list()
        self.rotation = rotation

    def addList(self, items):
            for item in items:
                self.add(item)

    def add(self, item):
        if self.rotation == 0: #linksdrehend
            self.coatHangers.insert(0, item)
        else:
            self.coatHangers.append(item)

    def remove(self):
        if self.rotation == 0: #linksdrehend
           return self.coatHangers.pop()
        else:
            return self.coatHangers.pop(0)

    def content(self):
        return self.coatHangers

    def itemOnSeparator(self):
        if self.rotation == 0: #linksdrehend
            return self.coatHangers[-1]
        else:
            return self.coatHangers[0]

    def getSmallestItem(self):
        return min(self.coatHangers)
    
    def isEmpty(self):
        return len(self.coatHangers) == 0 
        

class Switch:
    def __init__(self, left_roundabout: Roundabout, right_roundabout: Roundabout):
        self.lR = left_roundabout
        self.rR = right_roundabout
        self.set_to_left()

    def switch(self):
        if self.is_left():
            self.set_to_right()
        else:
            self.set_to_left()

    def set_to_left(self):
        self.status = 0
        return self.status

    def set_to_right(self):
        self.status = 1
        return self.status

    def is_left(self):
        if self.status == 0:
            return True
        return False

    def is_right(self):
        if self.status == 1:
            return True
        return False

    def assign(self, item):
        if self.is_left():
            self.lR.add(item)
        else:
            self.rR.add(item)


class RoundaboutPair:
    def __init__(self, left_roundabout: Roundabout, right_roundabout: Roundabout, switch: Switch):
        self.lR = left_roundabout
        self.rR = right_roundabout
        self.sw = switch
        self.sortProcedure = "p" # picksort
    
    def setSortType (self, t):
        """ param t: walweise p(icksort) oder t(uplesort) 
        """
        self.sortProcedure = t

    def sortStep(self):
        if self.sortProcedure == "p":   # picksort
            if self.lR.getSmallestItem() == self.lR.itemOnSeparator():
                item = self.lR.remove()
                self.sw.set_to_right()
                self.sw.assign(item)
                self.sw.set_to_left()
            else:
                item = self.lR.remove()
                self.sw.assign(item)
        else:               # tuplesort
            self.sw.set_to_right()
            runSorting = True
            while runSorting:
                maxOfLastItems = self.passageOfSeparatorItems()
                leftItem = self.lR.itemOnSeparator()
                rightItem = self.rR.itemOnSeparator()
                minOfCurentSeparatorItems =  min(leftItem, rightItem)
                if maxOfLastItems > minOfCurentSeparatorItems:
                    self.sw.switch()
                if self.lR.isEmpty():
                    runSorting = False



    def passageOfSeparatorItems(self):
        if self.lR.itemOnSeparator() < self.rR.itemOnSeparator():
            leftItem = self.lR.remove()
            self.sw.assign(leftItem)
            rightItem = self.rR.remove()
            self.sw.assign(rightItem)
        else:
            rightItem = self.rR.remove()
            self.sw.assign(rightItem)
            leftItem = self.lR.remove()
            self.sw.assign(leftItem)
        return max(rightItem, leftItem)


    def runSimulation(self):
        number = 0 
        while not self.lR.isEmpty():
            self.sortStep()
            number += 1
            if number > 300:
                break

    def show(self):
        return (self.lR.content(), self.rR.content())





class TestObjectMethods(unittest.TestCase):
    def test_roundabout(self):
        k1 = Roundabout()
        k1.addList([1, 2, 3])
        self.assertEqual(k1.content(), [3, 2, 1])
        self.assertEqual(k1.remove(), 1)
        self.assertEqual(k1.content(), [3, 2])

        k2 = Roundabout() # links drehend
        k2.add(1)
        k2.add(2)
        k2.add(3)
        k2.add(4)
        self.assertEqual(k2.content(), [4, 3, 2, 1])

        k3 = Roundabout(1) # rechts drehend
        k3.add(5)
        k3.add(6)
        k3.add(7)
        k3.add(8)
        self.assertEqual(k3.content(), [5, 6, 7, 8])



        self.assertEqual(k2.itemOnSeparator(), 1)
        self.assertEqual(k3.itemOnSeparator(), 5)

        
        self.assertEqual(k3.remove(), 5)
        self.assertEqual(k2.remove(), 1)

        k5 = Roundabout()
        self.assertEqual(k5.isEmpty(), True)
        k5.addList([1, 2, 3])
        self.assertEqual(k5.isEmpty(), False)
        self.assertEqual(k5.getSmallestItem(), 1)


    def test_switch(self):
        k1 = Roundabout()
        k2 = Roundabout()
        sw = Switch(k1, k2)
        self.assertEqual(sw.set_to_left(), 0)
        sw.set_to_right()
        self.assertEqual(sw.is_right(), True)
        self.assertEqual(sw.is_left(), False)

    def test_pair(self):
        lK = Roundabout()
        lK.addList([6, 5, 4, 3, 2, 1])
        rK = Roundabout(1)
        sw = Switch(lK, rK)
        p = RoundaboutPair(lK, rK, sw)
        self.assertEqual(lK.content(), [1, 2, 3, 4, 5, 6])
        self.assertEqual(p.show(), ([1, 2, 3, 4, 5, 6], []))

        p.sortStep()
        self.assertEqual(p.show(), ([6, 1, 2, 3, 4, 5], []))
        p.sortStep()
        self.assertEqual(p.show(), ([5, 6, 1, 2, 3, 4], []))
        p.sortStep()
        self.assertEqual(p.show(), ([4, 5, 6, 1, 2, 3], []))
        p.sortStep()
        self.assertEqual(p.show(), ([3, 4, 5, 6, 1, 2], []))
        p.sortStep()
        self.assertEqual(p.show(), ([2, 3, 4, 5, 6, 1], []))
        p.sortStep()
        self.assertEqual(p.show(), ([2, 3, 4, 5, 6], [1]))

    def test_picksort(self):
        lK = Roundabout()
        lK.addList([6, 5, 4, 3, 2, 1])
        rK = Roundabout(1)
        sw = Switch(lK, rK)
        p = RoundaboutPair(lK, rK, sw)
        self.assertEqual(lK.content(), [1, 2, 3, 4, 5, 6])

        p.runSimulation()
        self.assertEqual(p.show(), ([], [1, 2, 3, 4, 5, 6]))

    def test_tuplesort(self):
        lK = Roundabout()
        lK.addList([3, 2, 1])
        rK = Roundabout(1)
        rK.addList([6, 5, 4])
        sw = Switch(lK, rK)
        p = RoundaboutPair(lK, rK, sw)
        self.assertEqual(p.show(), ([1, 2, 3], [6, 5, 4]))
        p.setSortType('t')

        p.sortStep()
        self.assertEqual(p.show(), ([1, 2], [5, 4, 3, 6]))




if __name__ == '__main__':
    unittest.main()