def test_endService_empty_queue(self): mock_input = Queue() mock_input.getQueueLength = MagicMock(return_value=0) self.processorObj.addInput(mock_input) self.processorObj.hostedEntity = 1 self.assertFalse(self.processorObj.isIdle(), "The processor shouldn't be idle") self.processorObj.endService() self.assertTrue(self.processorObj.isIdle(), "The processor should be idle")
def test_enqueue(self): q = Queue() self.assertTrue(q.is_empty()) q.enqueue(1) self.assertFalse(q.is_empty()) self.assertEqual(q.peek(), 1) q.enqueue(2) self.assertNotEqual(q.peek(), 2)
def test_nextArrival_unlimited_capacity_idle_output(self): self.queueObj = Queue(0) output_queue = Queue(0) self.queueObj.addOutput(output_queue) self.queueObj.nextArrival(1) self.assertEqual(self.queueObj.getQueueLength(), 0, "The queue can transmit the entity")
def test_can_host_entity_unlimited_busy_output(self): mock_output = Queue() mock_output.canHostEntity = MagicMock(return_value=False) mock_output.nextArrival = MagicMock() self.queueObj.addOutput(mock_output) self.queueObj.nextArrival(0) self.assertEqual(self.queueObj.getQueueLength(), 1, "The queue mustn't be empty")
def __init__(self, page_sequence, num_of_frames): # Initializing a list attribute of page sequences self.sequence = page_sequence # Initializing the number of page faults self.page_fault = 0 # Initializing the number off frames self.frame_size = num_of_frames # Creating a queue to use self.queue = Queue()
def __init__(self, page_sequence, num_of_frames): # Initializing a list attribute containing the sequence of pages self.sequence = [] self.sequence = page_sequence # Initializing the variable holding the number of page faults self.page_fault = 0 # Initializing the variable telling us the number of frames to use self.frame_size = num_of_frames # Creating the queue data structure to be used self.queue = Queue()
def test_addOutput(self): source = Source(self.coreObj) self.assertIsNone(source.outputModule, "The output module should be empty") source.addOutput(Queue()) self.assertIsNotNone(source.outputModule, "The output module shouldn't be empty")
def test_can_host_entity_unlimited_not_busy_output(self): queueObj2 = Queue(0) queueObj = Queue(0) queueObj.addOutput(queueObj2) queueObj.nextArrival(0) self.assertEqual(queueObj.getQueueLength(), 0, "The queue must be empty")
def test_executeEvent_Not_NEXT_ARRIVAL(self): source = Source(self.coreObj) source.addOutput(Queue(1)) self.assertEqual(self.coreObj.entitiesSystem, 0, "The system should not have any entity") event = Event(eventName=Constants.END_SERVICE) source.executeEvent(event) self.assertEqual(self.coreObj.entitiesSystem, 0, "The system should not have any entity")
def test_nonempty_queue(): queue = Queue() queue.enqueue(1) queue.enqueue(2) queue.enqueue(3) assert len(queue) == 3 assert queue.dequeue() == 1 assert queue.front() == 2 assert len(queue) == 2 assert queue.dequeue() == 2 assert len(queue) == 1 assert queue.dequeue() == 3 assert len(queue) == 0
def test_executeEvent_before_SIMULATION_DURATION(self): source = Source(self.coreObj) queue = Queue(1) source.addOutput(queue) self.assertTrue(self.coreObj.eventsList.empty(), "The system should not have any entity") source.nextArrival() self.assertFalse(self.coreObj.eventsList.empty(), "The system should have one entity")
def test_executeEvent_Not_None_output(self): source = Source(self.coreObj) queue = Queue(1) source.addOutput(queue) self.assertEqual(len(queue.entitiesList), 0, "The queue should not have any entity") source.nextArrival() self.assertEqual(len(queue.entitiesList), 1, "The queue should have one entity")
def test_executeEvent_after_SIMULATION_DURATION(self): self.coreObj.currentTime = Constants.SIMULATION_FINAL_TIME source = Source(self.coreObj) queue = Queue(1) source.addOutput(queue) self.assertTrue(self.coreObj.eventsList.empty(), "The system should not have any entity") source.nextArrival() self.assertTrue(self.coreObj.eventsList.empty(), "The system should not have any entity")
def __init__(self, inputFeed): ''' In the initiation of a scheduler we set up the variables that will be needed, it takes a process feed as input so it can work with a group of processes, note that it copies the feed so that it doesn't change the feed for other schedulers. It also creates two queues, the arrival queue, which stores processes for which their arrival time has not yet occured, and the waiting queue which is where the processes that have arrived go. ''' processFeed = copy.deepcopy(inputFeed) processFeed.sort(key=lambda x: x.getArrivalTime()) processQ = Queue() for process in processFeed: processQ.add(process) self.arrivalQueue = processQ self.waitingQueue = Queue() self.clock = -1 # clock starts from -1 because the start of a tick method # always increments the clock at the start, so it will # effectively start from 0 self.currentProcess = None self.finishedArray = [ ] # processes that have finished get put here to be returned at the end self.count = 0 #used for prememption if needed, such as in RRS when the time slice is 2
def __init__(self, parameters=None): if parameters is None: self.parameters = Parameters() else: self.parameters = parameters num_sources = Constants.DEFAULT_SOURCES num_processors = self.parameters.num_processors # Attributes initialization self.processors = [] self.sources = [] self.eventsList = PriorityQueue(0) # maxsize = 0 (infinite) self.previousTime = Constants.SIMULATION_INITIAL_TIME self.currentTime = Constants.SIMULATION_INITIAL_TIME self.idleProcessors = 0 self.serviceProcessors = 0 self.entitiesSystem = 0 self.service_per_shift = [] self.service_per_total = [] self.shift_durations = self.parameters.getParameters()[1] self.shift_next_time = self.shift_durations[0] self.shift_next_index = 1 # Instance creation self.queue = Queue(Constants.SLOTS_BUFFER) self.parking = Queue(Constants.SLOTS_QUEUE) self.random = Random() for _ in range(0, num_processors): self.processors.append(Processor(self)) for _ in range(0, num_sources): self.sources.append(Source(self)) # Dependency injection for source in self.sources: source.addOutput(self.queue) # source -> queue self.queue.addOutput(self.parking) # queue -> parking self.parking.addInput(self.queue) # parking <- queue for processor in self.processors: self.parking.addOutput(processor) # parking -> processor processor.addInput(self.parking) # processor <- parking self.output_file = None self.numberOfIdleProcessors = num_processors
def test_is_empty(self): q = Queue() self.assertTrue(q.is_empty()) for i in range(1000): n = random.randint(0, 1000) q.enqueue(n) counter = 0 while (not q.is_empty()): q.dequeue() counter += 1 self.assertEqual(counter, 1000)
def test_nextArrival_unlimited_capacity_idle_output(self): self.queueObj = Queue(0) mock_output = Queue() mock_output.canHostEntity = MagicMock(return_value=True) mock_output.nextArrival = MagicMock() self.queueObj.addOutput(mock_output) self.queueObj.nextArrival(1) self.assertEqual(self.queueObj.getQueueLength(), 0, "The queue can transmit the entity")
def test_nextArrival_unlimited_capacity_busy_output_has_already_an_entity( self): self.queueObj = Queue(0) output_queue = Queue(1) output_queue.nextArrival(1) self.queueObj.addOutput(output_queue) self.queueObj.nextArrival(1) self.queueObj.nextArrival(1) self.assertEqual(self.queueObj.getQueueLength(), 2, "The queue cannot transmit the entity")
def test_nextArrival_unlimited_capacity_busy_output_has_already_an_entity( self): self.queueObj = Queue(0) mock_output = Queue() mock_output.canHostEntity = MagicMock(return_value=False) mock_output.nextArrival = MagicMock() self.queueObj.addOutput(mock_output) self.queueObj.nextArrival(1) self.queueObj.nextArrival(1) self.assertEqual(self.queueObj.getQueueLength(), 2, "The queue cannot transmit the entity")
def test_nextArrival_limited_capacity_busy_output_has_no_elements_above_limit( self): self.queueObj = Queue(1) output_queue = Queue(1) output_queue.nextArrival(1) self.queueObj.addOutput(output_queue) self.queueObj.nextArrival(1) try: self.queueObj.nextArrival(1) self.fail() except: pass
def test_nextArrival_limited_capacity_busy_output_has_no_elements_above_limit( self): self.queueObj = Queue(1) mock_output = Queue() mock_output.canHostEntity = MagicMock(return_value=False) mock_output.nextArrival = MagicMock() self.queueObj.addOutput(mock_output) self.queueObj.nextArrival(1) try: self.queueObj.nextArrival(1) self.fail() except: pass
def test_str(self): q = Queue() self.assertEqual(str(q), '') s = '' for i in range(50): r = random.randint(1, 200) q.enqueue(r) if (s == ''): s = str(r) else: s = str(r) + ' ' + s k = len(str(q.peek())) s = s[:-(k + 1)] q.dequeue() self.assertEqual(str(q), s)
def test_equals(self): qa = Queue() qb = Queue() self.assertEqual(qa, qb) for i in range(50): r = random.randint(1, 200) qa.enqueue(r) self.assertNotEqual(qa, qb) qb.enqueue(r) self.assertEqual(qa, qb) for i in range(50): qa.dequeue() self.assertNotEqual(qa, qb) qb.dequeue() self.assertEqual(qa, qb)
def test_dequeue(self): q = Queue() self.assertRaises(IndexError, q.dequeue) for i in range(10): q.enqueue(i) for i in range(9): self.assertEqual(q.peek(), i) q.dequeue() self.assertNotEqual(q.peek(), i) self.assertFalse(q.is_empty()) q.dequeue() self.assertTrue(q.is_empty())
def test_peek(self): q = Queue() self.assertRaises(IndexError, q.peek) q.enqueue(0) self.assertEqual(q.peek(), 0) q.enqueue(1) self.assertNotEqual(q.peek(), 1) self.assertEqual(q.peek(), 0) q.dequeue() self.assertEqual(q.peek(), 1)
class TestQueue(unittest.TestCase): def setUp(self): self.queueObj = Queue() def tearDown(self): self.queueObj = None def test_can_host_entity_unlimited_not_busy_output(self): mock_output = Queue() mock_output.canHostEntity = MagicMock(return_value=True) mock_output.nextArrival = MagicMock() self.queueObj.addOutput(mock_output) self.queueObj.nextArrival(0) self.assertEqual(self.queueObj.getQueueLength(), 0, "The queue must be empty") def test_can_host_entity_unlimited_busy_output(self): mock_output = Queue() mock_output.canHostEntity = MagicMock(return_value=False) mock_output.nextArrival = MagicMock() self.queueObj.addOutput(mock_output) self.queueObj.nextArrival(0) self.assertEqual(self.queueObj.getQueueLength(), 1, "The queue mustn't be empty") def test_can_host_entity_limited_not_busy_output(self): self.queueObj = Queue(1) mock_output = Queue() mock_output.canHostEntity = MagicMock(return_value=True) mock_output.nextArrival = MagicMock() self.queueObj.addOutput(mock_output) self.queueObj.nextArrival(0) self.queueObj.nextArrival(0) self.queueObj.nextArrival(0) self.assertEqual(self.queueObj.getQueueLength(), 0, "The queue must be empty") def test_can_host_entity_limited_busy_output(self): self.queueObj = Queue(1) mock_output = Queue() mock_output.canHostEntity = MagicMock(return_value=False) mock_output.nextArrival = MagicMock() self.queueObj.addOutput(mock_output) self.queueObj.nextArrival(0) self.assertEqual(self.queueObj.getQueueLength(), 1, "The queue mustn't be empty") try: self.queueObj.nextArrival(0) self.fail() except: pass def test_canHostEntity_unlimited_queue(self): self.queueObj.nextArrival(0) self.queueObj.nextArrival(0) self.queueObj.nextArrival(0) self.assertTrue(self.queueObj.canHostEntity(), "The queue should hold all elements") def test_canHostEntity_limited_queue(self): self.queueObj = Queue(1) self.queueObj.nextArrival(0) self.assertFalse(self.queueObj.canHostEntity(), "The queue shouldn't hold more elements") def test_getEntity(self): # def getEntity(self, outputModule) # queue2 <-> main queue -> mock output self.queueObj = Queue(1) queueObj2 = Queue() queueObj2.addOutput(self.queueObj) mock_output = Queue() mock_output.canHostEntity = MagicMock(return_value=False) mock_output.nextArrival = MagicMock() self.queueObj.addInput(queueObj2) self.queueObj.addOutput(mock_output) queueObj2.nextArrival(1) queueObj2.nextArrival(1) self.assertEqual(self.queueObj.getQueueLength(), 1, "The queue mustn't be empty") self.assertEqual(queueObj2.getQueueLength(), 1, "The queue mustn't be empty") # The exception is risen because que mock_output queue cannot host any entity try: self.queueObj.getEntity(mock_output) except: pass try: self.queueObj.getEntity(mock_output) except: pass self.assertEqual(self.queueObj.getQueueLength(), 0, "The queue must be empty") self.assertEqual(queueObj2.getQueueLength(), 0, "The queue must be empty") def test_nextArrival_unlimited_capacity_no_output(self): self.queueObj = Queue(0) self.queueObj.nextArrival(1) self.assertEqual(self.queueObj.getQueueLength(), 1, "The queue cannot transmit the entity") def test_nextArrival_unlimited_capacity_busy_output(self): self.queueObj = Queue(0) mock_output = Queue() mock_output.canHostEntity = MagicMock(return_value=False) mock_output.nextArrival = MagicMock() self.queueObj.addOutput(mock_output) self.queueObj.nextArrival(1) self.assertEqual(self.queueObj.getQueueLength(), 1, "The queue cannot transmit the entity") def test_nextArrival_unlimited_capacity_idle_output(self): self.queueObj = Queue(0) mock_output = Queue() mock_output.canHostEntity = MagicMock(return_value=True) mock_output.nextArrival = MagicMock() self.queueObj.addOutput(mock_output) self.queueObj.nextArrival(1) self.assertEqual(self.queueObj.getQueueLength(), 0, "The queue can transmit the entity") def test_nextArrival_unlimited_capacity_busy_output_has_already_an_entity( self): self.queueObj = Queue(0) mock_output = Queue() mock_output.canHostEntity = MagicMock(return_value=False) mock_output.nextArrival = MagicMock() self.queueObj.addOutput(mock_output) self.queueObj.nextArrival(1) self.queueObj.nextArrival(1) self.assertEqual(self.queueObj.getQueueLength(), 2, "The queue cannot transmit the entity") def test_nextArrival_limited_capacity_busy_output_has_no_elements_above_limit( self): self.queueObj = Queue(1) mock_output = Queue() mock_output.canHostEntity = MagicMock(return_value=False) mock_output.nextArrival = MagicMock() self.queueObj.addOutput(mock_output) self.queueObj.nextArrival(1) try: self.queueObj.nextArrival(1) self.fail() except: pass
class Scheduler: def __init__(self, inputFeed): ''' In the initiation of a scheduler we set up the variables that will be needed, it takes a process feed as input so it can work with a group of processes, note that it copies the feed so that it doesn't change the feed for other schedulers. It also creates two queues, the arrival queue, which stores processes for which their arrival time has not yet occured, and the waiting queue which is where the processes that have arrived go. ''' processFeed = copy.deepcopy(inputFeed) processFeed.sort(key=lambda x: x.getArrivalTime()) processQ = Queue() for process in processFeed: processQ.add(process) self.arrivalQueue = processQ self.waitingQueue = Queue() self.clock = -1 # clock starts from -1 because the start of a tick method # always increments the clock at the start, so it will # effectively start from 0 self.currentProcess = None self.finishedArray = [ ] # processes that have finished get put here to be returned at the end self.count = 0 #used for prememption if needed, such as in RRS when the time slice is 2 def isFinished(self): ''' useful to know when a sheduler is done processing all the processes, this has a few elements, but essentially we know the scheduler is done only when both the queues are empty, and there is no current process ''' return self.arrivalQueue.isEmpty() and self.waitingQueue.isEmpty( ) and self.currentProcess is None def getAvgTurnaroundTime(self): ''' After asserting the scheduler is finished, it goes through each process in the finished array and increments the total turnaround time by the current processes turnaround time. It then divides this total by the number of processes to get the average turnaround time ''' assert (self.isFinished()) totalTurnaroundTime = 0 for process in self.finishedArray: totalTurnaroundTime += process.getTurnAroundTime() avgTurnaroundTime = totalTurnaroundTime / len(self.finishedArray) return avgTurnaroundTime def getAvgWaitingTime(self): ''' After asserting the scheduler is finished, it goes through each process in the finished array and increments the total waiting time by the current processes waiting time. It then divides this total by the number of processes to get the average waiting time ''' assert (self.isFinished()) totalWaitingTime = 0 for process in self.finishedArray: totalWaitingTime += process.getWaitingTime() avgWaitingTime = totalWaitingTime / len(self.finishedArray) return avgWaitingTime def getThroughput(self): ''' After asserting the scheduler is finished it calculates the throughput, the throughput is the number of processes completed per second, since we know the clock wont be incremented after all the processes are done, this is simply the number of processes divided by the clock (since every process in the finished array must be finished). ''' assert (self.isFinished()) throughput = len(self.finishedArray) / self.clock return throughput
def test_getEntity(self): # def getEntity(self, outputModule) # queue2 <-> main queue -> mock output self.queueObj = Queue(1) queueObj2 = Queue() queueObj2.addOutput(self.queueObj) mock_output = Queue() mock_output.canHostEntity = MagicMock(return_value=False) mock_output.nextArrival = MagicMock() self.queueObj.addInput(queueObj2) self.queueObj.addOutput(mock_output) queueObj2.nextArrival(1) queueObj2.nextArrival(1) self.assertEqual(self.queueObj.getQueueLength(), 1, "The queue mustn't be empty") self.assertEqual(queueObj2.getQueueLength(), 1, "The queue mustn't be empty") # The exception is risen because que mock_output queue cannot host any entity try: self.queueObj.getEntity(mock_output) except: pass try: self.queueObj.getEntity(mock_output) except: pass self.assertEqual(self.queueObj.getQueueLength(), 0, "The queue must be empty") self.assertEqual(queueObj2.getQueueLength(), 0, "The queue must be empty")
def test_canHostEntity_limited_queue(self): self.queueObj = Queue(1) self.queueObj.nextArrival(0) self.assertFalse(self.queueObj.canHostEntity(), "The queue shouldn't hold more elements")
def setUp(self): self.queueObj = Queue()