1#!/usr/bin/env python3.4 2# 3# Copyright 2016 - The Android Open Source Project 4# 5# Licensed under the Apache License, Version 2.0 (the "License"); 6# you may not use this file except in compliance with the License. 7# You may obtain a copy of the License at 8# 9# http://www.apache.org/licenses/LICENSE-2.0 10# 11# Unless required by applicable law or agreed to in writing, software 12# distributed under the License is distributed on an "AS IS" BASIS, 13# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14# See the License for the specific language governing permissions and 15# limitations under the License. 16 17import time 18 19from acts import asserts 20from acts import base_test 21from acts.test_utils.wifi import wifi_test_utils as wutils 22 23WifiEnums = wutils.WifiEnums 24NETWORK_ID_ERROR = "Network don't have ID" 25NETWORK_ERROR = "Device is not connected to reference network" 26 27 28class WifiNewSetupAutoJoinTest(base_test.BaseTestClass): 29 def __init__(self, controllers): 30 base_test.BaseTestClass.__init__(self, controllers) 31 self.tests = ("test_autojoin_out_of_range", 32 "test_autojoin_Ap1_2g", 33 "test_autojoin_Ap1_2gto5g", 34 "test_autojoin_in_AP1_5gto2g", 35 "test_autojoin_swtich_AP1toAp2", 36 "test_autojoin_Ap2_2gto5g", 37 "test_autojoin_Ap2_5gto2g", 38 "test_autojoin_out_of_range", 39 "test_autojoin_Ap2_2g", 40 "test_autojoin_Ap2_2gto5g", 41 "test_autojoin_in_Ap2_5gto2g", 42 "test_autojoin_swtich_AP2toAp1", 43 "test_autojoin_Ap1_2gto5g", 44 "test_autojoin_Ap1_5gto2g", 45 "test_autojoin_swtich_to_blacklist_AP", 46 "test_autojoin_in_blacklist_AP", 47 "test_autojoin_back_from_blacklist_AP", ) 48 49 def setup_class(self): 50 """It will setup the required dependencies from config file and configure 51 the required networks for auto-join testing. Configured networks will 52 not be removed. If networks are already configured it will skip 53 configuring the networks 54 55 Returns: 56 True if successfully configured the requirements for testing. 57 """ 58 self.dut = self.android_devices[0] 59 wutils.wifi_test_device_init(self.dut) 60 req_params = ("reference_networks", "other_network", "atten_val", 61 "ping_addr", "max_bugreports") 62 self.unpack_userparams(req_params) 63 self.log.debug("Connect networks :: {}".format(self.other_network)) 64 configured_networks = self.dut.droid.wifiGetConfiguredNetworks() 65 self.log.debug("Configured networks :: {}".format(configured_networks)) 66 count_confnet = 0 67 result = False 68 if self.reference_networks[0]['2g']['ssid'] == self.reference_networks[ 69 0]['5g']['ssid']: 70 self.ref_ssid_count = 1 71 else: 72 self.ref_ssid_count = 2 # Different SSID for 2g and 5g 73 for confnet in configured_networks: 74 if confnet[WifiEnums.SSID_KEY] == self.reference_networks[0]['2g'][ 75 'ssid']: 76 count_confnet += 1 77 elif confnet[WifiEnums.SSID_KEY] == self.reference_networks[0][ 78 '5g']['ssid']: 79 count_confnet += 1 80 self.log.info("count_confnet {}".format(count_confnet)) 81 if count_confnet == self.ref_ssid_count: 82 return 83 else: 84 self.log.info("Configured networks for testing") 85 self.attenuators[0].set_atten(0) 86 self.attenuators[1].set_atten(0) 87 self.attenuators[2].set_atten(90) 88 self.attenuators[3].set_atten(90) 89 wait_time = 15 90 self.dut.droid.wakeLockAcquireBright() 91 self.dut.droid.wakeUpNow() 92 try: 93 self.dut.droid.wifiPriorityConnect(self.reference_networks[0][ 94 '2g']) 95 connect_result = self.dut.ed.pop_event( 96 "WifiManagerPriorityConnectOnSuccess", 1) 97 self.log.info(connect_result) 98 time.sleep(wait_time) 99 if self.ref_ssid_count == 2: #add 5g network as well 100 self.dut.droid.wifiPriorityConnect(self.reference_networks[ 101 0]['5g']) 102 connect_result = self.dut.ed.pop_event( 103 "WifiManagerPriorityConnectOnSuccess", 1) 104 self.log.info(connect_result) 105 time.sleep(wait_time) 106 self.dut.droid.wifiPriorityConnect(self.other_network) 107 connect_result = self.dut.ed.pop_event( 108 "WifiManagerPriorityConnectOnSuccess") 109 self.log.info(connect_result) 110 wutils.track_connection(self.dut, self.other_network["ssid"], 1) 111 wutils.wifi_forget_network(self.dut, self.other_network["ssid"]) 112 time.sleep(wait_time) 113 current_network = self.dut.droid.wifiGetConnectionInfo() 114 self.log.info("Current network: {}".format(current_network)) 115 asserts.assert_true('network_id' in current_network, 116 NETWORK_ID_ERROR) 117 asserts.assert_true(current_network['network_id'] >= 0, 118 NETWORK_ERROR) 119 finally: 120 self.dut.droid.wifiLockRelease() 121 self.dut.droid.goToSleepNow() 122 123 def check_connection(self, network_bssid): 124 """Check current wifi connection networks. 125 Args: 126 network_bssid: Network bssid to which connection. 127 Returns: 128 True if connection to given network happen, else return False. 129 """ 130 time.sleep(40) #time for connection state to be updated 131 self.log.info("Check network for {}".format(network_bssid)) 132 current_network = self.dut.droid.wifiGetConnectionInfo() 133 self.log.debug("Current network: {}".format(current_network)) 134 if WifiEnums.BSSID_KEY in current_network: 135 return current_network[WifiEnums.BSSID_KEY] == network_bssid 136 return False 137 138 def set_attn_and_validate_connection(self, attn_value, bssid): 139 """Validate wifi connection status on different attenuation setting. 140 141 Args: 142 attn_value: Attenuation value for different APs signal. 143 bssid: Bssid of excepted network. 144 145 Returns: 146 True if bssid of current network match, else false. 147 """ 148 self.attenuators[0].set_atten(attn_value[0]) 149 self.attenuators[1].set_atten(attn_value[1]) 150 self.attenuators[2].set_atten(attn_value[2]) 151 self.attenuators[3].set_atten(attn_value[3]) 152 self.dut.droid.wakeLockAcquireBright() 153 self.dut.droid.wakeUpNow() 154 try: 155 asserts.assert_true( 156 self.check_connection(bssid), 157 "Device is not connected to required bssid {}".format(bssid)) 158 time.sleep(10) #wait for connection to be active 159 asserts.assert_true( 160 wutils.check_internet_connection(self.dut, self.ping_addr), 161 "Error, No Internet connection for current bssid {}".format( 162 bssid)) 163 finally: 164 self.dut.droid.wifiLockRelease() 165 self.dut.droid.goToSleepNow() 166 167 def on_fail(self, test_name, begin_time): 168 if self.max_bugreports > 0: 169 self.dut.take_bug_report(test_name, begin_time) 170 self.max_bugreports -= 1 171 self.dut.cat_adb_log(test_name, begin_time) 172 173 """ Tests Begin """ 174 175 def test_autojoin_Ap1_2g(self): 176 """Test wifi auto join functionality move in range of AP1. 177 178 1. Attenuate the signal to low range of AP1 and Ap2 not visible at all. 179 2. Wake up the device. 180 3. Check that device is connected to right BSSID and maintain stable 181 connection to BSSID in range. 182 """ 183 att0, att1, att2, att3 = self.atten_val["Ap1_2g"] 184 variance = 5 185 attenuations = ([att0 + variance * 2, att1, att2, att3], 186 [att0 + variance, att1, att2, att3], [att0, att1, att2, att3], 187 [att0 - variance, att1, att2, att3]) 188 name_func = lambda att_value, bssid: ("test_autojoin_Ap1_2g_AP1_{}_AP2" 189 "_{}_AP3_{}").format(att_value[0], att_value[1], att_value[2]) 190 failed = self.run_generated_testcases( 191 self.set_attn_and_validate_connection, 192 attenuations, 193 args=(self.reference_networks[0]["2g"]['bssid'], ), 194 name_func=name_func) 195 asserts.assert_false( 196 failed, 197 "Number of test_autojoin_Ap1_2g failed {}".format(len(failed))) 198 199 def test_autojoin_Ap1_2gto5g(self): 200 """Test wifi auto join functionality move to high range. 201 202 1. Attenuate the signal to high range of AP1. 203 2. Wake up the device. 204 3. Check that device is connected to right BSSID and maintain stable 205 connection to BSSID in range. 206 """ 207 att0, att1, att2, attn3 = self.atten_val["Ap1_2gto5g"] 208 variance = 5 209 attenuations = ([att0 + variance * 2, att1, att2, attn3], 210 [att0 + variance, att1, att2, attn3], [att0, att1, att2, attn3]) 211 name_func = lambda att_value, bssid: ("test_autojoin_Ap1_2gto5g_AP1_{}_AP2" 212 "_{}_AP3_{}").format(att_value[0], att_value[1], att_value[2]) 213 failed = self.run_generated_testcases( 214 self.set_attn_and_validate_connection, 215 attenuations, 216 args=(self.reference_networks[0]["5g"]['bssid'], ), 217 name_func=name_func) 218 asserts.assert_false( 219 failed, 220 "Number of test_autojoin_Ap1_2gto5g failed {}".format(len(failed))) 221 222 def test_autojoin_in_AP1_5gto2g(self): 223 """Test wifi auto join functionality move to low range toward AP2. 224 225 1. Attenuate the signal to medium range of AP1 and low range of AP2. 226 2. Wake up the device. 227 3. Check that device is connected to right BSSID and maintain stable 228 connection to BSSID in range. 229 """ 230 att0, att1, att2, attn3 = self.atten_val["In_AP1_5gto2g"] 231 variance = 5 232 attenuations = ([att0 - variance, att1 + variance, att2, attn3], 233 [att0, att1, att2, attn3], 234 [att0 + variance, att1 - variance, att2, attn3]) 235 name_func = lambda att_value, bssid: ("test_autojoin_in_AP1_5gto2g_AP1_{}_AP2" 236 "_{}_AP3_{}").format(att_value[0], att_value[1], att_value[2]) 237 failed = self.run_generated_testcases( 238 self.set_attn_and_validate_connection, 239 attenuations, 240 args=(self.reference_networks[0]["2g"]['bssid'], ), 241 name_func=name_func) 242 asserts.assert_false( 243 failed, "Number of test_autojoin_in_AP1_5gto2g failed {}".format( 244 len(failed))) 245 246 def test_autojoin_swtich_AP1toAp2(self): 247 """Test wifi auto join functionality move from low range of AP1 to better 248 range of AP2. 249 250 1. Attenuate the signal to low range of AP1 and medium range of AP2. 251 2. Wake up the device. 252 3. Check that device is connected to right BSSID and maintain stable 253 connection to BSSID in range. 254 """ 255 att0, att1, att2, attn3 = self.atten_val["Swtich_AP1toAp2"] 256 variance = 5 257 attenuations = ([att0 - variance, att1 + variance, att2, attn3], 258 [att0, att1, att2, attn3], 259 [att0 + variance, att1 - variance, att2, attn3]) 260 name_func = lambda att_value, bssid: ("test_autojoin_swtich_AP1toAp2_AP1_{}_AP2" 261 "_{}_AP3_{}").format(att_value[0], att_value[1], att_value[2]) 262 failed = self.run_generated_testcases( 263 self.set_attn_and_validate_connection, 264 attenuations, 265 args=(self.reference_networks[1]["2g"]['bssid'], ), 266 name_func=name_func) 267 asserts.assert_false( 268 failed, "Number of test_autojoin_swtich_AP1toAp2 failed {}".format( 269 len(failed))) 270 271 def test_autojoin_Ap2_2gto5g(self): 272 """Test wifi auto join functionality move to high range of AP2. 273 274 1. Attenuate the signal to out range of AP1 and high range of AP2. 275 2. Wake up the device. 276 3. Check that device is connected to right BSSID and maintain stable 277 connection to BSSID in range. 278 """ 279 att0, att1, att2, attn3 = self.atten_val["Ap2_2gto5g"] 280 variance = 5 281 attenuations = ([att0 - variance, att1 + variance * 2, att2, attn3], 282 [att0, att1 + variance, att2, attn3], [att0, att1, att2, attn3]) 283 name_func = lambda att_value, bssid: ("test_autojoin_Ap2_2gto5g_AP1_{}_AP2" 284 "_{}_AP3_{}").format(att_value[0], att_value[1], att_value[2]) 285 failed = self.run_generated_testcases( 286 self.set_attn_and_validate_connection, 287 attenuations, 288 args=(self.reference_networks[1]["5g"]['bssid'], ), 289 name_func=name_func) 290 asserts.assert_false( 291 failed, 292 "Number of test_autojoin_Ap2_2gto5g failed {}".format(len(failed))) 293 294 def test_autojoin_Ap2_5gto2g(self): 295 """Test wifi auto join functionality move to low range of AP2. 296 297 1. Attenuate the signal to low range of AP2. 298 2. Wake up the device. 299 3. Check that device is connected to right BSSID and maintain stable. 300 """ 301 att0, att1, att2, attn3 = self.atten_val["Ap2_5gto2g"] 302 variance = 5 303 attenuations = ([att0, att1 - variance, att2, attn3], [att0, att1, att2, attn3], 304 [att0, att1 + variance, att2, attn3]) 305 name_func = lambda att_value, bssid: ("test_autojoin_Ap2_5gto2g_AP1_{}_AP2" 306 "_{}_AP3_{}").format(att_value[0], att_value[1], att_value[2]) 307 failed = self.run_generated_testcases( 308 self.set_attn_and_validate_connection, 309 attenuations, 310 args=(self.reference_networks[1]["2g"]['bssid'], ), 311 name_func=name_func) 312 asserts.assert_false( 313 failed, 314 "Number of test_autojoin_Ap2_5gto2g failed {}".format(len(failed))) 315 316 def test_autojoin_out_of_range(self): 317 """Test wifi auto join functionality move to low range. 318 319 1. Attenuate the signal to out of range. 320 2. Wake up the device. 321 3. Start the scan. 322 4. Check that device is not connected to any network. 323 """ 324 self.attenuators[0].set_atten(90) 325 self.attenuators[1].set_atten(90) 326 self.attenuators[2].set_atten(90) 327 self.attenuators[3].set_atten(90) 328 self.dut.droid.wakeLockAcquireBright() 329 self.dut.droid.wakeUpNow() 330 try: 331 wutils.start_wifi_connection_scan(self.dut) 332 wifi_results = self.dut.droid.wifiGetScanResults() 333 self.log.debug("Scan result {}".format(wifi_results)) 334 time.sleep(20) 335 current_network = self.dut.droid.wifiGetConnectionInfo() 336 self.log.info("Current network: {}".format(current_network)) 337 asserts.assert_true( 338 ('network_id' in current_network and 339 current_network['network_id'] == -1), 340 "Device is connected to network {}".format(current_network)) 341 finally: 342 self.dut.droid.wifiLockRelease() 343 self.dut.droid.goToSleepNow() 344 345 def test_autojoin_Ap2_2g(self): 346 """Test wifi auto join functionality move in low range of AP2. 347 348 1. Attenuate the signal to move in range of AP2 and Ap1 not visible at all. 349 2. Wake up the device. 350 3. Check that device is connected to right BSSID and maintain stable 351 connection to BSSID in range. 352 """ 353 att0, att1, att2, attn3 = self.atten_val["Ap2_2g"] 354 variance = 5 355 attenuations = ([att0, att1 + variance * 2, att2, attn3], 356 [att0, att1 + variance, att2, attn3], [att0, att1, att2, attn3], 357 [att0, att1 - variance, att2, attn3]) 358 name_func = lambda att_value, bssid: ("test_autojoin_Ap2_2g_AP1_{}_AP2" 359 "_{}_AP3_{}").format(att_value[0], att_value[1], att_value[2]) 360 failed = self.run_generated_testcases( 361 self.set_attn_and_validate_connection, 362 attenuations, 363 args=(self.reference_networks[1]["2g"]['bssid'], ), 364 name_func=name_func) 365 asserts.assert_false( 366 failed, 367 "Number of test_autojoin_Ap2_2g failed {}".format(len(failed))) 368 369 def test_autojoin_in_Ap2_5gto2g(self): 370 """Test wifi auto join functionality move to medium range of Ap2 and 371 low range of AP1. 372 373 1. Attenuate the signal to move in medium range of AP2 and low range of AP1. 374 2. Wake up the device. 375 3. Check that device is connected to right BSSID and maintain stable 376 connection to BSSID in range. 377 """ 378 att0, att1, att2, attn3 = self.atten_val["In_Ap2_5gto2g"] 379 variance = 5 380 attenuations = ([att0, att1 - variance, att2, attn3], [att0, att1, att2, attn3], 381 [att0, att1 + variance, att2, attn3]) 382 name_func = lambda att_value, bssid: ("test_autojoin_in_Ap2_5gto2g_AP1_{}_AP2" 383 "_{}_AP3_{}").format(att_value[0], att_value[1], att_value[2]) 384 failed = self.run_generated_testcases( 385 self.set_attn_and_validate_connection, 386 attenuations, 387 args=(self.reference_networks[1]["2g"]['bssid'], ), 388 name_func=name_func) 389 asserts.assert_false( 390 failed, "Number of test_autojoin_in_Ap2_5gto2g failed {}".format( 391 len(failed))) 392 393 def test_autojoin_swtich_AP2toAp1(self): 394 """Test wifi auto join functionality move from low range of AP2 to better 395 range of AP1. 396 397 1. Attenuate the signal to low range of AP2 and medium range of AP1. 398 2. Wake up the device. 399 3. Check that device is connected to right BSSID and maintain stable 400 connection to BSSID in range. 401 """ 402 att0, att1, att2, attn3 = self.atten_val["Swtich_AP2toAp1"] 403 variance = 5 404 attenuations = ([att0 + variance, att1 - variance, att2, attn3], 405 [att0, att1, att2, attn3], 406 [att0 - variance, att1 + variance, att2, attn3]) 407 name_func = lambda att_value, bssid: ("test_autojoin_swtich_AP2toAp1_AP1_{}_AP2" 408 "_{}_AP3_{}").format(att_value[0], att_value[1], att_value[2]) 409 failed = self.run_generated_testcases( 410 self.set_attn_and_validate_connection, 411 attenuations, 412 args=(self.reference_networks[0]["2g"]['bssid'], ), 413 name_func=name_func) 414 asserts.assert_false( 415 failed, "Number of test_autojoin_swtich_AP2toAp1 failed {}".format( 416 len(failed))) 417 418 def test_autojoin_Ap1_5gto2g(self): 419 """Test wifi auto join functionality move to medium range of AP1. 420 421 1. Attenuate the signal to medium range of AP1. 422 2. Wake up the device. 423 3. Check that device is connected to right BSSID and maintain stable 424 connection to BSSID in range. 425 """ 426 att0, att1, att2, attn3 = self.atten_val["Ap1_5gto2g"] 427 variance = 5 428 attenuations = ([att0, att1, att2, attn3], [att0 + variance, att1, att2, attn3], 429 [att0 + variance * 2, att1, att2, attn3]) 430 name_func = lambda att_value, bssid: ("test_autojoin_Ap1_5gto2g_AP1_{}_AP2" 431 "_{}_AP3_{}").format(att_value[0], att_value[1], att_value[2]) 432 failed = self.run_generated_testcases( 433 self.set_attn_and_validate_connection, 434 attenuations, 435 args=(self.reference_networks[0]["2g"]['bssid'], ), 436 name_func=name_func) 437 asserts.assert_false( 438 failed, 439 "Number of test_autojoin_Ap1_5gto2g failed {}".format(len(failed))) 440 """ Tests End """ 441