# Copyright 2018 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 = "apronin"
NAME = "firmware_Cr50U2fPowerwash"
METADATA = {
        "contacts": ["chromeos-faft@google.com", "apronin@chromium.org"],
        "bug_component": "b:792402", # ChromeOS > Platform > Enablement > Firmware > FAFT
        "criteria": "after a powerwash, a device cannot be used to access resources on which the device was registered before powerwash"
}
ATTRIBUTES = "suite:faft_gsc_nightly, suite:faft_cr50_pvt, suite:faft_cr50_prepvt"
TIME = "SHORT"
TEST_TYPE = "server"
DEPENDENCIES="servo_state:WORKING"

DOC = """
This test issues a U2F_REGISTER command, clears the TPM, and checks that
the previously issued key handle becomes invalid. This test ensures that
after a powerwash, a device cannot be used to access resources on which
the device was registered before powerwash.
"""

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

def run_test(machine):
    host = hosts.create_host(machine, servo_args=servo_args)
    iterations = int(args_dict.get("iterations", 1))
    job.run_test('firmware_Cr50U2fPowerwash', host=host, cmdline_args=args,
                 iterations=iterations)

parallel_simple(run_test, machines)
