def run_iperf_single_ndp_aware_only(self, use_ib, results):
"""Measure iperf performance on a single NDP, with Aware enabled and no
infrastructure connection - i.e. device is not associated to an AP.
Args:
use_ib: True to use in-band discovery, False to use out-of-band discovery.
results: Dictionary into which to place test results.
"""
init_dut = self.android_devices[0]
resp_dut = self.android_devices[1]
if use_ib:
# note: Publisher = Responder, Subscribe = Initiator
(resp_req_key, init_req_key, resp_aware_if, init_aware_if,
resp_ipv6, init_ipv6) = autils.create_ib_ndp(
resp_dut, init_dut,
autils.create_discovery_config(
self.SERVICE_NAME, aconsts.PUBLISH_TYPE_UNSOLICITED),
autils.create_discovery_config(
self.SERVICE_NAME, aconsts.SUBSCRIBE_TYPE_PASSIVE),
self.device_startup_offset)
else:
(init_req_key, resp_req_key, init_aware_if, resp_aware_if,
init_ipv6, resp_ipv6) = autils.create_oob_ndp(init_dut, resp_dut)
self.log.info("Interface names: I=%s, R=%s", init_aware_if,
resp_aware_if)
self.log.info("Interface addresses (IPv6): I=%s, R=%s", init_ipv6,
resp_ipv6)
# Run iperf3
result, data = init_dut.run_iperf_server("-D")
asserts.assert_true(result, "Can't start iperf3 server")
result, data = resp_dut.run_iperf_client(
"%s%%%s" % (init_ipv6, resp_aware_if), "-6 -J")
self.log.debug(data)
asserts.assert_true(result,
"Failure starting/running iperf3 in client mode")
self.log.debug(pprint.pformat(data))
# clean-up
resp_dut.droid.connectivityUnregisterNetworkCallback(resp_req_key)
init_dut.droid.connectivityUnregisterNetworkCallback(init_req_key)
# Collect results
data_json = json.loads("".join(data))
if "error" in data_json:
asserts.fail("iperf run failed: %s" % data_json["error"],
extras=data_json)
results["tx_rate"] = data_json["end"]["sum_sent"]["bits_per_second"]
results["rx_rate"] = data_json["end"]["sum_received"][
"bits_per_second"]
self.log.info("iPerf3: Sent = %d bps Received = %d bps",
results["tx_rate"], results["rx_rate"])
def run_infra_assoc_oob_ndp_stress(self, with_ndp_traffic):
"""Validates that Wi-Fi Aware NDP does not interfere with infrastructure
(AP) association.
Test assumes (and verifies) that device is already associated to an AP.
Args:
with_ndp_traffic: True to run traffic over the NDP.
"""
init_dut = self.android_devices[0]
resp_dut = self.android_devices[1]
# check that associated and start tracking
init_dut.droid.wifiStartTrackingStateChange()
resp_dut.droid.wifiStartTrackingStateChange()
asserts.assert_true(self.is_associated(init_dut),
"DUT is not associated to an AP!")
asserts.assert_true(self.is_associated(resp_dut),
"DUT is not associated to an AP!")
# set up NDP
(init_req_key, resp_req_key, init_aware_if, resp_aware_if, init_ipv6,
resp_ipv6) = autils.create_oob_ndp(init_dut, resp_dut)
self.log.info("Interface names: I=%s, R=%s", init_aware_if,
resp_aware_if)
self.log.info("Interface addresses (IPv6): I=%s, R=%s", init_ipv6,
resp_ipv6)
# wait for any disassociation change events
q = queue.Queue()
init_thread = threading.Thread(target=self.wait_for_disassociation,
args=(q, init_dut))
resp_thread = threading.Thread(target=self.wait_for_disassociation,
args=(q, resp_dut))
init_thread.start()
resp_thread.start()
any_disassociations = False
try:
q.get(True, self.TEST_DURATION_SECONDS)
any_disassociations = True # only happens on any disassociation
except queue.Empty:
pass
finally:
# TODO: no way to terminate thread (so even if we fast fail we still have
# to wait for the full timeout.
init_dut.droid.wifiStopTrackingStateChange()
resp_dut.droid.wifiStopTrackingStateChange()
asserts.assert_false(any_disassociations,
"Wi-Fi disassociated during test run")
def test_ping6_oob(self):
"""Validate that ping6 works correctly on an NDP created using OOB (out-of
band) discovery"""
init_dut = self.android_devices[0]
resp_dut = self.android_devices[1]
# create NDP
(init_req_key, resp_req_key, init_aware_if, resp_aware_if, init_ipv6,
resp_ipv6) = autils.create_oob_ndp(init_dut, resp_dut)
self.log.info("Interface names: I=%s, R=%s", init_aware_if,
resp_aware_if)
self.log.info("Interface addresses (IPv6): I=%s, R=%s", init_ipv6,
resp_ipv6)
# run ping6
self.run_ping6(init_dut, resp_ipv6, init_aware_if)
self.run_ping6(resp_dut, init_ipv6, resp_aware_if)
# clean-up
resp_dut.droid.connectivityUnregisterNetworkCallback(resp_req_key)
init_dut.droid.connectivityUnregisterNetworkCallback(init_req_key)
def test_nsd_oob(self):
"""Validate that NSD (mDNS) works correctly on an NDP created using OOB
(out-of band) discovery"""
init_dut = self.android_devices[0]
resp_dut = self.android_devices[1]
# create NDP
(init_req_key, resp_req_key, init_aware_if, resp_aware_if, init_ipv6,
resp_ipv6) = autils.create_oob_ndp(init_dut, resp_dut)
self.log.info("Interface names: I=%s, R=%s", init_aware_if,
resp_aware_if)
self.log.info("Interface addresses (IPv6): I=%s, R=%s", init_ipv6,
resp_ipv6)
# run NSD
nsd_service_info = {
"serviceInfoServiceName": "sl4aTestAwareNsd",
"serviceInfoServiceType": "_simple-tx-rx._tcp.",
"serviceInfoPort": 2257
}
nsd_reg = None
nsd_discovery = None
try:
# Initiator registers an NSD service
nsd_reg = init_dut.droid.nsdRegisterService(nsd_service_info)
event_nsd = autils.wait_for_event_with_keys(
init_dut, nconsts.REG_LISTENER_EVENT, autils.EVENT_TIMEOUT,
(nconsts.REG_LISTENER_CALLBACK,
nconsts.REG_LISTENER_EVENT_ON_SERVICE_REGISTERED))
self.log.info("Initiator %s: %s",
nconsts.REG_LISTENER_EVENT_ON_SERVICE_REGISTERED,
event_nsd["data"])
# Responder starts an NSD discovery
nsd_discovery = resp_dut.droid.nsdDiscoverServices(
nsd_service_info[nconsts.NSD_SERVICE_INFO_SERVICE_TYPE])
event_nsd = autils.wait_for_event_with_keys(
resp_dut, nconsts.DISCOVERY_LISTENER_EVENT,
autils.EVENT_TIMEOUT,
(nconsts.DISCOVERY_LISTENER_DATA_CALLBACK,
nconsts.DISCOVERY_LISTENER_EVENT_ON_SERVICE_FOUND))
self.log.info("Responder %s: %s",
nconsts.DISCOVERY_LISTENER_EVENT_ON_SERVICE_FOUND,
event_nsd["data"])
# Responder resolves IP address of Initiator from NSD service discovery
resp_dut.droid.nsdResolveService(event_nsd["data"])
event_nsd = autils.wait_for_event_with_keys(
resp_dut, nconsts.RESOLVE_LISTENER_EVENT, autils.EVENT_TIMEOUT,
(nconsts.RESOLVE_LISTENER_DATA_CALLBACK,
nconsts.RESOLVE_LISTENER_EVENT_ON_SERVICE_RESOLVED))
self.log.info("Responder %s: %s",
nconsts.RESOLVE_LISTENER_EVENT_ON_SERVICE_RESOLVED,
event_nsd["data"])
# mDNS returns first character as '/' - strip
# out to get clean IPv6
init_ipv6_nsd = event_nsd["data"][
nconsts.NSD_SERVICE_INFO_HOST][1:]
asserts.assert_equal(
init_ipv6, init_ipv6_nsd,
"Initiator's IPv6 address obtained through NSD doesn't match!?"
)
finally:
# Stop NSD
if nsd_reg is not None:
init_dut.droid.nsdUnregisterService(nsd_reg)
if nsd_discovery is not None:
resp_dut.droid.nsdStopServiceDiscovery(nsd_discovery)
# clean-up
resp_dut.droid.connectivityUnregisterNetworkCallback(resp_req_key)
init_dut.droid.connectivityUnregisterNetworkCallback(init_req_key)
def test_ping6_oob_max_ndp(self):
"""Validate that ping6 works correctly on multiple NDPs brought up
concurrently. Uses the capability of the device to determine the max
number of NDPs to set up.
Note: the test requires MAX_NDP + 1 devices to be validated. If these are
not available the test will fail."""
dut = self.android_devices[0]
# get max NDP: using first available device (assumes all devices are the
# same)
max_ndp = dut.aware_capabilities[aconsts.CAP_MAX_NDP_SESSIONS]
asserts.assert_true(
len(self.android_devices) > max_ndp,
'Needed %d devices to run the test, have %d' %
(max_ndp + 1, len(self.android_devices)))
# create all NDPs
dut_aware_if = None
dut_ipv6 = None
peers_aware_ifs = []
peers_ipv6s = []
dut_requests = []
peers_requests = []
for i in range(max_ndp):
(init_req_key, resp_req_key, init_aware_if, resp_aware_if,
init_ipv6,
resp_ipv6) = autils.create_oob_ndp(dut,
self.android_devices[i + 1])
self.log.info("Interface names: I=%s, R=%s", init_aware_if,
resp_aware_if)
self.log.info("Interface addresses (IPv6): I=%s, R=%s", init_ipv6,
resp_ipv6)
dut_requests.append(init_req_key)
peers_requests.append(resp_req_key)
if dut_aware_if is None:
dut_aware_if = init_aware_if
else:
asserts.assert_equal(
dut_aware_if, init_aware_if,
"DUT (Initiator) interface changed on subsequent NDPs!?")
if dut_ipv6 is None:
dut_ipv6 = init_ipv6
else:
asserts.assert_equal(
dut_ipv6, init_ipv6,
"DUT (Initiator) IPv6 changed on subsequent NDPs!?")
peers_aware_ifs.append(resp_aware_if)
peers_ipv6s.append(resp_ipv6)
# run ping6
for i in range(max_ndp):
self.run_ping6(dut, peers_ipv6s[i], dut_aware_if)
self.run_ping6(self.android_devices[i + 1], dut_ipv6,
peers_aware_ifs[i])
# cleanup
for i in range(max_ndp):
dut.droid.connectivityUnregisterNetworkCallback(dut_requests[i])
self.android_devices[
i + 1].droid.connectivityUnregisterNetworkCallback(
peers_requests[i])
def run_iperf_max_ndp_aware_only(self, results):
"""Measure iperf performance on the max number of concurrent OOB NDPs, with
Aware enabled and no infrastructure connection - i.e. device is not
associated to an AP.
Note: the test requires MAX_NDP + 1 devices to be validated. If these are
not available the test will fail.
Args:
results: Dictionary into which to place test results.
"""
dut = self.android_devices[0]
# get max NDP: using first available device (assumes all devices are the
# same)
max_ndp = dut.aware_capabilities[aconsts.CAP_MAX_NDP_SESSIONS]
asserts.assert_true(
len(self.android_devices) > max_ndp,
'Needed %d devices to run the test, have %d' %
(max_ndp + 1, len(self.android_devices)))
# create all NDPs
dut_aware_if = None
dut_ipv6 = None
peers_aware_ifs = []
peers_ipv6s = []
dut_requests = []
peers_requests = []
for i in range(max_ndp):
(init_req_key, resp_req_key, init_aware_if, resp_aware_if,
init_ipv6,
resp_ipv6) = autils.create_oob_ndp(dut,
self.android_devices[i + 1])
self.log.info("Interface names: I=%s, R=%s", init_aware_if,
resp_aware_if)
self.log.info("Interface addresses (IPv6): I=%s, R=%s", init_ipv6,
resp_ipv6)
dut_requests.append(init_req_key)
peers_requests.append(resp_req_key)
if dut_aware_if is None:
dut_aware_if = init_aware_if
else:
asserts.assert_equal(
dut_aware_if, init_aware_if,
"DUT (Initiator) interface changed on subsequent NDPs!?")
if dut_ipv6 is None:
dut_ipv6 = init_ipv6
else:
asserts.assert_equal(
dut_ipv6, init_ipv6,
"DUT (Initiator) IPv6 changed on subsequent NDPs!?")
peers_aware_ifs.append(resp_aware_if)
peers_ipv6s.append(resp_ipv6)
# create threads, start them, and wait for all to finish
base_port = 5000
q = queue.Queue()
threads = []
for i in range(max_ndp):
threads.append(
threading.Thread(target=self.run_iperf,
args=(q, dut, self.android_devices[i + 1],
peers_aware_ifs[i], dut_ipv6,
base_port + i)))
for thread in threads:
thread.start()
for thread in threads:
thread.join()
# cleanup
for i in range(max_ndp):
dut.droid.connectivityUnregisterNetworkCallback(dut_requests[i])
self.android_devices[
i + 1].droid.connectivityUnregisterNetworkCallback(
peers_requests[i])
# collect data
for i in range(max_ndp):
results[i] = {}
result, data = q.get()
asserts.assert_true(
result, "Failure starting/running iperf3 in client mode")
self.log.debug(pprint.pformat(data))
data_json = json.loads("".join(data))
if "error" in data_json:
asserts.fail("iperf run failed: %s" % data_json["error"],
extras=data_json)
results[i]["tx_rate"] = data_json["end"]["sum_sent"][
"bits_per_second"]
results[i]["rx_rate"] = data_json["end"]["sum_received"][
"bits_per_second"]
self.log.info("iPerf3: Sent = %d bps Received = %d bps",
results[i]["tx_rate"], results[i]["rx_rate"])