def test_write_single_field(self): """ Write a single field to the eeprom file. """ done = {} def read(data): """ Read dummy. """ if data["bank"] == 1: done['read1'] = True return {"data": "\xff" * 256} else: raise Exception("Wrong page") def write(data): """ Write dummy. """ self.assertEquals(1, data["bank"]) self.assertEquals(2, data["address"]) self.assertEquals("abc", data["data"]) done['write'] = True communicator = MasterCommunicator(read, write) eeprom_file = EepromFile(communicator) eeprom_file.write([EepromData(EepromAddress(1, 2, 3), "abc")]) self.assertTrue('read1' in done) self.assertTrue('write' in done)
def test_read_multiple_banks(self): """ Test read from multiple banks. """ def read(_data): """ Read dummy. """ if _data["bank"] == 1: return {"data": "abc" + "\xff" * 200 + "def" + "\xff" * 48} if _data["bank"] == 100: return {"data": "hello" + "\x00" * 100 + "world" + "\x00" * 146} else: raise Exception("Wrong page") eeprom_file = EepromFile(MasterCommunicator(read)) address1 = EepromAddress(1, 2, 10) address2 = EepromAddress(100, 4, 10) address3 = EepromAddress(100, 105, 5) data = eeprom_file.read([address1, address2, address3]) self.assertEquals(3, len(data)) self.assertEquals(address1, data[address1].address) self.assertEquals("c" + "\xff" * 9, data[address1].bytes) self.assertEquals(address2, data[address2].address) self.assertEquals("o" + "\x00" * 9, data[address2].bytes) self.assertEquals(address3, data[address3].address) self.assertEquals("world", data[address3].bytes)
def test_read_multiple_banks(self): """ Test read from multiple banks. """ def read(_data): """ Read dummy. """ if _data["bank"] == 1: return {"data": "abc" + "\xff" * 200 + "def" + "\xff" * 48} if _data["bank"] == 100: return { "data": "hello" + "\x00" * 100 + "world" + "\x00" * 146 } else: raise Exception("Wrong page") eeprom_file = EepromFile(MasterCommunicator(read)) address1 = EepromAddress(1, 2, 10) address2 = EepromAddress(100, 4, 10) address3 = EepromAddress(100, 105, 5) data = eeprom_file.read([address1, address2, address3]) self.assertEquals(3, len(data)) self.assertEquals(address1, data[address1].address) self.assertEquals("c" + "\xff" * 9, data[address1].bytes) self.assertEquals(address2, data[address2].address) self.assertEquals("o" + "\x00" * 9, data[address2].bytes) self.assertEquals(address3, data[address3].address) self.assertEquals("world", data[address3].bytes)
def get_module_addresses(master_communicator, type): """ Get the addresses for the modules of the given type. :param master_communicator: used to read the addresses from the master eeprom. :type master_communicator: MasterCommunicator :param type: the type of the module (o, r, d, i, t, c) :param type: chr :returns: A list containing the addresses of the modules (strings of length 4). """ eeprom_file = EepromFile(master_communicator) base_address = EepromAddress(0, 1, 2) no_modules = eeprom_file.read([base_address]) modules = [] no_input_modules = ord(no_modules[base_address].bytes[0]) for i in range(no_input_modules): address = EepromAddress(2 + i, 0, 4) modules.append(eeprom_file.read([address])[address].bytes) no_output_modules = ord(no_modules[base_address].bytes[1]) for i in range(no_output_modules): address = EepromAddress(33 + i, 0, 4) modules.append(eeprom_file.read([address])[address].bytes) return [module for module in modules if module[0].lower() == type]
def test_write_multiple_fields(self): """ Test writing multiple fields to the eeprom file. """ done = {} def read(data): """ Read dummy. """ if data["bank"] == 1: done['read1'] = True return {"data": "\xff" * 256} elif data["bank"] == 2: done['read2'] = True return {"data": "\x00" * 256} else: raise Exception("Wrong page") def write(data): """ Write dummy. """ if 'write1' not in done: done['write1'] = True self.assertEquals(1, data["bank"]) self.assertEquals(2, data["address"]) self.assertEquals("abc", data["data"]) elif 'write2' not in done: done['write2'] = True self.assertEquals(2, data["bank"]) self.assertEquals(123, data["address"]) self.assertEquals("More bytes", data["data"]) elif 'write3' not in done: done['write3'] = True self.assertEquals(2, data["bank"]) self.assertEquals(133, data["address"]) self.assertEquals(" than 10", data["data"]) else: raise Exception("Too many writes") communicator = MasterCommunicator(read, write) eeprom_file = EepromFile(communicator) eeprom_file.write([ EepromData(EepromAddress(1, 2, 3), "abc"), EepromData(EepromAddress(2, 123, 18), "More bytes than 10") ]) self.assertTrue('read1' in done) self.assertTrue('read2' in done) self.assertTrue('write1' in done) self.assertTrue('write2' in done) self.assertTrue('write3' in done)
def test_read_one_bank_one_address(self): """ Test read from one bank with one address """ def read(_data): """ Read dummy. """ if _data["bank"] == 1: return {"data": "abc" + "\xff" * 200 + "def" + "\xff" * 48} else: raise Exception("Wrong page") eeprom_file = EepromFile(MasterCommunicator(read)) address = EepromAddress(1, 0, 3) data = eeprom_file.read([address]) self.assertEquals(1, len(data)) self.assertEquals(address, data[address].address) self.assertEquals("abc", data[address].bytes)
def test_write_multiple_fields(self): """ Test writing multiple fields to the eeprom file. """ done = {} def read(data): """ Read dummy. """ if data["bank"] == 1: done['read1'] = True return {"data": "\xff" * 256} elif data["bank"] == 2: done['read2'] = True return {"data": "\x00" * 256} else: raise Exception("Wrong page") def write(data): """ Write dummy. """ if 'write1' not in done: done['write1'] = True self.assertEquals(1, data["bank"]) self.assertEquals(2, data["address"]) self.assertEquals("abc", data["data"]) elif 'write2' not in done: done['write2'] = True self.assertEquals(2, data["bank"]) self.assertEquals(123, data["address"]) self.assertEquals("More bytes", data["data"]) elif 'write3' not in done: done['write3'] = True self.assertEquals(2, data["bank"]) self.assertEquals(133, data["address"]) self.assertEquals(" than 10", data["data"]) else: raise Exception("Too many writes") communicator = MasterCommunicator(read, write) eeprom_file = EepromFile(communicator) eeprom_file.write([EepromData(EepromAddress(1, 2, 3), "abc"), EepromData(EepromAddress(2, 123, 18), "More bytes than 10")]) self.assertTrue('read1' in done) self.assertTrue('read2' in done) self.assertTrue('write1' in done) self.assertTrue('write2' in done) self.assertTrue('write3' in done)
def test_cache_invalidate(self): """ Test the cache invalidation. """ state = {'count': 0} def read(_): """ Read dummy. """ if state['count'] == 0: state['count'] = 1 return {"data": "\xff" * 256} elif state['count'] == 1: state['count'] = 2 return {"data": "\xff" * 256} else: raise Exception("Too many reads !") communicator = MasterCommunicator(read, None) eeprom_file = EepromFile(communicator) address = EepromAddress(1, 0, 256) read = eeprom_file.read([address]) self.assertEquals("\xff" * 256, read[address].bytes) # Second read should come from cache. address = EepromAddress(1, 0, 256) read = eeprom_file.read([address]) self.assertEquals("\xff" * 256, read[address].bytes) eeprom_file.invalidate_cache() # Should be read from communicator, since cache is invalid address = EepromAddress(1, 0, 256) read = eeprom_file.read([address]) self.assertEquals("\xff" * 256, read[address].bytes) self.assertEquals(2, state['count'])
def test_cache_write(self): """ Test the eeprom cache on writing. """ state = {'read': 0, 'write': 0} def read(_): """ Read dummy. """ if state['read'] == 0: state['read'] = 1 return {"data": "\xff" * 256} else: raise Exception("Too many reads !") def write(data): """ Write dummy. """ if state['write'] == 0: self.assertEquals(1, data["bank"]) self.assertEquals(100, data["address"]) self.assertEquals("\x00" * 10, data["data"]) state['write'] = 1 elif state['write'] == 1: self.assertEquals(1, data["bank"]) self.assertEquals(110, data["address"]) self.assertEquals("\x00" * 10, data["data"]) state['write'] = 2 else: raise Exception("Too many writes !") communicator = MasterCommunicator(read, write) eeprom_file = EepromFile(communicator) address = EepromAddress(1, 0, 256) read = eeprom_file.read([address]) self.assertEquals("\xff" * 256, read[address].bytes) eeprom_file.write([EepromData(EepromAddress(1, 100, 20), "\x00" * 20)]) address = EepromAddress(1, 0, 256) read = eeprom_file.read([address]) self.assertEquals("\xff" * 100 + "\x00" * 20 + "\xff" * 136, read[address].bytes) self.assertEquals(1, state['read']) self.assertEquals(2, state['write'])
def test_write_end_of_page(self): """ Test writing an address that is close (< BATCH_SIZE) to the end of the page. """ done = {} def read(_): """ Read dummy. """ return {"data": "\x00" * 256} def write(data): """ Write dummy. """ self.assertEquals(117, data["bank"]) self.assertEquals(248, data["address"]) self.assertEquals("test\xff\xff\xff\xff", data["data"]) done['done'] = True communicator = MasterCommunicator(read, write) eeprom_file = EepromFile(communicator) eeprom_file.write([EepromData(EepromAddress(117, 248, 8), "test\xff\xff\xff\xff")]) self.assertTrue(done['done'])
def test_write_end_of_page(self): """ Test writing an address that is close (< BATCH_SIZE) to the end of the page. """ done = {} def read(_): """ Read dummy. """ return {"data": "\x00" * 256} def write(data): """ Write dummy. """ self.assertEquals(117, data["bank"]) self.assertEquals(248, data["address"]) self.assertEquals("test\xff\xff\xff\xff", data["data"]) done['done'] = True SetUpTestInjections(master_communicator=MasterCommunicator(read, write)) eeprom_file = EepromFile() eeprom_file.write([EepromData(EepromAddress(117, 248, 8), "test\xff\xff\xff\xff")]) self.assertTrue(done['done'])
def get_module_addresses(module_type): """ Get the addresses for the modules of the given type. :param module_type: the type of the module (O, R, D, I, T, C) :param module_type: chr :returns: A list containing the addresses of the modules (strings of length 4). """ eeprom_file = EepromFile() base_address = EepromAddress(0, 1, 2) no_modules = eeprom_file.read([base_address]) modules = [] no_input_modules = ord(no_modules[base_address].bytes[0]) for i in range(no_input_modules): address = EepromAddress(2 + i, 252, 1) is_can = eeprom_file.read([address])[address].bytes == 'C' address = EepromAddress(2 + i, 0, 4) module = eeprom_file.read([address])[address].bytes if not is_can or module[0] == 'C': modules.append(module) no_output_modules = ord(no_modules[base_address].bytes[1]) for i in range(no_output_modules): address = EepromAddress(33 + i, 0, 4) modules.append(eeprom_file.read([address])[address].bytes) return [module for module in modules if module[0] == module_type]
def test_cache_write_exception(self): """ The cache should be invalidated if a write fails. """ state = {'read': 0, 'write': 0} def read(_): """ Read dummy. """ if state['read'] == 0: state['read'] = 1 return {"data": "\xff" * 256} elif state['read'] == 1: state['read'] = 2 return {"data": "\xff" * 256} else: raise Exception("Too many reads !") def write(_): """ Write dummy. """ state['write'] += 1 raise Exception("write fails...") communicator = MasterCommunicator(read, write) eeprom_file = EepromFile(communicator) address = EepromAddress(1, 0, 256) read = eeprom_file.read([address]) self.assertEquals("\xff" * 256, read[address].bytes) try: eeprom_file.write([EepromData(EepromAddress(1, 100, 20), "\x00" * 20)]) self.fail("Should not get here !") except Exception: pass address = EepromAddress(1, 0, 256) read = eeprom_file.read([address]) self.assertEquals("\xff" * 256, read[address].bytes) self.assertEquals(2, state['read']) self.assertEquals(1, state['write'])
def test_cache(self): """ Test the caching of banks. """ state = { 'count' : 0 } def read(data): """ Read dummy. """ if state['count'] == 0: state['count'] = 1 return {"data" : "\xff" * 256} else: raise Exception("Too many reads !") communicator = MasterCommunicatorDummy(read, None) eeprom_file = EepromFile(communicator) read = eeprom_file.read([EepromAddress(1, 0, 256)]) self.assertEquals("\xff" * 256, read[0].bytes) # Second read should come from cache, if read is called # an exception will be thrown. read = eeprom_file.read([EepromAddress(1, 0, 256)]) self.assertEquals("\xff" * 256, read[0].bytes)
def test_read_one_bank_two_addresses(self): """ Test read from one bank with two addresses. """ def read(_data): """ Read dummy """ if _data["bank"] == 1: return {"data": "abc" + "\xff" * 200 + "def" + "\xff" * 48} else: raise Exception("Wrong page") eeprom_file = EepromFile(MasterCommunicator(read)) address1 = EepromAddress(1, 2, 10) address2 = EepromAddress(1, 203, 4) data = eeprom_file.read([address1, address2]) self.assertEquals(2, len(data)) self.assertEquals(address1, data[address1].address) self.assertEquals("c" + "\xff" * 9, data[address1].bytes) self.assertEquals(address2, data[address2].address) self.assertEquals("def\xff", data[address2].bytes)
def test_write_multiple_fields_same_batch(self): """ Test writing multiple fields to the eeprom file. """ done = {} def read(data): """ Read dummy. """ if data["bank"] == 1: done['read'] = True return {"data": "\xff" * 256} else: raise Exception("Wrong page") def write(data): """ Write dummy. """ if 'write1' not in done: done['write1'] = True self.assertEquals(1, data["bank"]) self.assertEquals(2, data["address"]) self.assertEquals("abc\xff\xff\xffdefg", data["data"]) elif 'write2' not in done: done['write2'] = True self.assertEquals(1, data["bank"]) self.assertEquals(12, data["address"]) self.assertEquals("hijklmn", data["data"]) else: raise Exception("Too many writes") communicator = MasterCommunicator(read, write) eeprom_file = EepromFile(communicator) eeprom_file.write([ EepromData(EepromAddress(1, 2, 3), "abc"), EepromData(EepromAddress(1, 8, 11), "defghijklmn") ]) self.assertTrue('read' in done) self.assertTrue('write1' in done) self.assertTrue('write2' in done)
def test_cache(self): """ Test the caching of banks. """ state = {'count': 0} def read(_): """ Read dummy. """ if state['count'] == 0: state['count'] = 1 return {"data": "\xff" * 256} else: raise Exception("Too many reads !") SetUpTestInjections(master_communicator=MasterCommunicator(read)) eeprom_file = EepromFile() address = EepromAddress(1, 0, 256) read = eeprom_file.read([address]) self.assertEquals("\xff" * 256, read[address].bytes) # Second read should come from cache, if read is called # an exception will be thrown. address = EepromAddress(1, 0, 256) read = eeprom_file.read([address]) self.assertEquals("\xff" * 256, read[address].bytes)
def test_write_multiple_fields_same_batch(self): """ Test writing multiple fields to the eeprom file. """ done = {} def read(data): """ Read dummy. """ if data["bank"] == 1: done['read'] = True return {"data": "\xff" * 256} else: raise Exception("Wrong page") def write(data): """ Write dummy. """ if 'write1' not in done: done['write1'] = True self.assertEquals(1, data["bank"]) self.assertEquals(2, data["address"]) self.assertEquals("abc\xff\xff\xffdefg", data["data"]) elif 'write2' not in done: done['write2'] = True self.assertEquals(1, data["bank"]) self.assertEquals(12, data["address"]) self.assertEquals("hijklmn", data["data"]) else: raise Exception("Too many writes") communicator = MasterCommunicator(read, write) eeprom_file = EepromFile(communicator) eeprom_file.write([EepromData(EepromAddress(1, 2, 3), "abc"), EepromData(EepromAddress(1, 8, 11), "defghijklmn")]) self.assertTrue('read' in done) self.assertTrue('write1' in done) self.assertTrue('write2' in done)
def test_cache(self): """ Test the caching of banks. """ state = {'count': 0} def read(_): """ Read dummy. """ if state['count'] == 0: state['count'] = 1 return {"data": "\xff" * 256} else: raise Exception("Too many reads !") communicator = MasterCommunicator(read, None) eeprom_file = EepromFile(communicator) address = EepromAddress(1, 0, 256) read = eeprom_file.read([address]) self.assertEquals("\xff" * 256, read[address].bytes) # Second read should come from cache, if read is called # an exception will be thrown. address = EepromAddress(1, 0, 256) read = eeprom_file.read([address]) self.assertEquals("\xff" * 256, read[address].bytes)
def get_eeprom_file_dummy(banks): """ Create an EepromFile when the data for all banks is provided. @param banks: list of string of bytes. """ def list(data): """ Dummy for listing a bank. """ return {"data" : banks[data["bank"]]} def write(data): """ Dummy for writing bytes to a bank. """ bank = banks[data["bank"]] address = data["address"] bytes = data["data"] banks[data["bank"]] = bank[0:address] + bytes + bank[address+len(bytes):] return EepromFile(MasterCommunicatorDummy(list, write))
def get_eeprom_file_dummy(banks): """ Create an EepromFile when the data for all banks is provided. :param banks: list of basestring """ def list_fct(data): """ Dummy for listing a bank. """ return {"data": banks[data["bank"]]} def write_fct(data): """ Dummy for writing bytes to a bank. """ bank = banks[data["bank"]] address = data["address"] data_bytes = data["data"] banks[data["bank"]] = bank[0:address] + data_bytes + bank[address+len(data_bytes):] SetUpTestInjections(master_communicator=MasterCommunicator(list_fct, write_fct)) return EepromFile()
def test_cache_write_exception(self): """ The cache should be invalidated if a write fails. """ state = {'read': 0, 'write': 0} def read(_): """ Read dummy. """ if state['read'] == 0: state['read'] = 1 return {"data": "\xff" * 256} elif state['read'] == 1: state['read'] = 2 return {"data": "\xff" * 256} else: raise Exception("Too many reads !") def write(_): """ Write dummy. """ state['write'] += 1 raise Exception("write fails...") communicator = MasterCommunicator(read, write) eeprom_file = EepromFile(communicator) address = EepromAddress(1, 0, 256) read = eeprom_file.read([address]) self.assertEquals("\xff" * 256, read[address].bytes) try: eeprom_file.write( [EepromData(EepromAddress(1, 100, 20), "\x00" * 20)]) self.fail("Should not get here !") except Exception: pass address = EepromAddress(1, 0, 256) read = eeprom_file.read([address]) self.assertEquals("\xff" * 256, read[address].bytes) self.assertEquals(2, state['read']) self.assertEquals(1, state['write'])