class TestMemoryPagination_ValidateVirtualAddress(unittest.TestCase):
def setUp(self):
bits_for_physical_addres = 3
bits_for_page_size = 1
self.memory = Memory(2**bits_for_physical_addres)
self.mem_pag = PaginationStrategy(self.memory, 2**bits_for_page_size)
## Mockeo el Pcb, solo necesito su pid
self.pcb = Mock()
self.pcb.get_pid.return_value = 1
'''
Page table has 2 pages, and virtual address has 2 bits for page and 1 for offset, so possible virtual addresses are:
000 : page 0, offset 0
001 : page 0, offset 1
010 : page 1, offset 0
011 : page 1, offset 1
'''
self.page_table = self.mem_pag.malloc(self.pcb,3)
def test_when_trying_all_posible_virtual_address_then_wrong_ones_should_raise_InvalidAddressException(self):
ins_put = "instruction"
for n in range(2**3):
addr = self.mem_pag.virtual_address_for(self.pcb, n)
print "addr: " + addr + "- n: " + str(n)
if (n < 4):
self.assertTrue(self.mem_pag.validate_virtual_address(self.pcb, addr))
else :
with self.assertRaises(InvalidAddressException) :
self.mem_pag.validate_virtual_address(self.pcb, addr)
def setUp(self):
self.memory = Memory(2**2)
self.mem_pag = PaginationStrategy(self.memory, 2)
## Mockeo el Pcb, solo necesito su pid
self.pcb = Mock()
self.pcb.get_pid.return_value = 1
class TestMemoryPagination_Malloc(unittest.TestCase):
def setUp(self):
self.memory = Memory(2**2)
self.mem_pag = PaginationStrategy(self.memory, 2)
## Mockeo el Pcb, solo necesito su pid
self.pcb = Mock()
self.pcb.get_pid.return_value = 1
def test_when_mallocing_4_spaces_then_page_table_has_2_pages(self):
page_table = self.mem_pag.malloc(self.pcb,4)
pages = page_table.get_page_count()
self.assertEqual(pages,2)
def test_when_mallocing_3_spaces_then_page_table_has_2_pages(self):
page_table = self.mem_pag.malloc(self.pcb,3)
pages = page_table.get_page_count()
self.assertEqual(pages,2)
def test_when_mallocing_2_spaces_then_page_table_has_1_page(self):
page_table = self.mem_pag.malloc(self.pcb,2)
pages = page_table.get_page_count()
self.assertEqual(pages,1)
def test_when_mallocing_4_spaces_then_free_space_is_0(self):
page_table = self.mem_pag.malloc(self.pcb,4)
self.assertEqual(self.mem_pag.free_space(),0)
def test_when_mallocing_3_spaces_then_free_space_is_0(self):
page_table = self.mem_pag.malloc(self.pcb,4)
self.assertEqual(self.mem_pag.free_space(),0)
def test_when_mallocing_2_spaces_then_free_space_is_2(self):
page_table = self.mem_pag.malloc(self.pcb,4)
self.assertEqual(self.mem_pag.free_space(),0)
def setUp(self):
bits_for_physical_addres = 3
bits_for_page_size = 1
self.memory = Memory(2**bits_for_physical_addres)
self.mem_pag = PaginationStrategy(self.memory, 2**bits_for_page_size)
## Mockeo el Pcb, solo necesito su pid
self.pcb = Mock()
self.pcb.get_pid.return_value = 1
'''
Page table has 2 pages, and virtual address has 2 bits for page and 1 for offset, so possible virtual addresses are:
000 : page 0, offset 0
001 : page 0, offset 1
010 : page 1, offset 0
011 : page 1, offset 1
'''
self.page_table = self.mem_pag.malloc(self.pcb,3)
class TestMemoryPagination_Put_and_Get(unittest.TestCase):
def setUp(self):
bits_for_physical_addres = 3
bits_for_page_size = 1
self.memory = Memory(2**bits_for_physical_addres)
self.mem_pag = PaginationStrategy(self.memory, 2**bits_for_page_size)
## Mockeo el Pcb, solo necesito su pid
self.pcb = Mock()
self.pcb.get_pid.return_value = 1
'''
Page table has 2 pages, and virtual address has 2 bits for page and 1 for offset, so possible virtual addresses are:
000 : page 0, offset 0
001 : page 0, offset 1
010 : page 1, offset 0
011 : page 1, offset 1
'''
self.page_table = self.mem_pag.malloc(self.pcb,3)
def test_when_put_instruction_in_001_for_page_table_then_get_001_returns_instruction(self):
address = '001'
ins_put = "instruction"
self.mem_pag.put(self.pcb, address, ins_put)
ins_get = self.mem_pag.get(self.pcb, address)
self.assertEqual(ins_get , ins_put)
def test_when_put_instruction_in_111_for_page_table_then_raises_IndexError(self):
address = '111'
ins_put = "instruction"
with self.assertRaises(IndexError):
self.mem_pag.put(self.pcb, address, ins_put)
