# Copyright 2020 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 = "ChromeOS Team"
NAME = "firmware_PDResetHard.shutdown_port2"
METADATA = {
    "contacts": ["chromeos-faft@google.com", "jbettis@chromium.org"],
    "bug_component": "b:792402",  # ChromeOS > Platform > Enablement > Firmware > FAFT
    "criteria": "Servo based PD hard reset test on USB-C port 2",
    "requirements": ["sys-fw-0023-v01"],
}
DEPENDENCIES = "servo_state:WORKING"
TIME = "SHORT"
TEST_TYPE = "server"

DOC = """
This test checks:
  - Ability of DUT to initate hard resets
  - Ability of DUT to receive hard resets
  - If DUT is dualrole capable, hard resets are done with the DUT
    in each power role.
"""

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


def run(machine):
    host = hosts.create_host(
        machine, servo_args=servo_args, pdtester_args=pdtester_args
    )
    job.run_test(
        "firmware_PDResetHard",
        host=host,
        cmdline_args=args,
        disable_sysinfo=True,
        flip_cc=False,
        dts_mode=False,
        init_power_mode="shutdown",
        tag='.'.join(NAME.split('.')[1:]),
        desired_pd_port_idx=2,
    )


parallel_simple(run, machines)
