#!/usr/bin/env python3.4 # # Copyright 2017 - The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import copy import pprint import time import acts.base_test import acts_contrib.test_utils.wifi.wifi_test_utils as wutils from acts import asserts from acts.test_decorators import test_tracker_info from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest SCAN_TIME = 30 WAIT_TIME = 2 class WifiPreFlightTest(WifiBaseTest): """ Pre-flight checks for Wifi tests. Test Bed Requirement: * One Android device * 4 reference networks - two 2G and two 5G networks * Attenuators to attenuate each reference network Tests: * Check if reference networks show up in wifi scan * Check if attenuators attenuate the correct network """ def setup_class(self): super().setup_class() self.WIFI_2G = "2g" self.WIFI_5G = "5g" self.PASSWORD = "password" self.MIN_SIGNAL_LEVEL = -45 self.dut = self.android_devices[0] wutils.wifi_test_device_init(self.dut) wutils.wifi_toggle_state(self.dut, True) # Get reference networks as a list opt_params = ["reference_networks"] self.unpack_userparams(opt_param_names=opt_params) if "AccessPoint" in self.user_params: self.legacy_configure_ap_and_start(ap_count=2) networks = [] for ref_net in self.reference_networks: networks.append(ref_net[self.WIFI_2G]) networks.append(ref_net[self.WIFI_5G]) self.reference_networks = networks asserts.assert_true( len(self.reference_networks) == 4, "Need at least 4 reference network with psk.") def teardown_class(self): wutils.reset_wifi(self.dut) for a in self.attenuators: a.set_atten(0) if "AccessPoint" in self.user_params: del self.user_params["reference_networks"] del self.user_params["open_network"] """ Helper functions """ def _find_reference_networks_no_attn(self): """ Verify that when ATTN set to 0, all reference networks show up in the scanned results Args: 1. List of reference networks Returns: 1. List of networks not found. Empty if all reference networks are found """ found_networks = copy.deepcopy(self.target_networks) start_time = time.time() while(time.time() < start_time + SCAN_TIME): if not found_networks: break time.sleep(WAIT_TIME) scanned_networks = self.dut.droid.wifiGetScanResults() self.log.info("SCANNED RESULTS %s" % scanned_networks) for net in self.target_networks: if net in found_networks: result = wutils.match_networks(net, scanned_networks) if result and result[0]['level'] > self.MIN_SIGNAL_LEVEL: found_networks.remove(net) elif result: self.log.warn("Signal strength for %s is low: %sdBm" % (net, result[0]['level'])) return found_networks def _find_network_after_setting_attn(self, target_network): """ Find network after setting attenuation Args: 1. target_network to find in the scanned_results Returns: 1. True if a. if max_attn is set and target_network not found 2. False if not """ start_time = time.time() while(time.time() < start_time + SCAN_TIME): time.sleep(WAIT_TIME) scanned_networks = self.dut.droid.wifiGetScanResults() self.log.info("SCANNED RESULTS %s" % scanned_networks) result = wutils.match_networks(target_network, scanned_networks) if not result: return True return False """ Tests """ def test_attenuators(self): """ Test if attenuating a channel, disables the correct reference network Reference networks for each testbed should match attenuators as follows wh_ap1_2g - channel 1 wh_ap1_5g - channel 2 wh_ap2_2g - channel 3 wh_ap2_5g - channel 4 Steps: 1. Set attenuation on each channel to 95 2. Verify that the corresponding network does not show up in the scanned results """ # Set attenuation to 0 and verify reference # networks show up in the scanned results self.log.info("Verify if all reference networks show with " "attenuation set to 0") if getattr(self, "attenuators", []): for a in self.attenuators: a.set_atten(0) self.target_networks = [] for ref_net in self.reference_networks: self.target_networks.append( {'BSSID': ref_net['bssid']} ) result = self._find_reference_networks_no_attn() asserts.assert_true(not result, "Did not find or signal strength too low " "for the following reference networks\n%s\n" % result) # attenuate 1 channel at a time and find the network self.log.info("Verify if attenuation channel matches with " "correct reference network") found_networks = [] for i in range(len(self.attenuators)): target_network = {} target_network['BSSID'] = self.reference_networks[i]['bssid'] # set the attn to max and verify target network is not found self.attenuators[i].set_atten(95) result = self._find_network_after_setting_attn(target_network) if result: target_network['ATTN'] = i found_networks.append(target_network) asserts.assert_true(not found_networks, "Attenuators did not match the networks\n %s\n" % pprint.pformat(found_networks))