class TestMemoryMapping(unittest.TestCase): def setUp(self): cflib.crtp.init_drivers(enable_debug_driver=False) self.test_rig_support = RigSupport() def test_memory_mapping_with_one_cf(self): # Fixture uri = self.test_rig_support.all_uris[0] self.test_rig_support.restart_devices([uri]) cf = Crazyflie(rw_cache='./cache') # Test and Assert with SyncCrazyflie(uri, cf=cf) as scf: self.assert_memory_mapping(scf) def test_memory_mapping_with_all_cfs(self): # Fixture uris = self.test_rig_support.all_uris self.test_rig_support.restart_devices(uris) factory = CachedCfFactory(rw_cache='./cache') # Test and Assert with Swarm(uris, factory=factory) as swarm: swarm.parallel_safe(self.assert_memory_mapping) def assert_memory_mapping(self, scf): mems = scf.cf.mem.get_mems(MemoryElement.TYPE_MEMORY_TESTER) count = len(mems) self.assertEqual(1, count, 'unexpected number of memories found') self.verify_reading_memory_data(mems) self.verify_writing_memory_data(mems, scf) def verify_writing_memory_data(self, mems, scf): self.wrote_data = False scf.cf.param.set_value('memTst.resetW', '1') time.sleep(0.1) mems[0].write_data(5, 1000, self._data_written) while not self.wrote_data: time.sleep(1) log_conf = LogConfig(name='memtester', period_in_ms=100) log_conf.add_variable('memTst.errCntW', 'uint32_t') with SyncLogger(scf, log_conf) as logger: for log_entry in logger: errorCount = log_entry[1]['memTst.errCntW'] self.assertEqual(0, errorCount) break def verify_reading_memory_data(self, mems): self.got_data = False mems[0].read_data(5, 1000, self._data_read) while not self.got_data: time.sleep(1) def _data_read(self, mem): self.got_data = True def _data_written(self, mem, address): self.wrote_data = True
class TestLogging(unittest.TestCase): def setUp(self): cflib.crtp.init_drivers() self.test_rig_support = RigSupport() def test_that_requested_logging_is_received_properly_from_one_cf(self): # Fixture uri = self.test_rig_support.all_uris[0] self.test_rig_support.restart_devices([uri]) cf = Crazyflie(rw_cache='./cache') # Test and Assert with SyncCrazyflie(uri, cf=cf) as scf: self.assert_add_logging_and_get_non_zero_value(scf) def test_that_requested_logging_is_received_properly_from_all_cfs(self): # Fixture uris = self.test_rig_support.all_uris self.test_rig_support.restart_devices(uris) factory = CachedCfFactory(rw_cache='./cache') # Test and Assert with Swarm(uris, factory=factory) as swarm: swarm.parallel_safe(self.assert_add_logging_and_get_non_zero_value) def assert_add_logging_and_get_non_zero_value(self, scf): log_name = 'stabilizer.roll' expected = 0.0 lg_conf = LogConfig(name='SysTest', period_in_ms=10) lg_conf.add_variable(log_name, 'float') with SyncLogger(scf, lg_conf) as logger: for log_entry in logger: actual = log_entry[1][log_name] break self.assertNotAlmostEqual(expected, actual, places=4)
def setUp(self): cflib.crtp.init_drivers() self.test_rig_support = RigSupport()
class TestConnection(unittest.TestCase): def setUp(self): cflib.crtp.init_drivers() self.test_rig_support = RigSupport() def test_that_connection_time_scales_with_more_devices_without_cache(self): # Fixture self.test_rig_support.restart_devices(self.test_rig_support.all_uris) EXPECTED_CONNECTION_TIME = 5 for nr_of_devices in range(1, len(self.test_rig_support.all_uris)): # Test uris = self.test_rig_support.all_uris[:nr_of_devices] start_time = time.time() with Swarm(uris): connected_time = time.time() actual = connected_time - start_time max_expected = EXPECTED_CONNECTION_TIME * nr_of_devices print('Connection time for', nr_of_devices, ':', actual, ', per device:', actual / nr_of_devices) # Assert self.assertLess(actual, max_expected) def test_that_connection_time_scales_with_more_devices_with_cache(self): # Fixture self.test_rig_support.restart_devices(self.test_rig_support.all_uris) # Fill caches first by connecting to all devices factory = CachedCfFactory(rw_cache='./cache') with Swarm(self.test_rig_support.all_uris, factory=factory): pass EXPECTED_CONNECTION_TIME = 1.5 for nr_of_devices in range(1, len(self.test_rig_support.all_uris)): # Test uris = self.test_rig_support.all_uris[:nr_of_devices] start_time = time.time() with Swarm(uris, factory=factory): connected_time = time.time() actual = connected_time - start_time max_expected = EXPECTED_CONNECTION_TIME * nr_of_devices print('Connection time for', nr_of_devices, ':', actual, ', per device:', actual / nr_of_devices) # Assert self.assertLess(actual, max_expected) def test_that_all_devices_are_restarted(self): # Fixture uris = self.test_rig_support.all_uris # Test # Assert self.test_rig_support.restart_devices(uris) def test_that_all_devices_are_restarted_multiple_times(self): # Fixture uris = self.test_rig_support.all_uris # Test # Assert for i in range(10): self.test_rig_support.restart_devices(uris) def test_that_the_same_cf_object_can_be_connected_multiple_times(self): # Fixture self.test_rig_support.restart_devices(self.test_rig_support.all_uris) cf = Crazyflie(rw_cache='./cache') # Test for uri in self.test_rig_support.all_uris: with SyncCrazyflie(uri, cf=cf): pass
def setUp(self): cflib.crtp.init_drivers(enable_debug_driver=False) self.test_rig_support = RigSupport() self.links = []
class TestResponseTime(unittest.TestCase): ECHO = 0 def setUp(self): cflib.crtp.init_drivers(enable_debug_driver=False) self.test_rig_support = RigSupport() self.links = [] def tearDown(self): for link in self.links: link.close() self.links = [] def test_response_time_to_one_cf(self): # Fixture uri = self.test_rig_support.all_uris[0] self.test_rig_support.restart_devices([uri]) link = self.connect_link(uri) seq_nr = 47 expected_max_response_time = 0.01 # Test time_send_echo = time.time() self.request_echo_with_seq_nr(link, seq_nr) response_timestamps = self.assert_wait_for_all_seq_nrs([link], seq_nr) response_time = response_timestamps[uri] - time_send_echo # Assert self.assertLess(response_time, expected_max_response_time) def test_response_time_to_all_cfs(self): # Fixture uris = self.test_rig_support.all_uris self.test_rig_support.restart_devices(uris) for uri in uris: self.connect_link(uri) seq_nr = 47 expected_max_response_time = 0.1 expected_mean_response_time = 0.05 # Test time_send_echo = time.time() for link in self.links: self.request_echo_with_seq_nr(link, seq_nr) response_timestamps = self.assert_wait_for_all_seq_nrs( self.links, seq_nr) # Assert response_times = {} for uri, response_time in response_timestamps.items(): response_times[uri] = response_time - time_send_echo times = response_times.values() max_time = max(times) mean_time = float(sum(times)) / len(times) # print(max_time, mean_time, times) self.assertLess(max_time, expected_max_response_time) self.assertLess(mean_time, expected_mean_response_time) def request_echo_with_seq_nr(self, link, seq_nr): pk = CRTPPacket() pk.set_header(CRTPPort.LINKCTRL, self.ECHO) pk.data = (seq_nr, ) link.send_packet(pk) def assert_wait_for_all_seq_nrs(self, links, seq_nr, timeout=1): NO_BLOCKING = -1 time_end = time.time() + timeout response_timestamps = {} while time.time() < time_end: for link in links: if link.uri not in response_timestamps: response = link.receive_packet(time=NO_BLOCKING) if self._is_response_correct_seq_nr(response, seq_nr): response_timestamps[link.uri] = time.time() if len(response_timestamps) == len(self.links): return response_timestamps time.sleep(0.001) self.fail('Time out while waiting for seq nrs.') def _is_response_correct_seq_nr(self, response, seq_nr): if response is not None: if response._get_channel() == self.ECHO and \ response._get_port() == CRTPPort.LINKCTRL: received_seq = response._get_data_t()[0] if received_seq == seq_nr: return True return False def connect_link(self, uri): link = cflib.crtp.get_link_driver(uri, self._link_quality_cb, self._link_error_cb) self.assertIsNotNone(link) self.links.append(link) return link def _link_quality_cb(self, percentage): pass def _link_error_cb(self, errmsg): self.fail(errmsg)