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

# TODO(b/339345721): Remove from PVS testplans and remove this file.

from autotest_lib.server import utils

AUTHOR = "ChromeOS Team"
NAME = "firmware_FwScreenCloseLid"
METADATA = {
    "contacts": ["chromeos-faft@google.com", "jbettis@chromium.org"],
    "bug_component": "b:792402",  # ChromeOS > Platform > Enablement > Firmware > FAFT
    "criteria": "Servo based lid close triggered shutdown during firmware screens",
}
DEPENDENCIES = "servo_state:WORKING, servo_usb_state:NORMAL"
TIME = "MEDIUM"
TEST_TYPE = "server"
JOB_RETRIES = 0

DOC = """
This test requires a USB disk plugged-in, which contains a ChromeOS test
image (built by "build_image --test"). On runtime, this test triggers
firmware screens (developer, remove, insert, yuck, to_norm screens),
and then closes the lid in order to power the machine down.
"""

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


def run_fwscreencloselid(machine):
    host = hosts.create_host(machine, servo_args=servo_args)
    job.run_test(
        "firmware_FwScreenCloseLid",
        host=host,
        cmdline_args=args,
        disable_sysinfo=True,
        dev_mode=True,
    )


parallel_simple(run_fwscreencloselid, machines)
