1 /* 2 * Copyright (C) 2021 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.car.cts; 18 19 import android.car.cts.app.PowerPolicyTestCommandStatus; 20 import android.car.cts.app.PowerPolicyTestCommandType; 21 import android.car.cts.powerpolicy.CpmsFrameworkLayerStateInfo; 22 import android.car.cts.powerpolicy.CpmsSystemLayerStateInfo; 23 import android.car.cts.powerpolicy.LocationInfo; 24 import android.car.cts.powerpolicy.PowerPolicyConstants; 25 import android.car.cts.powerpolicy.PowerPolicyDef; 26 import android.car.cts.powerpolicy.PowerPolicyGroups; 27 import android.car.cts.powerpolicy.PowerPolicyTestAnalyzer; 28 import android.car.cts.powerpolicy.PowerPolicyTestHelper; 29 import android.car.cts.powerpolicy.PowerPolicyTestResult; 30 import android.car.cts.powerpolicy.SilentModeInfo; 31 import android.car.cts.powerpolicy.SystemInfoParser; 32 33 import com.android.compatibility.common.util.CommonTestUtils; 34 import com.android.tradefed.log.LogUtil.CLog; 35 import com.android.tradefed.testtype.DeviceJUnit4ClassRunner; 36 37 import org.junit.After; 38 import org.junit.Assume; 39 import org.junit.Before; 40 import org.junit.Test; 41 import org.junit.runner.RunWith; 42 43 import java.lang.reflect.Method; 44 45 @RunWith(DeviceJUnit4ClassRunner.class) 46 public final class PowerPolicyHostTest extends CarHostJUnit4TestCase { 47 private static final String ANDROID_CLIENT_PKG = "android.car.cts.app"; 48 private static final String ANDROID_CLIENT_ACTIVITY = ANDROID_CLIENT_PKG 49 + "/.PowerPolicyTestActivity"; 50 private static final String TEST_COMMAND_HEADER = 51 "am start -n " + ANDROID_CLIENT_ACTIVITY + " --es powerpolicy "; 52 53 private static final int DEFAULT_TIMEOUT_SEC = 20; 54 private static final int BOOT_TIMEOUT_SEC = 60; 55 56 private final PowerPolicyTestAnalyzer mTestAnalyzer = new PowerPolicyTestAnalyzer(this); 57 58 @Before checkPrecondition()59 public void checkPrecondition() throws Exception { 60 waitForPowerState(PowerPolicyConstants.CarPowerState.ON); 61 PowerPolicyTestHelper testHelper = new PowerPolicyTestHelper( 62 /* testcase= */ "pre-condition", /* step= */ "testStep1", 63 /* frameCpms= */ getCpmsFrameworkLayerStateInfo(), 64 /* sysCpms= */ getCpmsSystemLayerStateInfo(), /* silentMode= */ null); 65 checkDefaultPowerPolicySet(testHelper); 66 } 67 68 @After restoreInitCondition()69 public void restoreInitCondition() throws Exception { 70 applyPowerPolicy(PowerPolicyDef.IdSet.DEFAULT_ALL_ON); 71 } 72 73 @Test testPowerPolicySilentMode()74 public void testPowerPolicySilentMode() throws Exception { 75 String testcase = "testPowerPolicySilentModeFull:"; 76 String teststep; 77 PowerPolicyTestHelper testHelper; 78 79 SilentModeInfo smInfo = getSilentModeInfo(); 80 Assume.assumeTrue("HW does not support silent mode. Skip the test", 81 smInfo.getMonitoringHWStateSignal()); 82 83 teststep = "switch to forced silent"; 84 enterForcedSilentMode(); 85 testHelper = getTestHelper(testcase, 1, teststep); 86 // Test starts in ON state, state shouldn't change between test start and this check 87 testHelper.checkCurrentState(PowerPolicyConstants.CarPowerState.ON); 88 testHelper.checkCurrentPolicy(PowerPolicyDef.IdSet.NO_USER_INTERACTION); 89 testHelper.checkSilentModeStatus(true); 90 testHelper.checkSilentModeFull(SilentModeInfo.FORCED_SILENT); 91 testHelper.checkCurrentPowerComponents(PowerPolicyDef.PolicySet.NO_USER_INTERACT); 92 93 teststep = "restore to normal mode"; 94 leaveForcedSilentMode(); 95 testHelper = getTestHelper(testcase, 2, teststep); 96 // Test starts in ON state, state shouldn't change between test start and this check 97 testHelper.checkCurrentState(PowerPolicyConstants.CarPowerState.ON); 98 testHelper.checkCurrentPolicy(PowerPolicyDef.IdSet.DEFAULT_ALL_ON); 99 testHelper.checkSilentModeStatus(false); 100 testHelper.checkSilentModeFull(SilentModeInfo.NO_SILENT); 101 testHelper.checkCurrentPowerComponents(PowerPolicyDef.PolicySet.DEFAULT_ALL_ON); 102 } 103 104 /** 105 * Tests the error conditions for CPMS at the ON state. 106 * 107 * <p>All other VHAL events but {@code SHUTDOWN_PREPARE} shall not have any impact 108 * to CPMS power state. 109 */ 110 @Test testDefaultStateMachineAtONState()111 public void testDefaultStateMachineAtONState() throws Exception { 112 String testcase = "testDefaultStateMachineAtONState:"; 113 String[] stepNames = { 114 "trigger VHAL ON event", 115 "trigger VHAL CANCEL_SHUTDOWN", 116 "trigger VHAL FINISHED" 117 }; 118 int[] vhalReqs = { 119 PowerPolicyConstants.VhalPowerStateReq.ON, 120 PowerPolicyConstants.VhalPowerStateReq.CANCEL_SHUTDOWN, 121 PowerPolicyConstants.VhalPowerStateReq.FINISHED 122 }; 123 124 for (int i = 0; i < stepNames.length; i++) { 125 triggerVhalPowerStateReq(vhalReqs[i], PowerPolicyConstants.ShutdownParam.NOT_USED); 126 PowerPolicyTestHelper testHelper = getTestHelper(testcase, i + 1, stepNames[i]); 127 // power state shouldn't change 128 testHelper.checkCurrentState(PowerPolicyConstants.CarPowerState.ON); 129 testHelper.checkCurrentPolicy(PowerPolicyDef.IdSet.DEFAULT_ALL_ON); 130 } 131 } 132 133 @Test testPowerPolicyChange()134 public void testPowerPolicyChange() throws Exception { 135 String testcase = "testPowerPolicyChange:"; 136 int stepNo = 0; 137 String teststep; 138 PowerPolicyTestHelper testHelper; 139 140 teststep = "check the inital power policies"; 141 testHelper = getTestHelper(testcase, stepNo++, teststep); 142 // Test starts in ON state, state shouldn't change between test start and this check 143 testHelper.checkCurrentState(PowerPolicyConstants.CarPowerState.ON); 144 // save number of device power policies 145 int registeredPoliciesNumber = testHelper.getNumberOfRegisteredPolicies(); 146 int expectedTotalPolicies = registeredPoliciesNumber; 147 148 // create two power policies, test1 and test2, for power policy change test 149 defineAndCheckPolicyTest1(testcase, stepNo++, ++expectedTotalPolicies); 150 defineAndCheckPolicyTest2(testcase, stepNo++, ++expectedTotalPolicies); 151 152 teststep = "apply power policy test1"; 153 applyPowerPolicy(PowerPolicyDef.IdSet.TEST1); 154 testHelper = getTestHelper(testcase, stepNo++, teststep); 155 testHelper.checkCurrentPolicy(PowerPolicyDef.IdSet.TEST1); 156 157 teststep = "apply power policy test2"; 158 applyPowerPolicy(PowerPolicyDef.IdSet.TEST2); 159 testHelper = getTestHelper(testcase, stepNo++, teststep); 160 testHelper.checkCurrentPolicy(PowerPolicyDef.IdSet.TEST2); 161 162 teststep = "revert power policy back to the default"; 163 applyPowerPolicy(PowerPolicyDef.IdSet.DEFAULT_ALL_ON); 164 testHelper = getTestHelper(testcase, stepNo++, teststep); 165 testHelper.checkCurrentPolicy(PowerPolicyDef.IdSet.DEFAULT_ALL_ON); 166 167 // add "test power policy listener" here so that one reboot clears all 168 defineAndCheckPolicyListenerTest(testcase, stepNo++, ++expectedTotalPolicies); 169 String clientTestcase = "PowerPolicyListenerTest"; 170 PowerPolicyTestResult testResult = new PowerPolicyTestResult(mTestAnalyzer); 171 String clientAction = PowerPolicyTestCommandType.DUMP_LISTENER.name(); 172 String component = "AUDIO"; 173 174 setClientTestcase(clientTestcase, getTestRunningUserId()); 175 int currentNumberListeners = getNumberPolicyListeners(); 176 registerPowerPolicyListener(component, getTestRunningUserId()); 177 waitUntilNumberPolicyListenersEquals(++currentNumberListeners); 178 resetPowerPolicyListeners(getTestRunningUserId()); 179 waitResetPowerPolicyListenersComplete(testResult, clientTestcase, 180 PowerPolicyTestCommandType.RESET_LISTENERS.name(), component); 181 applyPowerPolicy(PowerPolicyDef.IdSet.LISTENER_TEST); 182 waitPowerPolicyListenersUpdated(testResult, clientTestcase, 183 PowerPolicyTestCommandType.CHECK_LISTENERS.name(), component, 184 getTestRunningUserId()); 185 186 dumpPowerPolicyListener(component, getTestRunningUserId()); 187 testResult.checkLastTestResultEntry(clientTestcase, clientAction, 188 component, PowerPolicyDef.PolicySet.LISTENER_TEST); 189 190 unregisterPowerPolicyListener(component, getTestRunningUserId()); 191 applyPowerPolicy(PowerPolicyDef.IdSet.DEFAULT_ALL_ON); 192 waitPowerPolicyListenersUpdated(testResult, clientTestcase, 193 PowerPolicyTestCommandType.CHECK_LISTENERS.name(), component, 194 getTestRunningUserId()); 195 196 dumpPowerPolicyListener(component, getTestRunningUserId()); 197 testResult.checkLastTestResultEntry(clientTestcase, clientAction, 198 component, "not_registered"); 199 clearClientTestcase(getTestRunningUserId()); 200 201 // add respect to user setting test case here to utilize a single device reboot 202 testPowerPolicyAndComponentUserSetting(); 203 204 teststep = "define power policy group"; 205 definePowerPolicyGroup(PowerPolicyGroups.TestSet.POLICY_GROUP_DEF1.toShellCommandString()); 206 definePowerPolicyGroup(PowerPolicyGroups.TestSet.POLICY_GROUP_DEF2.toShellCommandString()); 207 testHelper = getTestHelper(testcase, stepNo++, teststep); 208 // check that device policy groups, include just added groups as well 209 testHelper.checkPowerPolicyGroupsDefined(PowerPolicyGroups.TestSet.POLICY_GROUPS1); 210 211 teststep = "set power policy group"; 212 setPowerPolicyGroup(PowerPolicyGroups.TestSet.GROUP_ID1); 213 testHelper = getTestHelper(testcase, stepNo++, teststep); 214 testHelper.checkCurrentPolicyGroupId(PowerPolicyGroups.TestSet.GROUP_ID1); 215 216 // reboot device to clear created TEST1 and TEST2 test cases. 217 // need to find a way to move reboot device into AfterAll 218 rebootDevice(); 219 teststep = "reboot to clear added test power policies"; 220 // device was restarted, need to wait for ON state 221 waitForPowerState(PowerPolicyConstants.CarPowerState.ON); 222 testHelper = getTestHelper(testcase, stepNo++, teststep); 223 testHelper.checkTotalRegisteredPolicies(registeredPoliciesNumber); 224 } 225 fetchActivityDumpsys()226 public String fetchActivityDumpsys() throws Exception { 227 return executeCommand("dumpsys activity %s", ANDROID_CLIENT_ACTIVITY); 228 } 229 waitForPowerState(int powerState)230 private void waitForPowerState(int powerState) throws Exception { 231 //need to wait for ON state 232 CommonTestUtils.waitUntil("timed out (" + BOOT_TIMEOUT_SEC 233 + "s) waiting for ON state", BOOT_TIMEOUT_SEC, 234 () -> { 235 CpmsFrameworkLayerStateInfo frameworkLayerStateInfo = 236 getCpmsFrameworkLayerStateInfo(); 237 return frameworkLayerStateInfo != null 238 && frameworkLayerStateInfo.getCurrentState() == powerState; 239 }); 240 } 241 getTestHelper(String testcase, int stepNo, String stepName)242 private PowerPolicyTestHelper getTestHelper(String testcase, int stepNo, String stepName) 243 throws Exception { 244 CpmsSystemLayerStateInfo cpmsSystemInfo = getCpmsSystemLayerStateInfo(); 245 CpmsFrameworkLayerStateInfo cpmsFrameworkInfo = getCpmsFrameworkLayerStateInfo(); 246 String normalizedStepName = String.format("%d. %s", stepNo, stepName); 247 return new PowerPolicyTestHelper(testcase, normalizedStepName, 248 cpmsFrameworkInfo, cpmsSystemInfo, getSilentModeInfo()); 249 } 250 triggerVhalPowerStateReq(int reqNo, int param)251 private void triggerVhalPowerStateReq(int reqNo, int param) throws Exception { 252 executeCommand("cmd car_service inject-vhal-event %d %d,%d", 253 PowerPolicyConstants.VHAL_POWER_STATE_REQ_PROPERTY_ID, reqNo, param); 254 } 255 getSilentModeInfo()256 private SilentModeInfo getSilentModeInfo() throws Exception { 257 return executeAndParseCommand( 258 new SystemInfoParser<SilentModeInfo>(SilentModeInfo.class), 259 SilentModeInfo.COMMAND); 260 } 261 getCpmsFrameworkLayerStateInfo()262 private CpmsFrameworkLayerStateInfo getCpmsFrameworkLayerStateInfo() throws Exception { 263 return executeAndParseCommand(new SystemInfoParser<CpmsFrameworkLayerStateInfo>( 264 CpmsFrameworkLayerStateInfo.class), CpmsFrameworkLayerStateInfo.COMMAND); 265 } 266 getCpmsSystemLayerStateInfo()267 private CpmsSystemLayerStateInfo getCpmsSystemLayerStateInfo() throws Exception { 268 return executeAndParseCommand(new SystemInfoParser<CpmsSystemLayerStateInfo>( 269 CpmsSystemLayerStateInfo.class), CpmsSystemLayerStateInfo.COMMAND); 270 } 271 rebootDevice()272 private void rebootDevice() throws Exception { 273 executeCommand("svc power reboot"); 274 waitForDeviceAvailable(); 275 } 276 enterForcedSilentMode()277 private void enterForcedSilentMode() throws Exception { 278 executeCommand("cmd car_service silent-mode forced-silent"); 279 waitUntilForcedSilentModeChangeTo(true); 280 } 281 leaveForcedSilentMode()282 private void leaveForcedSilentMode() throws Exception { 283 executeCommand("cmd car_service silent-mode forced-non-silent"); 284 executeCommand("cmd car_service silent-mode non-forced-silent-mode"); 285 waitUntilForcedSilentModeChangeTo(false); 286 } 287 definePowerPolicy(String policyStr)288 private void definePowerPolicy(String policyStr) throws Exception { 289 CLog.d("definePowerPolicy: %s", policyStr); 290 executeCommand("cmd car_service define-power-policy %s", policyStr); 291 } 292 applyPowerPolicy(String policyId)293 private void applyPowerPolicy(String policyId) throws Exception { 294 executeCommand("cmd car_service apply-power-policy %s", policyId); 295 } 296 definePowerPolicyGroup(String policyGroupStr)297 private void definePowerPolicyGroup(String policyGroupStr) throws Exception { 298 executeCommand("cmd car_service define-power-policy-group %s", policyGroupStr); 299 } 300 setPowerPolicyGroup(String policyGroupId)301 private void setPowerPolicyGroup(String policyGroupId) throws Exception { 302 executeCommand("cmd car_service set-power-policy-group %s", policyGroupId); 303 } 304 setClientTestcase(String testcase, int userId)305 private void setClientTestcase(String testcase, int userId) throws Exception { 306 executeCommand("%s settest,%s --user %d", TEST_COMMAND_HEADER, testcase, userId); 307 } 308 clearClientTestcase(int userId)309 private void clearClientTestcase(int userId) throws Exception { 310 executeCommand("%s cleartest --user %d", TEST_COMMAND_HEADER, userId); 311 } 312 registerPowerPolicyListener(String componentName, int userId)313 private void registerPowerPolicyListener(String componentName, int userId) throws Exception { 314 executeCommand("%s addlistener,%s --user %d", TEST_COMMAND_HEADER, componentName, userId); 315 } 316 unregisterPowerPolicyListener(String componentName, int userId)317 private void unregisterPowerPolicyListener(String componentName, int userId) throws Exception { 318 executeCommand("%s removelistener,%s --user %d", 319 TEST_COMMAND_HEADER, componentName, userId); 320 } 321 dumpPowerPolicyListener(String componentName, int userId)322 private void dumpPowerPolicyListener(String componentName, int userId) throws Exception { 323 executeCommand("%s dumplistener,%s --user %d", TEST_COMMAND_HEADER, componentName, userId); 324 } 325 waitPowerPolicyListenersUpdated(PowerPolicyTestResult testResult, String clientTestcase, String clientAction, String component, int userId)326 private void waitPowerPolicyListenersUpdated(PowerPolicyTestResult testResult, 327 String clientTestcase, String clientAction, String component, int userId) 328 throws Exception { 329 CommonTestUtils.waitUntil("timed out (" + DEFAULT_TIMEOUT_SEC 330 + "s) waiting policy listeners updated", DEFAULT_TIMEOUT_SEC, 331 () -> { 332 return checkPowerPolicyListenersUpdated(testResult, clientTestcase, 333 clientAction, component, userId); 334 }); 335 } 336 checkPowerPolicyListenersUpdated(PowerPolicyTestResult testResult, String clientTestcase, String clientAction, String component, int userId)337 private boolean checkPowerPolicyListenersUpdated(PowerPolicyTestResult testResult, 338 String clientTestcase, String clientAction, String component, int userId) 339 throws Exception { 340 executeCommand("%s checklisteners --user %d", TEST_COMMAND_HEADER, userId); 341 return testResult.checkLastTestResultEntryData(clientTestcase, clientAction, 342 component, PowerPolicyTestCommandStatus.PROPAGATED); 343 } 344 resetPowerPolicyListeners(int userId)345 private void resetPowerPolicyListeners(int userId) throws Exception { 346 executeCommand("%s resetlisteners --user %d", TEST_COMMAND_HEADER, userId); 347 } 348 waitResetPowerPolicyListenersComplete(PowerPolicyTestResult testResult, String clientTestcase, String clientAction, String component)349 private void waitResetPowerPolicyListenersComplete(PowerPolicyTestResult testResult, 350 String clientTestcase, String clientAction, String component) throws Exception { 351 CommonTestUtils.waitUntil("timed out (" + DEFAULT_TIMEOUT_SEC 352 + "s) waiting resetPowerPolicyListenersComplete", DEFAULT_TIMEOUT_SEC, 353 () -> { 354 return testResult.checkLastTestResultEntryData(clientTestcase, clientAction, 355 component, PowerPolicyTestCommandStatus.SUCCEED); 356 }); 357 } 358 getNumberPolicyListeners()359 private int getNumberPolicyListeners() throws Exception { 360 return getCpmsFrameworkLayerStateInfo().getNumberPolicyListeners(); 361 } 362 waitUntilNumberPolicyListenersEquals(int numListeners)363 private void waitUntilNumberPolicyListenersEquals(int numListeners) throws Exception { 364 CommonTestUtils.waitUntil("timed out (" + DEFAULT_TIMEOUT_SEC 365 + "s) getting number policy listeners", DEFAULT_TIMEOUT_SEC, 366 () -> (getNumberPolicyListeners() == numListeners)); 367 } 368 waitUntilForcedSilentModeChangeTo(boolean expected)369 private void waitUntilForcedSilentModeChangeTo(boolean expected) throws Exception { 370 String timeoutMsg = String.format("timed out (%ds) waiting for forced silent mode " 371 + "to be %b", DEFAULT_TIMEOUT_SEC, expected); 372 CommonTestUtils.waitUntil(timeoutMsg, DEFAULT_TIMEOUT_SEC, 373 () -> { 374 SilentModeInfo silentInfo = getSilentModeInfo(); 375 CpmsFrameworkLayerStateInfo cpmsInfo = getCpmsFrameworkLayerStateInfo(); 376 return (silentInfo.getForcedSilentMode() == expected) 377 && (cpmsInfo.getForcedSilentMode() == expected); 378 }); 379 } 380 waitForDeviceAvailable()381 private void waitForDeviceAvailable() throws Exception { 382 try { 383 getDevice().waitForDeviceAvailable(); 384 } catch (Exception e) { 385 CLog.w("device is not available, trying one more time"); 386 getDevice().waitForDeviceAvailable(); 387 } 388 } 389 checkDefaultPowerPolicySet(PowerPolicyTestHelper testHelper)390 private void checkDefaultPowerPolicySet(PowerPolicyTestHelper testHelper) throws Exception { 391 testHelper.checkRegisteredPolicy(PowerPolicyDef.PolicySet.INITIAL_ALL_ON); 392 testHelper.checkRegisteredPolicy(PowerPolicyDef.PolicySet.DEFAULT_ALL_ON); 393 } 394 defineAndCheckPolicyTest1(String testcase, int stepNo, int expectedTotalPolicies)395 private void defineAndCheckPolicyTest1(String testcase, int stepNo, 396 int expectedTotalPolicies) throws Exception { 397 String teststep = stepNo + ". define a new power policy with id test1"; 398 definePowerPolicy(PowerPolicyDef.PolicySet.TEST1.toString()); 399 PowerPolicyTestHelper testHelper = getTestHelper(testcase, stepNo, teststep); 400 testHelper.checkRegisteredPolicy(PowerPolicyDef.PolicySet.TEST1); 401 testHelper.checkTotalRegisteredPolicies(expectedTotalPolicies); 402 } 403 defineAndCheckPolicyTest2(String testcase, int stepNo, int expectedTotalPolicies)404 private void defineAndCheckPolicyTest2(String testcase, int stepNo, 405 int expectedTotalPolicies) throws Exception { 406 String teststep = stepNo + ". define a new power policy with id test2"; 407 definePowerPolicy(PowerPolicyDef.PolicySet.TEST2.toString()); 408 PowerPolicyTestHelper testHelper = getTestHelper(testcase, stepNo, teststep); 409 testHelper.checkRegisteredPolicy(PowerPolicyDef.PolicySet.TEST2); 410 testHelper.checkTotalRegisteredPolicies(expectedTotalPolicies); 411 } 412 defineAndCheckPolicyListenerTest(String testcase, int stepNo, int expectedTotalPolicies)413 private void defineAndCheckPolicyListenerTest(String testcase, int stepNo, 414 int expectedTotalPolicies) throws Exception { 415 String teststep = stepNo + ". define a new power policy with id listener_test"; 416 definePowerPolicy(PowerPolicyDef.PolicySet.LISTENER_TEST.toString()); 417 PowerPolicyTestHelper testHelper = getTestHelper(testcase, stepNo, teststep); 418 testHelper.checkRegisteredPolicy(PowerPolicyDef.PolicySet.LISTENER_TEST); 419 testHelper.checkTotalRegisteredPolicies(expectedTotalPolicies); 420 } 421 testPowerPolicyAndComponentUserSetting()422 private void testPowerPolicyAndComponentUserSetting() throws Exception { 423 ComponentTestHelper[] testHelpers = { 424 new ComponentTestHelper<LocationInfo>(this, "LOCATION", LocationInfo.class), 425 }; 426 427 for (int i = 0; i < testHelpers.length; i++) { 428 testComponent(testHelpers[i]); 429 } 430 } 431 432 private static final class ComponentTestHelper<T> { 433 private final PowerPolicyHostTest mHostTest; 434 private final String mComponentName; 435 private final String mInfoRetrieveCommand; 436 private final String[] mEnableCommands; 437 private final String[] mDisableCommands; 438 private final Class mTypeClass; 439 ComponentTestHelper(PowerPolicyHostTest hostTest, String componentName, Class typeClass)440 ComponentTestHelper(PowerPolicyHostTest hostTest, String componentName, Class typeClass) 441 throws Exception { 442 mHostTest = hostTest; 443 mComponentName = componentName; 444 mTypeClass = typeClass; 445 mInfoRetrieveCommand = (String) mTypeClass.getField("COMMAND").get(null); 446 mEnableCommands = (String[]) mTypeClass.getField("ENABLE_COMMANDS").get(null); 447 mDisableCommands = (String[]) mTypeClass.getField("DISABLE_COMMANDS").get(null); 448 } 449 turnOnComponent()450 private void turnOnComponent() throws Exception { 451 for (int i = 0; i < mEnableCommands.length; i++) { 452 mHostTest.executeCommand(mEnableCommands[i]); 453 } 454 } 455 turnOffComponent()456 private void turnOffComponent() throws Exception { 457 for (int i = 0; i < mDisableCommands.length; i++) { 458 mHostTest.executeCommand(mDisableCommands[i]); 459 } 460 } 461 tryGetComponentInfo()462 private T tryGetComponentInfo() throws Exception { 463 return mHostTest.executeAndParseCommand(new SystemInfoParser<T>(mTypeClass), 464 mInfoRetrieveCommand); 465 } 466 waitUntilPowerStateChangeTo(boolean expected)467 private void waitUntilPowerStateChangeTo(boolean expected) throws Exception { 468 CommonTestUtils.waitUntil("timed out with " + mComponentName 469 + "enabled expected: " + expected, DEFAULT_TIMEOUT_SEC, 470 () -> { 471 T info = tryGetComponentInfo(); 472 if (info != null) { 473 Method isPowerOn = mTypeClass.getMethod("isPowerOn"); 474 Boolean result = (Boolean) isPowerOn.invoke(info); 475 return result.booleanValue() == expected; 476 } 477 return false; 478 }); 479 } 480 } 481 testComponent(ComponentTestHelper testHelper)482 private void testComponent(ComponentTestHelper testHelper) 483 throws Exception { 484 PowerPolicyDef powerOffPolicy = 485 PowerPolicyDef.createWithComponentOff(testHelper.mComponentName); 486 definePowerPolicy(powerOffPolicy.toString()); 487 488 testHelper.turnOffComponent(); 489 testHelper.waitUntilPowerStateChangeTo(false); 490 491 testHelper.turnOnComponent(); 492 testHelper.waitUntilPowerStateChangeTo(true); 493 494 applyPowerPolicy(powerOffPolicy.getPolicyId()); 495 testHelper.turnOnComponent(); 496 testHelper.waitUntilPowerStateChangeTo(true); 497 498 testHelper.turnOffComponent(); 499 testHelper.waitUntilPowerStateChangeTo(false); 500 } 501 } 502