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

DOC = """
This test clears the cr50 update state and reboots the device many times
to verify that the cr50 update is reliable.

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)

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

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


parallel_simple(run, machines)
