# 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/322203169): Delete this file when PVS is done with it.

from autotest_lib.server import utils

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

DOC = """
This test checks:
  - If the DUT advertises support for data role swaps
  - Tests if the DUT can receive data swap requests
  - Tests if the DUT can initate data swap requests
"""

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

parallel_simple(run, machines)
