tree 381f8a6d2b0121ff47457472b980f062c9908c03
parent 8e75bab067119dfdaa086e934755f010159da127
author Mengqi Guo <mqg@chromium.org> 1539725967 -0700
committer chrome-bot <chrome-bot@chromium.org> 1539899672 -0700

power: Add test to use Servo v4 to charge the DUT

Add a server side test that controls charging the DUT. This server
side test first makes sure that the attached Servo v4 can control
charging the DUT, then puts the DUT on AC to charge, and finally
disconnect DUT from AC.

BUG=b:117681170
TEST=see following
test_that <dut ip> power_BatteryChargeControl.args \
--autotest_dir ~/trunk/src/third_party/autotest/files/ \
--args 'servo_host=localhost servo_port=9999 percent_charge_to_add=.5'

test_that <dut ip> power_BatteryChargeControl.args \
--autotest_dir ~/trunk/src/third_party/autotest/files/ \
--args 'servo_host=localhost servo_port=9999 percent_target_charge=83'

test_that <dut ip> power_BatteryCharge.args \
--autotest_dir ~/trunk/src/third_party/autotest/files/ \
--args 'percent_target_charge=3'

test_that <dut ip> power_BatteryChargeControl.charge70 \
--autotest_dir ~/trunk/src/third_party/autotest/files/

Change-Id: I530dde75fae74661436437cc4126bff3560367ef
Signed-off-by: Mengqi Guo <mqg@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/1285530
Commit-Ready: ChromeOS CL Exonerator Bot <chromiumos-cl-exonerator@appspot.gserviceaccount.com>
Reviewed-by: Puthikorn Voravootivat <puthik@chromium.org>
