class MyTestCase(unittest.TestCase):
def setUp(self):
#Se crea el pcb del primer programa
self._program1 = Program("so.exe", [CPU(2), CPU(1)], 2)
self._PCBProgram1 = PCB(0)
self._PCBProgram1.set_priority(self._program1.get_priority())
# Se crea el pcb del segundo programa
self._program2 = Program("exel.exe", [CPU(1), IO(1)], 1)
self._PCBProgram2 = PCB(1)
self._PCBProgram2.set_priority(self._program2.get_priority())
# Se crea el pcb del tercer programa
self._program3 = Program("paint.exe", [CPU(4), IO(1)], 3)
self._PCBProgram3 = PCB(2)
self._PCBProgram3.set_priority(self._program3.get_priority())
# Se crea el pcb del tercer programa
self._program4 = Program("word.exe", [CPU(4), IO(1)], 2)
self._PCBProgram4 = PCB(3)
self._PCBProgram4.set_priority(self._program4.get_priority())
# Se inicializa al SchedulerPriorityPreventive con un aging de 3
self._pcbTable = PCBTable()
self._pcbTable.addPCB(self._PCBProgram1)
self._pcbTable.addPCB(self._PCBProgram2)
self._pcbTable.addPCB(self._PCBProgram3)
self._pcbTable.addPCB(self._PCBProgram4)
self._aging = 3
self._shedulerTest = SchedulerPriorityPreemptive(
self._pcbTable, self._aging)
# Se agregan los pid, prioridad y los primeros burst de los tres programas
self._shedulerTest.add(self._PCBProgram1)
self._shedulerTest.add(self._PCBProgram2)
self._shedulerTest.add(self._PCBProgram3)
self._shedulerTest.add(self._PCBProgram4)
def testSchedulerPriorityPreventive(self):
# Se comprueba que se desencola primero el pid del programa 2, porque es el de menor prioridad
self.assertEqual(self._shedulerTest.pop(), self._PCBProgram2.get_pid())
# Se comprueba que se desencola el pid del programa 1, porque es siguiente de menor prioridad
self.assertEqual(self._shedulerTest.pop(), self._PCBProgram1.get_pid())
# y la prioridad del programa 1 sigue siendo de 2
self.assertEqual(self._PCBProgram1.get_priority(), 2)
# Se comprueba que se desencola el pid del programa 4, porque es siguiente de menor prioridad
self.assertEqual(self._shedulerTest.pop(), self._PCBProgram4.get_pid())
# el aging llego a 3
# y la prioridad del programa 1 ahora es de 2 por el aging del scheduler
self.assertEqual(self._PCBProgram4.get_priority(), 1)
# Se comprueba que se desencola el pid del programa 3, porque es siguiente de menor prioridad
self.assertEqual(self._shedulerTest.pop(), self._PCBProgram3.get_pid())
# y la prioridad del programa 1 ahora es de 2 por el aging del scheduler
self.assertEqual(self._PCBProgram3.get_priority(), 2)
class MyTestCase(unittest.TestCase):
def setUp(self):
#Se crea el pcb del primer programa
self._program1 = Program("so.exe", [CPU(2), CPU(1)], 1)
self._PCBProgram1 = PCB(0)
self._PCBProgram1.initialize(self._program1,
self._program1.longitud() // 4)
# Se crea el pcb del segundo programa
self._program2 = Program("exel.exe", [CPU(1), IO(1)], 2)
self._PCBProgram2 = PCB(1)
self._PCBProgram2.initialize(self._program2,
self._program2.longitud() // 4)
# Se crea el pcb del tercer programa
self._program3 = Program("paint.exe", [CPU(4), IO(1)], 3)
self._PCBProgram3 = PCB(2)
self._PCBProgram3.initialize(self._program3,
self._program3.longitud() // 4)
# Se crea al schedulerSJF
self._shedulerSJF = SchedulerSJFPreemptive()
# Se agregan el pid, la prioridad(en este caso no se utiliza),
# y el primer burst de los programas 2 y 3
self._shedulerSJF.add(self._PCBProgram2)
self._shedulerSJF.add(self._PCBProgram3)
# Obtiene el primer burst del programa 1
firstBurstProgram1 = self._PCBProgram1.get_firstBurst()
# Setea el primer burst del programa que esta en la CPU
self._shedulerSJF.set_burstPCBInCPU(firstBurstProgram1)
def testSchedulerSJF(self):
# Obtiene el primer burst del programa 2
firstBurstProgram2 = self._PCBProgram2.get_firstBurst()
# Se comprueba que el burst del programa 2 es menor que el programa que esta en CPU
self.assertTrue(
self._shedulerSJF.isChange(self._PCBProgram3, self._PCBProgram2))
# El scheduler desencola un programa
pid = self._shedulerSJF.pop()
# Se comprueba que desencolo al pid del programa con menor burst
self.assertEqual(pid, self._PCBProgram2.get_pid())
# Setea el busrt del programa que ahora esta en CPU
self._shedulerSJF.set_burstPCBInCPU(firstBurstProgram2)
# Se comprueba que el burst del programa 3 es menor que el programa que esta en CPU
self.assertFalse(
self._shedulerSJF.isChange(self._PCBProgram2, self._PCBProgram3))
class MyTestCase(unittest.TestCase):
def setUp(self):
#Se crea el pcb del primer programa
self._program1 = Program("so.exe", [CPU(9)], 2)
self._PCBProgram1 = PCB(0)
# Se crea el pcb del segundo programa
self._program2 = Program("exel.exe", [CPU(12)], 1)
self._PCBProgram2 = PCB(1)
# Se crea el pcb del tercer programa
self._program3 = Program("paint.exe", [CPU(8)], 3)
self._PCBProgram3 = PCB(2)
# Se crea el pcb del cuarto programa
self._program4 = Program("word.exe", [CPU(7)], 2)
self._PCBProgram4 = PCB(3)
# Se crea el pcb del cuarto programa
self._program5 = Program("pycharm.exe", [CPU(1)], 2)
self._PCBProgram5 = PCB(4)
# Se inicializa la memoria
self._memory = Memory(64)
# Se inicializa el disco y el Loader
self._memoryManager = MemoryManagerContinuousAssignmentFirstFit(
self._memory, mock.Mock(), mock.Mock(),
1) # El numero indica el moreSpace
def testMemory(self):
# Se cargan cuatro programas a memoria
self._memoryManager.addProgram(self._PCBProgram1.get_pid(),
self._program1.longitud())
self._memoryManager.addProgram(self._PCBProgram2.get_pid(),
self._program2.longitud())
self._memoryManager.addProgram(self._PCBProgram3.get_pid(),
self._program3.longitud())
self._memoryManager.addProgram(self._PCBProgram4.get_pid(),
self._program4.longitud())
# Se verifica que el memoryManager tenga la cantidad correcta de bloques en cada lista
self.assertEquals(4, len(self._memoryManager.getUsedBlocks()))
self.assertEquals(1, len(self._memoryManager.getFreeBlocks()))
# Se elimina un programa
self._memoryManager.freeMemory(self._PCBProgram1.get_pid())
# Se verifica que el memoryManager tenga la cantidad correcta de bloques en cada lista
self.assertEquals(3, len(self._memoryManager.getUsedBlocks()))
self.assertEquals(2, len(self._memoryManager.getFreeBlocks()))
# Se elimina un programa
self._memoryManager.freeMemory(self._PCBProgram3.get_pid())
# Se verifica que el memoryManager tenga la cantidad correcta de bloques en cada lista
self.assertEquals(2, len(self._memoryManager.getUsedBlocks()))
self.assertEquals(3, len(self._memoryManager.getFreeBlocks()))
# Se elimina un programa
self._memoryManager.freeMemory(self._PCBProgram2.get_pid())
# Se verifica que el memoryManager tenga la cantidad correcta de bloques en cada lista
self.assertEquals(1, len(self._memoryManager.getUsedBlocks()))
self.assertEquals(2, len(self._memoryManager.getFreeBlocks()))
# Se carga un quinto programa a memoria
self._memoryManager.addProgram(self._PCBProgram5.get_pid(),
self._program5.longitud())
# Se verifica que el memoryManager tenga la cantidad correcta de bloques en cada lista
self.assertEquals(2, len(self._memoryManager.getUsedBlocks()))
self.assertEquals(2, len(self._memoryManager.getFreeBlocks()))
# Se elimina un programa
self._memoryManager.freeMemory(self._PCBProgram4.get_pid())
# Se verifica que el memoryManager tenga la cantidad correcta de bloques en cada lista
self.assertEquals(1, len(self._memoryManager.getUsedBlocks()))
self.assertEquals(2, len(self._memoryManager.getFreeBlocks()))
# Se elimina un programa
self._memoryManager.freeMemory(self._PCBProgram5.get_pid())
# Se verifica que el memoryManager tenga la cantidad correcta de bloques en cada lista
self.assertEquals(0, len(self._memoryManager.getUsedBlocks()))
self.assertEquals(1, len(self._memoryManager.getFreeBlocks()))