# Copyright 2017 The ChromiumOS Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

from autotest_lib.server import utils

AUTHOR = "mruthven"
NAME = "firmware_Cr50Testlab"
METADATA = {
        "contacts": ["chromeos-faft@google.com", "mruthven@chromium.org"],
        "bug_component": "b:792402", # ChromeOS > Platform > Enablement > Firmware > FAFT
        "criteria": "Verify ccd testlab mode"
}
# This is verified by a devboard test. Remove the tests from nightly suites.
# Don't delete the test in case we find something that we need to verify on
# an actual dut.
# ATTRIBUTES = "suite:faft_gsc_nightly, suite:faft_cr50_pvt, suite:faft_cr50_prepvt"
TIME = "SHORT"
TEST_TYPE = "server"
DEPENDENCIES = "servo_state:WORKING"

DOC = """
Verify the testlab mode can be changed when ccd is open.

This must be done using servo instead of CCD, because we need to be able to
control the power button while the console is locked.
"""

if 'args_dict' not in locals():
    args_dict = {}

args_dict.update(utils.args_to_dict(args))
servo_args = hosts.CrosHost.get_servo_arguments(args_dict)

def run(machine):
    host = hosts.create_host(machine, servo_args=servo_args)

    iterations = int(args_dict.get("iterations", 1))

    job.run_test("firmware_Cr50Testlab", host=host, cmdline_args=args,
                 full_args=args_dict, iterations=iterations)

parallel_simple(run, machines)
