# Copyright 2019 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_Cr50ConsoleCommands.faft_cr50_tot"
METADATA = {
    "contacts": ["chromeos-faft@google.com", "mruthven@chromium.org"],
    "bug_component": "b:792402",  # ChromeOS > Platform > Enablement > Firmware > FAFT
    "criteria": "Verify Cr50 console output",
}
ATTRIBUTES = "suite:faft_cr50_tot"
TIME = "SHORT"
TEST_TYPE = "server"
DEPENDENCIES = "servo_state:WORKING"

DOC = """
This test verifies only expected console commands are in the Cr50 image and
that gpiocfg and pinmux have the right settings.

This test is applicable when using ToT cr50 module.
TODO(crbug.com/1014572) Drop this control file once suites can inject test args.
"""

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)

# crbug.com/1014572: Inject test args.
args_dict["tot_test_run"] = "true"


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

    job.run_test(
        "firmware_Cr50ConsoleCommands",
        host=host,
        cmdline_args=args,
        full_args=args_dict,
        tag="faft_cr50_tot",
    )


parallel_simple(run, machines)
