# 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.

# TODO(b/322035270): Remove this file when PVS is no longer using this test.

from autotest_lib.server import utils

AUTHOR = "ChromeOS Team"
NAME = "firmware_PDPowerSwap.flip_port1"
METADATA = {
        "contacts": ["chromeos-faft@google.com", "jbettis@chromium.org"],
        "bug_component": "b:792402", # ChromeOS > Platform > Enablement > Firmware > FAFT
        "criteria": "Servo based PD power role swap test on USB-C port 1",
}
DEPENDENCIES = "servo_state:WORKING"
TIME = "SHORT"
TEST_TYPE = "server"

DOC = """
This test checks:
  - If the DUT advertises support for dualrole operation
  - Tests if the DUT can receive power swap requests
  - Tests if the DUT can initiate power swap requests

This subtest is testing the other CC pin.
"""

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_PDPowerSwap", host=host, cmdline_args=args,
                 disable_sysinfo=True, flip_cc=True, dts_mode=False,
                 tag='.'.join(NAME.split('.')[1:]), desired_pd_port_idx=1)

parallel_simple(run, machines)
