def create_link(self, source, sink):
"""Creates a widget link for two audio widgets.
@param source: An AudioWidget.
@param sink: An AudioWidget.
@returns: An object of WidgetLink's subclass.
@raises: AudioLinkFactoryError if there is no link between
source and sink.
"""
# Finds the available link types from LINK_TABLE.
link_type = self.LINK_TABLE.get((source.port_id, sink.port_id), None)
if not link_type:
raise AudioLinkFactoryError('No supported link between %s and %s' %
(source.port_id, sink.port_id))
# There is only one dedicated HDMI cable, just use it.
if link_type == audio_widget_link.HDMIWidgetLink:
link = audio_widget_link.HDMIWidgetLink(self._cros_host)
# Acquires audio bus if there is available bus.
# Creates a bus of AudioBusLink's subclass that is more
# specific than AudioBusLink.
# Controls this link using AudioBus object obtained from AudioBoard
# object.
elif issubclass(link_type, audio_widget_link.AudioBusLink):
bus_index = self._acquire_audio_bus_index()
link = link_type(self._audio_board.get_audio_bus(bus_index))
self._audio_bus_links[bus_index] = link
elif issubclass(link_type, audio_widget_link.BluetoothWidgetLink):
# To connect bluetooth adapter on Cros device to bluetooth module on
# chameleon board, we need to access bluetooth adapter on Cros host
# using BluetoothDevice, and access bluetooth module on
# audio board using BluetoothController.
# Initializes a BluetoothDevice object if needed. And reuse this
# object for future bluetooth link usage.
if not self._bluetooth_device:
self._bluetooth_device = bluetooth_device.BluetoothDevice(
self._cros_host)
link = link_type(
self._bluetooth_device,
self._chameleon_board.get_bluetooth_ref_controller(),
self._chameleon_board.get_bluetooth_a2dp_sink().
GetLocalBluetoothAddress())
elif issubclass(link_type, audio_widget_link.USBWidgetLink):
# Aside from managing connection between USB audio gadget driver on
# Chameleon with Cros device, USBWidgetLink also handles changing
# the gadget driver's configurations, through the USBController that
# is passed to it at initialization.
if not self._usb_ctrl:
self._usb_ctrl = self._chameleon_board.get_usb_controller()
link = link_type(self._usb_ctrl)
else:
raise NotImplementedError('Link %s is not implemented' % link_type)
return link
def warmup(self, device_host, tester_host, interactive=False):
"""Initialize the test member objects based on its arguments."""
if interactive:
self.interactive = interactive_client.InteractiveClient(
device_host)
else:
self.interactive = None
self.device = bluetooth_device.BluetoothDevice(device_host)
if tester_host:
self.tester = bluetooth_tester.BluetoothTester(tester_host)
else:
self.tester = None
def run_once(self, host):
"""Test body."""
start_time = time.time()
# Prepare Bluetooth to scan, but do not start yet.
bt_device = bluetooth_device.BluetoothDevice(host)
if not bt_device.reset_on():
raise error.TestFail('DUT could not be reset to initial state')
for ap_config in self._ap_configs:
# Set up the router and associate the client with it.
self.context.configure(ap_config)
if ap_config.is_11ac and not self.context.client.is_vht_supported(
):
raise error.TestNAError('Client does not have AC support')
assoc_params = xmlrpc_datatypes.AssociationParameters(
ssid=self.context.router.get_ssid(),
security_config=ap_config.security_config)
self.context.assert_connect_wifi(assoc_params)
session = netperf_session.NetperfSession(self.context.client,
self.context.router)
# Warmup the wifi path and measure signal.
session.warmup_stations()
ap_config_tag = ap_config.perf_loggable_description
for config in self.NETPERF_CONFIGS:
self.test_one(session, config, ap_config_tag, 'BT_quiet')
if not bt_device.start_discovery():
raise error.TestFail('Could not start discovery on DUT')
try:
self.test_one(session, config, ap_config_tag,
'BT_scanning')
finally:
if not bt_device.stop_discovery():
logging.warning('Failed to stop discovery on DUT')
self.test_one(session, config, ap_config_tag, 'BT_quiet_again')
# Clean up router and client state for the next run.
self.context.client.shill.disconnect(
self.context.router.get_ssid())
self.context.router.deconfig()
end_time = time.time()
logging.info('Running time %0.1f seconds.', end_time - start_time)