def test_intf_blink(can_in_interface): """Verify LEDs can be blinked. Since we don't have a camera watching the LEDs, we can at least test if we are having an impact by checking - `ENABLE` works anytime except a session is in use - `DISABLE` always works Sleeps are in place in case this in case a visual confirmation is possible by the developer. """ with system.System() as sys: intfs = list(sys.intf_refs_all) in_intfs = [intf for intf in intfs if intf == can_in_interface] assert len(in_intfs) == 1, "Pre-requisite failed" in_intf = in_intfs[0] # Smoke-test the function calls in_intf.blink(constants.BlinkMode.ENABLE) time.sleep(0.01) in_intf.blink(constants.BlinkMode.DISABLE) time.sleep(0.01) with nixnet.FrameInStreamSession(can_in_interface) as input_session: input_session.intf.baud_rate = 125000 input_session.start() with pytest.raises(errors.XnetError) as excinfo: in_intf.blink(constants.BlinkMode.ENABLE) assert excinfo.value.error_type == constants.Err.PORT_LEDS_BUSY in_intf.blink(constants.BlinkMode.DISABLE) in_intf.blink(constants.BlinkMode.ENABLE) in_intf.blink(constants.BlinkMode.DISABLE)
def test_intf_properties(can_in_interface): """Verify Interface properties. Ideally we'd match these against a known piece of hardware to ensure the correct values are being returned. That makes it hard though for someone to run these tests with any piece of hardware. For now, we'll just verify the calls don't call catastrophically and someone can always run py.test with ``-s``_. """ with system.System() as sys: intfs = list(sys.intf_refs_all) in_intfs = [intf for intf in intfs if intf == can_in_interface] assert len(in_intfs) == 1, "Pre-requisite failed" in_intf = in_intfs[0] print(in_intf.num) assert str(in_intf).endswith(str(in_intf.num)) print(in_intf.port_num) print(in_intf.protocol) print(in_intf.can_term_cap) print(in_intf.can_tcvr_cap) print(in_intf.dongle_state) print(in_intf.dongle_id) if in_intf.dongle_id not in [ constants.DongleId.DONGLE_LESS, constants.DongleId.UNKNOWN ]: print(in_intf.dongle_revision) print(in_intf.dongle_firmware_version) print(in_intf.dongle_compatible_revision) print(in_intf.dongle_compatible_firmware_version)
def test_system_intf_refs_superset(can_in_interface, can_out_interface): with system.System() as sys: intfs = set(sys.intf_refs_all) can_intfs = set(sys.intf_refs_can) flex_ray_intfs = set(sys.intf_refs_flex_ray) lin_intfs = set(sys.intf_refs_lin) assert intfs == can_intfs | flex_ray_intfs | lin_intfs
def test_device_properties(can_in_interface): """Verify Device properties. Ideally we'd match these against a known piece of hardware to ensure the correct values are being returned. That makes it hard though for someone to run these tests with any piece of hardware for most properties. For now, we'll just verify the calls don't call catastrophically and someone can always run py.test with ``-s``_. For ``int_refs_all``, we can at least make sure that one device reports ``can_in_interface``_. """ with system.System() as sys: devs = list(sys.dev_refs) assert 0 < len(devs), "Pre-requisite failed" for dev in devs: in_intfs = [ intf for intf in dev.intf_refs_all if intf == can_in_interface ] if len(in_intfs) == 1: break else: raise RuntimeError( "Pre-requisite failed: can't find device for interface") intf_refs_all = set(dev.intf_refs_all) intf_refs = set(dev.intf_refs) assert intf_refs_all.issuperset(intf_refs) print(dev.form_fac) print(dev.num_ports) print(dev.product_name) print(dev.product_num) assert str(dev.product_num) in dev.product_name print(dev.ser_num) print(dev.slot_num) print(dev.num_ports_all)
def test_databases_container(custom_database_path): with system.System() as sys: print(repr(sys.databases)) print(list(sys.databases)) assert len(sys.databases) == len(list(sys.databases)) keys = list(sys.databases.keys()) values = list(sys.databases.values()) items = list(sys.databases.items()) assert len(sys.databases) == len(keys) assert len(sys.databases) == len(values) assert len(sys.databases) == len(items) assert list(sys.databases) == keys assert items == list(zip(keys, values)) for database in sys.databases.values(): print(repr(database)) assert database.alias in sys.databases new_database = sys.databases[database.alias] assert new_database.alias == database.alias assert new_database.filepath == database.filepath with pytest.raises(KeyError): sys.databases["____unlikely to ever exist_____"] unsupported_type = [] with pytest.raises(TypeError): sys.databases[unsupported_type]
def test_system_container(): with system.System() as sys_one: with system.System() as sys_two: assert sys_one == sys_one assert not (sys_one == sys_two) assert not (sys_one == 1) assert not (sys_one != sys_one) assert sys_one != sys_two assert sys_one != 1 print(hash(sys_one)) print(repr(sys_one)) with pytest.warns(errors.XnetResourceWarning): sys_one.close()
def test_system_collection_equality(): with system.System() as sys: print(hash(sys.dev_refs)) assert sys.dev_refs == sys.dev_refs assert not (sys.dev_refs != sys.dev_refs) assert not (sys.dev_refs == "Hello") assert sys.dev_refs != "Hello"
def test_intf_container(nixnet_in_interface): with system.System() as sys: intfs = set(sys.intf_refs_all) in_intfs = [intf for intf in intfs if intf == nixnet_in_interface] assert len(in_intfs) == 1 in_intf = in_intfs[0] assert str(in_intf) == nixnet_in_interface
def test_system_properties(): """Verify System properties. These are pretty transient and can't easily be verified against known good values. For now, we'll just verify the calls don't call catastrophically and someone can always run py.test with ``-s``_. """ with system.System() as sys: print(sys.ver)
def _detect_available_configs(): configs = [] nixnet_system = system.System() for can_intf in nixnet_system.intf_refs_can: logger.info("Channel index %d: %s", can_intf.port_num, str(can_intf)) configs.append( { "interface": "nixnet", "channel": str(can_intf), "can_term_available": can_intf.can_term_cap == constants.CanTermCap.YES, } ) nixnet_system.close() return configs
def test_device_container(): with system.System() as sys: devs = list(sys.dev_refs) assert 0 < len(devs), "Pre-requisite failed" dev = devs[0] assert dev == dev assert not (dev == 100) assert not (dev != dev) assert dev != 100 set([dev]) # Testing `__hash__` print(repr(dev))
def test_databases_modify(custom_database_path): with system.System() as sys: database_alias = 'test_database' default_baud_rate = 750000 assert database_alias not in sys.databases # pre-req initial_alias_len = len(sys.databases) sys.databases.add_alias(database_alias, custom_database_path, default_baud_rate) assert database_alias in sys.databases assert len(sys.databases) == (initial_alias_len + 1) print(sys.databases['test_database'].filepath) del sys.databases['test_database'] assert database_alias not in sys.databases # pre-req assert len(sys.databases) == initial_alias_len
def test_databases_equality(custom_database_path): with system.System() as sys: print(hash(sys.databases)) assert sys.databases == sys.databases assert not (sys.databases != sys.databases) assert not (sys.databases == "Hello") assert sys.databases != "Hello" for database in sys.databases.values(): print(hash(database)) assert database == database assert not (database != database) assert not (database == "Hello") assert database != "Hello"
def test_intf_container(can_in_interface): with system.System() as sys: intfs = list(sys.intf_refs_all) in_intfs = [intf for intf in intfs if intf == can_in_interface] assert len(in_intfs) == 1 in_intf = in_intfs[0] assert str(in_intf) == can_in_interface assert in_intf == can_in_interface assert in_intf == in_intf assert not (in_intf == 100) assert not (in_intf != can_in_interface) assert not (in_intf != in_intf) assert in_intf != "<Invalid>" assert in_intf != 100 set([in_intf]) # Testing `__hash__` print(repr(in_intf))
def _detect_available_configs(): configs = [] try: with system.System() as nixnet_system: for interface in nixnet_system.intf_refs_can: cahnnel = str(interface) logger.debug("Found channel index %d: %s", interface.port_num, cahnnel) configs.append({ "interface": "nixnet", "channel": cahnnel, "can_term_available": interface.can_term_cap == constants.CanTermCap.YES, }) except XnetError as error: logger.debug("An error occured while searching for configs: %s", str(error)) return configs
def test_system_intf_refs_all_superset(can_in_interface, can_out_interface): with system.System() as sys: intfs_all = set(sys.intf_refs_all) intfs = set(sys.intf_refs) assert intfs_all.issuperset(intfs)
def test_device_container(): with system.System() as sys: devs = list(sys.dev_refs) assert 0 < len(devs), "Pre-requisite failed" dev = devs[0] assert dev == str(dev)
def test_system_collection(can_in_interface, can_out_interface): with system.System() as sys: print(repr(sys.dev_refs)) print(list(sys.dev_refs)) assert len(sys.dev_refs) == len(list(sys.dev_refs))