# Copyright 2022 The ChromiumOS Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import logging
import pprint
import re
import time

from autotest_lib.client.bin import utils
from autotest_lib.client.common_lib import error
from autotest_lib.client.common_lib.cros import cr50_utils
from autotest_lib.server.cros.faft.cr50_test import Cr50Test


class firmware_GSCAPROV1Trigger(Cr50Test):
    """Verify GSC response after triggering AP RO V1 verification."""
    version = 1

    # This only verifies V1 output right now.
    TEST_AP_RO_VER = 1

    # DBG image has to be able to set the AP RO hash with the board id set.
    MIN_DBG_VER = '1.6.100'
    MIN_RELEASE_MAJOR = 5
    MIN_RELEASE_MINOR = 141

    APRO_PASS = 6
    APRO_FAIL = 2
    APRO_IN_PROGRESS = 7
    # Regex to search for the end of the AP RO output. Every run should end with
    # "AP RO PASS!" or "AP RO FAIL! evt - status". Collect all output up until
    # that point.
    APRO_OUTPUT_RE = r'.*(AP RO ([\S]*)![^\n]|do_ap_ro_check: unsupported)'

    # Cr50 tries to recalculate the hash with 8 of the common factory flags.
    FACTORY_FLAG_COUNT = 8
    TIMEOUT_SINGLE_RUN = 60
    TIMEOUT_ALL_FLAGS = FACTORY_FLAG_COUNT * TIMEOUT_SINGLE_RUN
    # If the flags are wrong, verification should fail quickly.
    TIMEOUT_FLAG_FAILURE = 10
    # Delay the gsctool command that starts verification, so the test can start
    # looking for the AP RO verify command output before the gsctool command
    # runs.
    START_DELAY = 5

    DIGEST_RE = r' digest ([0-9a-f]{64})'
    CALCULATED_DIGEST_RE = 'Calculated' + DIGEST_RE
    STORED_DIGEST_RE = 'Stored' + DIGEST_RE

    # The FAFT GBB flags are innocuous. Check that the DUT is using those or
    # doesn't have any flags set.
    SUPPORTED_FLAGS = [0, 0x140]
    TEST_RO_VPD_KEY = 'faft_apro_test_key'

    # 0x42b9 is the last value in the cr50 factory flag list. Use it to verify
    # cr50 can regenerate the hash with all factory flags in a reasonable time.
    LAST_FACTORY_FLAG_VAL = 0x42b9
    FLAG_0 = 0

    FLAGS_NONE = None
    FLAG_42B9 = '0x%x' % LAST_FACTORY_FLAG_VAL
    FLAG_0 = '0x%x' % FLAG_0
    FLAG_NA = 'na'

    # GBB status bits
    GBBS_INJECT_FLAGS = 1
    GBBS_FLAGS_IN_HASH = 2
    GBBD_INVALID = 'na (10)'
    GBBD_SAVED = 'ok (%d)'
    # If the flags are 0, then cr50 won't try to inject them.
    STATUS_0 = GBBS_FLAGS_IN_HASH
    # If the gbb flags are in the hash and they were non-zero when the hash
    # was generated, then cr50 should try to inject them when calculating
    # the hash.
    STATUS_LAST_FLAG = (GBBS_FLAGS_IN_HASH | GBBS_INJECT_FLAGS)
    # The flags aren't in the hash, so they're not injected. Cr50 should save
    # the status as 0.
    STATUS_OUTSIDE_HASH = 0
    GBBD_SAVED_0 = GBBD_SAVED % STATUS_0
    GBBD_SAVED_LAST_FLAG = GBBD_SAVED % STATUS_LAST_FLAG
    GBBD_SAVED_FLAGS_NOT_IN_HASH = GBBD_SAVED % STATUS_OUTSIDE_HASH
    # These messages should never happen. Fail if they show up in any AP RO
    # verificaton output.
    ERR_MESSAGES = ['Could not find GBB area', 'WATCHDOG']

    def initialize(self, host, cmdline_args, full_args={}):
        """Initialize servo"""
        self.ran_test = False
        super(firmware_GSCAPROV1Trigger,
              self).initialize(host,
                               cmdline_args,
                               full_args,
                               restore_cr50_image=True)
        if not self.gsc.ap_ro_version_is_supported(self.TEST_AP_RO_VER):
            raise error.TestNAError('GSC does not support AP RO v%s' %
                                    self.TEST_AP_RO_VER)

        self._original_timeout = float(self.servo.get('cr50_uart_timeout'))
        rw_ver = self.get_saved_cr50_original_version()[1]
        _, major, minor = rw_ver.split('.')
        if (int(major) < self.MIN_RELEASE_MAJOR or
            int(minor) < self.MIN_RELEASE_MINOR):
            raise error.TestNAError('Test does not support cr50 (%r). Update '
                                    'to 0.%s.%s' % (rw_ver,
                                                    self.MIN_RELEASE_MAJOR,
                                                    self.MIN_RELEASE_MINOR))

        dbg_ver = cr50_utils.InstallImage(self.host,
                                          self.get_saved_dbg_image_path(),
                                          '/tmp/cr50.bin')[1][1]
        if cr50_utils.GetNewestVersion(dbg_ver,
                                       self.MIN_DBG_VER) == self.MIN_DBG_VER:
            raise error.TestNAError('Update DBG image to 6.100 or newer.')

        self._start_gbb_flags = self.faft_client.bios.get_gbb_flags()
        logging.info('GBB flags: %x', self._start_gbb_flags)
        # Refuse to run with unsupported gbb flags, because this test sets the
        # flags to 0 and it could prevent the device from booting if it's
        # currently relying on the FORCE_DEV_MODE flag.
        if self._start_gbb_flags not in self.SUPPORTED_FLAGS:
            raise error.TestNaError('Unsupported DUT GBB flags 0x%x. Set the '
                                    'flags to one of %r to run the test.' %
                                    (self._start_gbb_flags,
                                     self.SUPPORTED_FLAGS))

    def run_ro_vpd_cmd(self, cmd):
        """Run RO_VPD command

        @param cmd: the RO vpd command to run
        """
        return self.host.run('vpd -i RO_VPD ' + cmd)

    def delete_test_ro_vpd_key(self):
        """Remove the test key from the RO_VPD"""
        self.run_ro_vpd_cmd('-d ' + self.TEST_RO_VPD_KEY)

    def set_test_ro_vpd_key(self, val):
        """Remove the test key from the RO_VPD"""
        self.run_ro_vpd_cmd('-s %s=%s' % (self.TEST_RO_VPD_KEY, val))

    def restore_ro(self):
        """Restore the original test RO_VPD test key value."""
        self.set_test_ro_vpd_key('original_val')
        self._ro_desc = 'ok'

    def modify_ro(self):
        """Change a RO_VPD value to modify RO."""
        self.set_test_ro_vpd_key('modified_val')
        self._ro_desc = 'modified'

    def update_to_dbg_and_clear_hash(self):
        """Clear the Hash."""
        # Make sure the AP is up before trying to update.
        self.recover_dut()
        self.clear_gbb_flags()
        self._retry_gsc_update_with_ccd_and_ap(self._dbg_image_path, 3, False)
        self.gsc.send_command('ap_ro_info erase')
        time.sleep(3)
        if self.gsc.get_ap_ro_info()['hash']:
            raise error.TestError('Could not erase hash')
        self._try_to_bring_dut_up()

    def after_run_once(self):
        """Reboot cr50 to recover the dut."""
        try:
            self.recover_dut()
        finally:
            super(firmware_GSCAPROV1Trigger, self).after_run_once()

    def set_hash(self, regions):
        """Set the Hash.

        @param regions: a space separated string with the names of the regions
                        to include in the hash. ex "FMAP GBB"
        """
        self.recover_dut()
        result = self.host.run('ap_ro_hash.py -v True %s' % regions)
        logging.info(result)
        time.sleep(3)
        ap_ro_info = self.gsc.get_ap_ro_info()
        self._hash_desc = '%s flags' % self._flag_desc
        ap_ro_info = self.gsc.get_ap_ro_info()
        if ap_ro_info['supported'] and not ap_ro_info['hash']:
            raise error.TestError('Could not set hash %r' % result)

    def rollback_to_release_image(self):
        """Update to the release image."""
        self._retry_gsc_update_with_ccd_and_ap(
                self.get_saved_cr50_original_path(), 3, rollback=True)
        self._try_to_bring_dut_up()

    def set_gbb_flags(self, flags):
        """Set the GBB flags.

        @params flags: integer value to set the gbb flags to.
        """
        self.host.run('/usr/bin/futility gbb --set --flash --flags=0x%x' %
                      flags)
        logging.info('Set GBB: %x', self.faft_client.bios.get_gbb_flags())

    def set_factory_gbb_flags(self):
        """Set the GBB flags to one of the cr50 factory flags."""
        self.set_gbb_flags(self.LAST_FACTORY_FLAG_VAL)
        self._flag_desc = '%x' % self.LAST_FACTORY_FLAG_VAL

    def clear_gbb_flags(self):
        """Set the GBB flags to 0."""
        self.set_gbb_flags(0)
        self._flag_desc = 'cleared'

    def cleanup(self):
        """Clear the hash, remove the test ro vpd key, and restore the flags."""
        try:
            if not self.ran_test:
                return
            logging.info('Cleanup')
            self.recover_dut()
            self.clear_gbb_flags()
            self.update_to_dbg_and_clear_hash()
            self.rollback_to_release_image()
            self.delete_test_ro_vpd_key()
            self.faft_client.bios.set_gbb_flags(self._start_gbb_flags)
        finally:
            super(firmware_GSCAPROV1Trigger, self).cleanup()

    def recover_dut(self):
        """Reboot gsc to recover the dut."""
        logging.info('Recover DUT')
        ap_ro_info = self.gsc.get_ap_ro_info()
        logging.info(ap_ro_info)
        if ap_ro_info['result'] != self.APRO_FAIL:
            self._try_to_bring_dut_up()
            return
        time.sleep(3)
        self.gsc.send_command('ccd testlab open')
        time.sleep(3)
        self.gsc.reboot()
        time.sleep(self.faft_config.delay_reboot_to_ping)
        self.gsc.get_ap_ro_info()
        self._try_to_bring_dut_up()
        self.gsc.send_command('ccd testlab open')

    def verification_in_progress(self):
        """Returns True if AP RO verification is running."""
        return self.gsc.get_ap_ro_info()['result']  == self.APRO_IN_PROGRESS

    def get_apro_output(self, timeout):
        """Get the AP RO console output.

        @param timeout: time in seconds to wait for AP RO verification to
                        finish.
        """
        self.servo.set_nocheck('cr50_uart_timeout', timeout + self.START_DELAY)
        start_time = time.time()
        try:
            # AP RO verification will start in the background. Wait for cr50 to
            # finish verification collect all of the AP RO output.
            cmd = 'noop_wait_apro ' + self._desc
            rv = self.gsc.send_command_get_output(cmd, [self.APRO_OUTPUT_RE])
        finally:
            self.servo.set_nocheck('cr50_uart_timeout', self._original_timeout)
        logging.info('AP RO verification ran in %ds', time.time() - start_time)
        return rv[0][0]

    def _start_apro_verify(self):
        """Start AP RO verification with a delay.

        Delay starting AP RO verification, so the test can get the full
        AP RO console output.
        """
        if not self.host.ping_wait_up(self.faft_config.delay_reboot_to_ping):
            raise error.TestError('AP is %s. Dut is not sshable. ' %
                                  self.cr50.get_ccdstate('AP'))
        apro_start_cmd = utils.sh_escape('sleep %d ; gsctool -aB start' %
                                         self.START_DELAY)
        full_ssh_cmd = '%s "%s"' % (self.host.ssh_command(options='-tt'),
                                    apro_start_cmd)
        # Start running the Cr50 Open process in the background.
        self._apro_start = utils.BgJob(full_ssh_cmd,
                                         nickname='apro_start',
                                         stdout_tee=utils.TEE_TO_LOGS,
                                         stderr_tee=utils.TEE_TO_LOGS)

    def _close_apro_start(self):
        """Terminate the process and check the results."""
        exit_status = utils.nuke_subprocess(self._apro_start.sp)
        delattr(self, '_apro_start')
        if exit_status:
            logging.info('exit status: %d', exit_status)

    def trigger_verification(self,
                             exp_result,
                             exp_calculations,
                             timeout,
                             exp_gbb,
                             exp_flags,
                             end_if_unsupported=True):
        """Trigger verification.

        Trigger verification. Verify the AP RO behavior by checking the result
        matches the expected result. Check that cr50 calculated the expected
        number of hashes within timeout seconds. Check the gbb value from
        ap_ro_info matches exp_gbb and all of the expected strings show up
        in the output.

        @param exp_result: expected value for the ap_ro_info result field after
                           verification runs.
        @param exp_calculations: expected number of hashes cr50 will generate
                                 during verification.
        @param timeout: maximum time in seconds that the AP RO verification run
                        can take.
        @param exp_gbb: string that should be found in the ap_ro_info gbb field.
        @param exp_flags: None or the flag string if the gbbd is saved
        @param end_if_unsupported: raise testNA if the device doesn't support
                                   verification.
        """
        self._desc = ('%s: current flags(%s) ro(%s) saved hash(%s) - '
                      'expected result(%d)' %
                      (self._prefix, self._flag_desc, self._ro_desc,
                       self._hash_desc, exp_result))
        # CCD has to be open to trigger verification.
        self.fast_ccd_open(True)
        logging.info('Run: %s', self._desc)

        self.recover_dut()
        try:
            self._start_apro_verify()
            contents = self.get_apro_output(timeout)
        finally:
            self._close_apro_start()
        logging.info('finished %r:%s', self._desc, contents)

        try:
            if self.verification_in_progress():
                raise error.TestFail('%s: Verification did not finish in %ds' %
                                     (self._desc, timeout))

            for msg in self.ERR_MESSAGES:
                if msg in contents:
                    raise error.TestFail('%s: %r showed up in contents %s' %
                                         (self._desc, msg, contents))
        finally:
            ap_ro_info = self.gsc.get_ap_ro_info()
            # Make sure to recover the dut.
            self.recover_dut()

        # cr50 only prints calculated and stored hashes after AP RO verificaiton
        # fails. These sets will be empty if verification passed every time.
        calculated = set(re.findall(self.CALCULATED_DIGEST_RE, contents))
        stored = set(re.findall(self.STORED_DIGEST_RE, contents))
        logging.info('Stored: %r', stored)
        logging.info('Calculated (%d): %s', len(calculated),
                     pprint.pformat(calculated))
        logging.info('Results: %s', pprint.pformat(ap_ro_info))

        if not ap_ro_info['supported']:
            reason = ap_ro_info['reason']
            if 'not programmed' not in reason:
                if end_if_unsupported:
                    raise error.TestNAError(reason)
                raise error.TestFail('%s: verification unsupported: %s' %
                                     (self._desc, reason))

        if len(calculated) != exp_calculations:
            raise error.TestFail('%s: Calculated %d digests instead of %d' %
                                 (self._desc, len(calculated),
                                  exp_calculations))
        if exp_flags != ap_ro_info['flags']:
            raise error.TestFail(
                    '%s: %r not found in flags %r -- stored: %r calc: %r' %
                    (self._desc, exp_flags, ap_ro_info['flags'], stored,
                     calculated))
        if exp_gbb not in ap_ro_info['gbbd']:
            raise error.TestFail(
                    '%s: %r not found in gbb %r -- stored: %r calc: %r' %
                    (self._desc, exp_gbb, ap_ro_info['gbbd'], stored,
                     calculated))
        if exp_result != ap_ro_info['result']:
            raise error.TestFail(
                    '%s: %r not found in status %r -- stored: %r calc: %r' %
                    (self._desc, exp_result, ap_ro_info['result'], stored,
                     calculated))

    def run_once(self):
        """Save hash and trigger verification"""
        self.ran_test = True
        # The DBG image can set the hash when the board id is saved. The release
        # image can't. Set the hash with the DBG image, so the test doesn't need
        # to erase the board id. This test verifies triggering AP RO
        # verification. It's not about saving the hash. Whenever the test
        # updates the hash, it'll update to the dbg image, set the hash, and
        # then rollback to the released image.
        self.update_to_dbg_and_clear_hash()

        # Generate a hash with the GBB flags set to 0.
        # Set the GBB flags to 0.
        self.clear_gbb_flags()
        # The test creates a RO_VPD key and modifies it to modify RO. It's a
        # bogus key. It doesn't change any device behavior. It's just a way
        # to easily modify RO.
        self.restore_ro()
        self.set_hash('WP_RO')
        self.rollback_to_release_image()
        self.fast_ccd_open(True)

        logging.info('Verifying standard behavior')
        logging.info('the hash was generated with 0 gbb flags')
        self._prefix = 'standard'
        # Set the flags to a non-zero value. Make sure it fails almost
        # immediately because the flags are wrong.
        self.set_factory_gbb_flags()
        # This is a pretty basic test. If the board says verification is
        # unsupported, fail with TestNA.
        self.trigger_verification(self.APRO_FAIL,
                                  0,
                                  self.TIMEOUT_FLAG_FAILURE,
                                  self.GBBD_INVALID,
                                  self.FLAGS_NONE,
                                  end_if_unsupported=True)
        # Modify RO. Cr50 should still fail immediately because the flags are
        # wrong.
        self.modify_ro()
        self.trigger_verification(self.APRO_FAIL, 0,
                                  self.TIMEOUT_FLAG_FAILURE,
                                  self.GBBD_INVALID,
                                  self.FLAGS_NONE)
        self.clear_gbb_flags()
        # Cr50 should try all factory flags and fail with a hash mismatch.
        self.trigger_verification(self.APRO_FAIL, self.FACTORY_FLAG_COUNT,
                                  self.TIMEOUT_ALL_FLAGS,
                                  self.GBBD_INVALID,
                                  self.FLAGS_NONE)
        # Restore RO. Check AP RO verification starts passing.
        self.restore_ro()
        # Verification should pass during the first flag check since the hash
        # was generated with gbb flags set to 0.
        self.trigger_verification(self.APRO_PASS, 0,
                                  self.TIMEOUT_SINGLE_RUN,
                                  self.GBBD_SAVED_0,
                                  self.FLAG_0)
        # Trigger verification multiple times. Make sure it doesn't fail or
        # change.
        self.trigger_verification(self.APRO_PASS, 0,
                                  self.TIMEOUT_SINGLE_RUN,
                                  self.GBBD_SAVED_0,
                                  self.FLAG_0)
        self.trigger_verification(self.APRO_PASS, 0,
                                  self.TIMEOUT_SINGLE_RUN,
                                  self.GBBD_SAVED_0,
                                  self.FLAG_0)
        # With the saved flags AP RO verification should only try one flag. It
        # should fail more quickly.
        self.modify_ro()
        self.trigger_verification(self.APRO_FAIL, 1,
                                  self.TIMEOUT_SINGLE_RUN,
                                  self.GBBD_SAVED_0,
                                  self.FLAG_0)

        # TODO(b/327795084): reenable after flakiness is investigated.
        return
        # Generate a hash with non-zero flags.
        self.update_to_dbg_and_clear_hash()
        self.restore_ro()
        self.set_factory_gbb_flags()
        self.set_hash('WP_RO')
        # Clear the gbb flags, so the test can open ccd.
        self.clear_gbb_flags()
        self.rollback_to_release_image()
        self.fast_ccd_open(True)
        self.set_factory_gbb_flags()

        logging.info('Verifying the gbb workaround')
        logging.info('cr50 can handle hashes generated with non-zero flags')
        self._prefix = 'non-zero factory flags'
        # The gbb flags are non-zero. Cr50 should fail immediately since they're
        # non-zero.
        self.trigger_verification(self.APRO_FAIL, 0,
                                  self.TIMEOUT_SINGLE_RUN,
                                  self.GBBD_INVALID,
                                  self.FLAGS_NONE)

        # The flags are wrong and RO is wrong. Cr50 verifies the flags first, so
        # it should still fail immediately and not generate any hashes.
        self.modify_ro()
        self.trigger_verification(self.APRO_FAIL, 0,
                                  self.TIMEOUT_SINGLE_RUN,
                                  self.GBBD_INVALID,
                                  self.FLAGS_NONE)
        # The flags are ok. RO is wrong. Cr50 should try all factory flags and
        # fail with a hash mismatch.
        self.clear_gbb_flags()
        self.trigger_verification(self.APRO_FAIL, self.FACTORY_FLAG_COUNT,
                                  self.TIMEOUT_ALL_FLAGS,
                                  self.GBBD_INVALID,
                                  self.FLAGS_NONE)
        # The test saved the hash with the last factory flag. Cr50 should
        # calculate hashes with all of the factory flags and pass on the last
        # one.
        self.restore_ro()
        # Cr50 should match the gbb flag and then save it.
        self.trigger_verification(self.APRO_PASS, self.FACTORY_FLAG_COUNT - 1,
                                  self.TIMEOUT_ALL_FLAGS,
                                  self.GBBD_SAVED_LAST_FLAG,
                                  self.FLAG_42B9)
        # The next verification cr50 should load the matched flag and only try
        # that.
        self.trigger_verification(self.APRO_PASS, 0,
                                  self.TIMEOUT_SINGLE_RUN,
                                  self.GBBD_SAVED_LAST_FLAG,
                                  self.FLAG_42B9)
        # RO verificaiton will fail since the RO is changed, but cr50 should
        # only try the flag it matched originally.
        self.modify_ro()
        self.trigger_verification(self.APRO_FAIL, 1,
                                  self.TIMEOUT_SINGLE_RUN,
                                  self.GBBD_SAVED_LAST_FLAG,
                                  self.FLAG_42B9)
        # RO and the flags are wrong, but cr50 shouldn't try to generate a hash.
        # It should fail before that since the flags are wrong.
        self.set_factory_gbb_flags()
        # Cr50 checks the current flags, before it tries to use the saved gbbd.
        # Cr50 will fail with non-zero flags before it loads the gbbd, so
        # LOAD_42B9 shouldn't show up in the result. It should only have the
        # invalid gbb flags messages.
        self.trigger_verification(self.APRO_FAIL, 0,
                                  self.TIMEOUT_FLAG_FAILURE,
                                  self.GBBD_SAVED_LAST_FLAG,
                                  self.FLAG_42B9)

        # After the state is restored to a good state, cr50 should pass again.
        self.clear_gbb_flags()
        self.restore_ro()
        self.trigger_verification(self.APRO_PASS, 0,
                                  self.TIMEOUT_SINGLE_RUN,
                                  self.GBBD_SAVED_LAST_FLAG,
                                  self.FLAG_42B9)
        self.gsc.reboot()
        self._try_to_bring_dut_up()
        # Make sure it works the same after cr50 reboots.
        self.trigger_verification(self.APRO_PASS, 0,
                                  self.TIMEOUT_SINGLE_RUN,
                                  self.GBBD_SAVED_LAST_FLAG,
                                  self.FLAG_42B9)

        # Set a hash with FMAP in the hash and the GBB outside of the hash.
        # Cr50 should not care about the GBB flags in this case.
        self.update_to_dbg_and_clear_hash()
        self.restore_ro()
        self.set_factory_gbb_flags()
        self.set_hash('FMAP RO_VPD')

        self.clear_gbb_flags()
        self.rollback_to_release_image()
        self.fast_ccd_open(True)
        self.set_factory_gbb_flags()

        logging.info('Verifying setup with GBB outside of hash')
        self._prefix = 'gbb outside of hash'

        # GBB flags are non-zero, but they're outside of the hash, so it
        # shouldn't matter.
        self.trigger_verification(self.APRO_PASS, 0,
                                  self.TIMEOUT_SINGLE_RUN,
                                  self.GBBD_SAVED_FLAGS_NOT_IN_HASH,
                                  self.FLAG_NA)
        # GBB flags are now zero, but they're outside of the hash, so it
        # shouldn't matter.
        self.clear_gbb_flags()
        self.trigger_verification(self.APRO_PASS, 0,
                                  self.TIMEOUT_SINGLE_RUN,
                                  self.GBBD_SAVED_FLAGS_NOT_IN_HASH,
                                  self.FLAG_NA)
        # Modify the RO_VPD. It's in the hash, so verification should fail.
        self.modify_ro()
        self.trigger_verification(self.APRO_FAIL, 1,
                                  self.TIMEOUT_SINGLE_RUN,
                                  self.GBBD_SAVED_FLAGS_NOT_IN_HASH,
                                  self.FLAG_NA)

        # Cr50 will fail verification if the FMAP is outside of the hash since
        # it can't trust the GBB location.
        self.update_to_dbg_and_clear_hash()
        self.restore_ro()
        self.clear_gbb_flags()
        self.set_hash('GBB')
        self.rollback_to_release_image()
        self.fast_ccd_open(True)

        logging.info('Verifying setup with FMAP outside of hash')
        self._prefix = 'fmap not in hash'

        # There's no way to pass since FMAP isn't in the hash. The factory
        # process is standard. FMAP should be in the hash.
        self.trigger_verification(self.APRO_FAIL, 0,
                                  self.TIMEOUT_FLAG_FAILURE,
                                  self.GBBD_INVALID,
                                  self.FLAGS_NONE)