# 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_FWMPDisableCCD"
METADATA = {
        "contacts": ["chromeos-faft@google.com", "mruthven@chromium.org"],
        "bug_component": "b:792402", # ChromeOS > Platform > Enablement > Firmware > FAFT
        "criteria": "Verify the cr50 response to FWMP flags being set"
}
TIME = "MEDIUM"
ATTRIBUTES = "suite:faft_gsc_nightly, suite:faft_cr50_pvt, suite:faft_cr50_prepvt, suite:faft_ti50_qual"
TEST_TYPE = "server"
JOB_RETRIES = 0
DEPENDENCIES = "servo_state:WORKING"

DOC = """
This test will set FWMP flags. If the test has access to the cr50 console, it
will verify that cr50 sees the ccd disable flag is set and disables console
unlock.
"""

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_FWMPDisableCCD", host=host, cmdline_args=args,
                 full_args=args_dict, iterations=iterations)

parallel_simple(run, machines)
