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

from autotest_lib.server import utils

AUTHOR = "mruthven"
NAME = "firmware_Cr50InvalidateRW.faft_cr50_tot"
METADATA = {
    "contacts": ["chromeos-faft@google.com", "mruthven@chromium.org"],
    "bug_component": "b:792402",  # ChromeOS > Platform > Enablement > Firmware > FAFT
    "criteria": "Verify the inactive cr50 header is corrupted after login",
}
ATTRIBUTES = "suite:faft_cr50_tot"
TIME = "MEDIUM"
TEST_TYPE = "server"

DOC = """
Verify the inactive Cr50 header on the first login after cryptohome restarts.

There are two special cases this test covers: logging in after the TPM owner is
cleared and logging in as guest. After the tpm owner is cleared, corrupting the
header will be done on the second login. During guest login the owner wont be
cleared.

This test is applicable when using ToT cr50 module.
TODO(crbug.com/1014572) Drop this control file once suites can inject test args.
"""

args_dict = utils.args_to_dict(args)

# crbug.com/1014572: Inject test args.
args_dict["tot_test_run"] = "true"


def run(machine):
    host = hosts.create_host(machine)

    num_iterations = int(args_dict.get("num_iterations", 1))

    job.run_test(
        "firmware_Cr50InvalidateRW",
        host=host,
        iterations=num_iterations,
        tag="faft_cr50_tot",
    )


parallel_simple(run, machines)
