/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy,
 * modify, merge, publish, distribute, sublicense, and/or sell copies
 * of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <string.h>

#include <map>
#include <vector>

#include <gtest/gtest.h>

#include <libavb_ab/libavb_ab.h>

#include "avb_unittest_util.h"
#include "fake_avb_ops.h"

namespace avb {

static_assert(sizeof(AvbABSlotData) == 4, "AvbABSlotData has wrong size");
static_assert(sizeof(AvbABData) == AVB_AB_DATA_SIZE,
              "AvbABData has wrong size");
static_assert(offsetof(AvbABData, slots) % 8 == 0,
              "AvbABData slots member has wrong offset");

// Subclass BaseAvbToolTest to check for memory leaks.
class ABTest : public BaseAvbToolTest {
 public:
  ABTest() {}
};

TEST_F(ABTest, InitData) {
  AvbABData data;
  avb_ab_data_init(&data);
  EXPECT_EQ(0,
            strncmp(reinterpret_cast<const char*>(data.magic),
                    AVB_AB_MAGIC,
                    AVB_AB_MAGIC_LEN));
  EXPECT_EQ(AVB_AB_MAX_PRIORITY, data.slots[0].priority);
  EXPECT_EQ(AVB_AB_MAX_TRIES_REMAINING, data.slots[0].tries_remaining);
  EXPECT_EQ(0, data.slots[0].successful_boot);
  EXPECT_EQ(AVB_AB_MAX_PRIORITY - 1, data.slots[1].priority);
  EXPECT_EQ(AVB_AB_MAX_TRIES_REMAINING, data.slots[1].tries_remaining);
  EXPECT_EQ(0, data.slots[1].successful_boot);
  EXPECT_EQ(uint32_t(0), data.crc32);
}

TEST_F(ABTest, DataSerialization) {
  AvbABData data;
  AvbABData serialized;
  AvbABData restored;

  avb_ab_data_init(&data);
  EXPECT_EQ(uint32_t(0), data.crc32);
  avb_ab_data_update_crc_and_byteswap(&data, &serialized);
  EXPECT_NE(uint32_t(0), serialized.crc32);
  EXPECT_TRUE(avb_ab_data_verify_and_byteswap(&serialized, &restored));
  EXPECT_EQ(std::string(reinterpret_cast<const char*>(data.magic), 4),
            std::string(reinterpret_cast<const char*>(restored.magic), 4));
  EXPECT_EQ(data.version_major, restored.version_major);
  EXPECT_EQ(data.version_minor, restored.version_minor);
  EXPECT_EQ(0,
            memcmp(reinterpret_cast<void*>(data.slots),
                   reinterpret_cast<void*>(restored.slots),
                   sizeof(AvbABSlotData) * 2));
}

TEST_F(ABTest, CatchBadCRC) {
  AvbABData data;
  AvbABData serialized;
  AvbABData restored;

  avb_ab_data_init(&data);
  avb_ab_data_update_crc_and_byteswap(&data, &serialized);
  serialized.crc32 += 1;
  EXPECT_FALSE(avb_ab_data_verify_and_byteswap(&serialized, &restored));
}

TEST_F(ABTest, CatchUnsupportedMajorVersion) {
  AvbABData data;
  AvbABData serialized;
  AvbABData restored;

  avb_ab_data_init(&data);
  data.version_major += 1;
  avb_ab_data_update_crc_and_byteswap(&data, &serialized);
  EXPECT_FALSE(avb_ab_data_verify_and_byteswap(&serialized, &restored));
}

TEST_F(ABTest, SupportSameMajorFutureMinorVersion) {
  AvbABData data;
  AvbABData serialized;
  AvbABData restored;

  avb_ab_data_init(&data);
  data.version_minor += 1;
  avb_ab_data_update_crc_and_byteswap(&data, &serialized);
  EXPECT_TRUE(avb_ab_data_verify_and_byteswap(&serialized, &restored));
}

#define MISC_PART_SIZE 8 * 1024

// These values are kept short since they are used in SetMD() and it's
// helpful if the information for a slot fits in one 80-character
// line.
enum SlotValidity {
  SV_OK,   // Slot is valid and verified.
  SV_INV,  // Slot is invalid.
  SV_UNV,  // Slot is valid but unverified.
};

class AvbABFlowTest : public BaseAvbToolTest {
 public:
  AvbABFlowTest() {}

  virtual void SetUp() override {
    BaseAvbToolTest::SetUp();
    ops_.set_partition_dir(testdir_);
    ops_.set_stored_rollback_indexes({{0, 0}, {1, 0}, {2, 0}, {3, 0}});
    ops_.set_stored_is_device_unlocked(false);

    // Create large enough 'misc' partition and initialize it with
    // zeroes.
    std::vector<uint8_t> misc;
    misc.resize(MISC_PART_SIZE);
    base::FilePath misc_path = testdir_.Append("misc.img");
    EXPECT_EQ(misc.size(),
              static_cast<const size_t>(
                  base::WriteFile(misc_path,
                                  reinterpret_cast<const char*>(misc.data()),
                                  misc.size())));

    // We're going to use this key for all images.
    ops_.set_expected_public_key(
        PublicKeyAVB(base::FilePath("test/data/testkey_rsa2048.pem")));
  }

  void GenerateSlot(unsigned int slot_number,
                    SlotValidity slot_validity,
                    uint64_t rollback_boot,
                    uint64_t rollback_odm) {
    std::string boot_name = "boot_a.img";
    std::string vbmeta_name = "vbmeta_a.img";
    std::string odm_name = "odm_a.img";
    if (slot_number > 0) {
      boot_name = "boot_b.img";
      vbmeta_name = "vbmeta_b.img";
      odm_name = "odm_b.img";
    }

    // If asked to make an invalid slot, just generate 1MiB garbage
    // for each the three images in the slot.
    if (slot_validity == SV_INV) {
      GenerateImage(boot_name, 1024 * 1024);
      GenerateImage(vbmeta_name, 1024 * 1024);
      GenerateImage(odm_name, 1024 * 1024);
      return;
    }

    const size_t boot_partition_size = 16 * 1024 * 1024;
    const size_t boot_image_size = 5 * 1024 * 1024;
    base::FilePath boot_path = GenerateImage(boot_name, boot_image_size);
    EXPECT_COMMAND(0,
                   "./avbtool add_hash_footer"
                   " --image %s"
                   " --rollback_index %" PRIu64
                   " --partition_name boot"
                   " --partition_size %zd"
                   " --salt deadbeef",
                   boot_path.value().c_str(),
                   rollback_boot,
                   boot_partition_size);

    const size_t odm_partition_size = 512 * 1024;
    const size_t odm_image_size = 80 * 1024;
    base::FilePath odm_path = GenerateImage(odm_name, odm_image_size);
    EXPECT_COMMAND(0,
                   "./avbtool add_hashtree_footer"
                   " --image %s"
                   " --rollback_index %" PRIu64
                   " --partition_name odm"
                   " --partition_size %zd"
                   " --salt deadbeef"
                   " --algorithm SHA512_RSA4096 "
                   " --key test/data/testkey_rsa4096.pem"
                   " --do_not_generate_fec",
                   odm_path.value().c_str(),
                   rollback_odm,
                   odm_partition_size);

    base::FilePath pk_path = testdir_.Append("testkey_rsa4096.avbpubkey");
    EXPECT_COMMAND(
        0,
        "./avbtool extract_public_key --key test/data/testkey_rsa4096.pem"
        " --output %s",
        pk_path.value().c_str());

    // If requested to make the image unverified, just use another key
    // in the chain_partition descriptor since this will cause
    // avb_slot_verify() to return ERROR_PUBLIC_KEY_REJECTED.
    if (slot_validity == SV_UNV) {
      pk_path = GenerateImage("dummy.avbpubkey", 32);
    }

    GenerateVBMetaImage(vbmeta_name,
                        "SHA256_RSA2048",
                        rollback_boot,
                        base::FilePath("test/data/testkey_rsa2048.pem"),
                        base::StringPrintf("--include_descriptors_from_image %s"
                                           " --chain_partition odm:1:%s",
                                           boot_path.value().c_str(),
                                           pk_path.value().c_str()));
  }

  void SetMD(int a_pri,
             int a_tries,
             bool a_success,
             SlotValidity a_slot_validity,
             uint64_t a_rollback_boot,
             uint64_t a_rollback_odm,
             int b_pri,
             int b_tries,
             bool b_success,
             SlotValidity b_slot_validity,
             uint64_t b_rollback_boot,
             uint64_t b_rollback_odm,
             const std::map<size_t, uint64_t>& stored_rollback_indexes) {
    AvbABData data;
    avb_ab_data_init(&data);
    data.slots[0].priority = a_pri;
    data.slots[0].tries_remaining = a_tries;
    data.slots[0].successful_boot = (a_success ? 1 : 0);
    data.slots[1].priority = b_pri;
    data.slots[1].tries_remaining = b_tries;
    data.slots[1].successful_boot = (b_success ? 1 : 0);
    EXPECT_EQ(AVB_IO_RESULT_OK,
              ops_.avb_ab_ops()->write_ab_metadata(ops_.avb_ab_ops(), &data));
    GenerateSlot(0, a_slot_validity, a_rollback_boot, a_rollback_odm);
    GenerateSlot(1, b_slot_validity, b_rollback_boot, b_rollback_odm);
    ops_.set_stored_rollback_indexes(stored_rollback_indexes);
  }

  std::map<size_t, uint64_t> MakeRollbackIndexes(uint64_t slot_0_value,
                                                 uint64_t slot_1_value) {
    return std::map<size_t, uint64_t>{{0, slot_0_value}, {1, slot_1_value}};
  }

  FakeAvbOps ops_;
};

#define ExpMD(a_pri,                                                          \
              a_tries,                                                        \
              a_success,                                                      \
              b_pri,                                                          \
              b_tries,                                                        \
              b_success,                                                      \
              stored_rollback_indexes)                                        \
  do {                                                                        \
    AvbABData data;                                                           \
    EXPECT_EQ(AVB_IO_RESULT_OK,                                               \
              ops_.avb_ab_ops()->read_ab_metadata(ops_.avb_ab_ops(), &data)); \
    EXPECT_EQ(a_pri, data.slots[0].priority);                                 \
    EXPECT_EQ(a_tries, data.slots[0].tries_remaining);                        \
    EXPECT_EQ(a_success ? 1 : 0, data.slots[0].successful_boot);              \
    EXPECT_EQ(b_pri, data.slots[1].priority);                                 \
    EXPECT_EQ(b_tries, data.slots[1].tries_remaining);                        \
    EXPECT_EQ(b_success ? 1 : 0, data.slots[1].successful_boot);              \
    EXPECT_EQ(stored_rollback_indexes, ops_.get_stored_rollback_indexes());   \
  } while (0);

TEST_F(AvbABFlowTest, MetadataReadAndWrite) {
  AvbABData data;
  AvbABData loaded;

  // First load from an uninitialized 'misc' partition. This should
  // not fail and just returned initialized data.
  EXPECT_EQ(AVB_IO_RESULT_OK, avb_ab_data_read(ops_.avb_ab_ops(), &loaded));
  EXPECT_EQ(AVB_AB_MAX_PRIORITY, loaded.slots[0].priority);
  EXPECT_EQ(AVB_AB_MAX_TRIES_REMAINING, loaded.slots[0].tries_remaining);
  EXPECT_EQ(0, loaded.slots[0].successful_boot);
  EXPECT_EQ(AVB_AB_MAX_PRIORITY - 1, loaded.slots[1].priority);
  EXPECT_EQ(AVB_AB_MAX_TRIES_REMAINING, loaded.slots[1].tries_remaining);
  EXPECT_EQ(0, loaded.slots[1].successful_boot);

  // Then initialize and save well-known A/B metadata and check we
  // read back the same thing.
  avb_ab_data_init(&data);
  data.slots[0].priority = 2;
  data.slots[0].tries_remaining = 3;
  EXPECT_EQ(AVB_IO_RESULT_OK, avb_ab_data_write(ops_.avb_ab_ops(), &data));
  EXPECT_EQ(AVB_IO_RESULT_OK, avb_ab_data_read(ops_.avb_ab_ops(), &loaded));
  EXPECT_EQ(2, loaded.slots[0].priority);
  EXPECT_EQ(3, loaded.slots[0].tries_remaining);
}

TEST_F(AvbABFlowTest, EverythingIsValid) {
  AvbSlotVerifyData* data;
  const char* requested_partitions[] = {"boot", NULL};

  SetMD(14,
        0,
        1,
        SV_OK,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        15,
        0,
        1,
        SV_OK,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(14,
        0,
        1,  // A: pri, tries, successful
        15,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_b", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);

  // Also check the other slot.
  SetMD(15,
        0,
        1,
        SV_OK,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        14,
        0,
        1,
        SV_OK,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(15,
        0,
        1,  // A: pri, tries, successful
        14,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_a", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);
}

TEST_F(AvbABFlowTest, NoBootableSlots) {
  AvbSlotVerifyData* data;
  const char* requested_partitions[] = {"boot", NULL};

  SetMD(0,
        0,
        0,
        SV_OK,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        0,
        0,
        0,
        SV_OK,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_ERROR_NO_BOOTABLE_SLOTS,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(0,
        0,
        0,  // A: pri, tries, successful
        0,
        0,
        0,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_EQ(nullptr, data);
}

TEST_F(AvbABFlowTest, TriesRemainingDecreasing) {
  AvbSlotVerifyData* data;
  const char* requested_partitions[] = {"boot", NULL};

  SetMD(15,
        3,
        0,
        SV_OK,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        0,
        0,
        0,
        SV_OK,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes

  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(15,
        2,
        0,  // A: pri, tries, successful
        0,
        0,
        0,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_a", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);

  // Keep counting down...
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(15,
        1,
        0,  // A: pri, tries, successful
        0,
        0,
        0,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_a", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);

  // Last try...
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(15,
        0,
        0,  // A: pri, tries, successful
        0,
        0,
        0,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_a", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);

  // And we're out of tries. At this point, (15, 0, 0) is normalized
  // to (0, 0, 0) so expect that.
  EXPECT_EQ(AVB_AB_FLOW_RESULT_ERROR_NO_BOOTABLE_SLOTS,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(0,
        0,
        0,  // A: pri, tries, successful
        0,
        0,
        0,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_EQ(nullptr, data);
}

TEST_F(AvbABFlowTest, TryingThenFallback) {
  AvbSlotVerifyData* data;
  const char* requested_partitions[] = {"boot", NULL};

  SetMD(15,
        2,
        0,
        SV_OK,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        14,
        0,
        1,
        SV_OK,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(15,
        1,
        0,  // A: pri, tries, successful
        14,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_a", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);

  // Last try...
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(15,
        0,
        0,  // A: pri, tries, successful
        14,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_a", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);

  // And we're out of tries. Check we fall back to slot B.
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(0,
        0,
        0,  // A: pri, tries, successful
        14,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_b", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);
}

TEST_F(AvbABFlowTest, TriesRemainingNotDecreasingIfNotPriority) {
  AvbSlotVerifyData* data;
  const char* requested_partitions[] = {"boot", NULL};

  SetMD(15,
        0,
        1,
        SV_OK,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        14,
        7,
        0,
        SV_OK,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(15,
        0,
        1,  // A: pri, tries, successful
        14,
        7,
        0,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_a", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);
}

TEST_F(AvbABFlowTest, InvalidSlotIsMarkedAsSuch) {
  AvbSlotVerifyData* data;
  const char* requested_partitions[] = {"boot", NULL};

  // Slot A is invalid.
  SetMD(15,
        0,
        1,
        SV_INV,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        14,
        0,
        1,
        SV_OK,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(0,
        0,
        0,  // A: pri, tries, successful
        14,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_b", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);

  // Slot B is invalid.
  SetMD(15,
        0,
        1,
        SV_OK,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        14,
        0,
        1,
        SV_INV,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(15,
        0,
        1,  // A: pri, tries, successful
        0,
        0,
        0,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_a", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);

  // Both slots are invalid.
  SetMD(15,
        0,
        1,
        SV_INV,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        14,
        0,
        1,
        SV_INV,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_ERROR_NO_BOOTABLE_SLOTS,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(0,
        0,
        0,  // A: pri, tries, successful
        0,
        0,
        0,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_EQ(nullptr, data);
}

TEST_F(AvbABFlowTest, UnverifiedSlotIsMarkedAsSuch) {
  AvbSlotVerifyData* data;
  const char* requested_partitions[] = {"boot", NULL};

  // Slot A fails verification.
  SetMD(15,
        0,
        1,
        SV_UNV,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        14,
        0,
        1,
        SV_OK,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(0,
        0,
        0,  // A: pri, tries, successful
        14,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_b", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);

  // Slot B fails verification.
  SetMD(15,
        0,
        1,
        SV_OK,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        14,
        0,
        1,
        SV_UNV,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(15,
        0,
        1,  // A: pri, tries, successful
        0,
        0,
        0,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_a", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);

  // Both slots fail verification.
  SetMD(15,
        0,
        1,
        SV_UNV,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        14,
        0,
        1,
        SV_UNV,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_ERROR_NO_BOOTABLE_SLOTS,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(0,
        0,
        0,  // A: pri, tries, successful
        0,
        0,
        0,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_EQ(nullptr, data);
}

TEST_F(AvbABFlowTest, RollbackIndexFailures) {
  AvbSlotVerifyData* data;
  const char* requested_partitions[] = {"boot", NULL};

  // Slot A rollback index failure for 'boot'.
  SetMD(15,
        0,
        1,
        SV_OK,
        0,
        2,  // A: pri, tries, success, slot_validity, RIs
        14,
        0,
        1,
        SV_OK,
        2,
        2,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(2, 2));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(0,
        0,
        0,  // A: pri, tries, successful
        14,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(2, 2));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_b", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);

  // Slot A rollback index failure for 'odm'.
  SetMD(15,
        0,
        1,
        SV_OK,
        2,
        0,  // A: pri, tries, success, slot_validity, RIs
        14,
        0,
        1,
        SV_OK,
        2,
        2,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(2, 2));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(0,
        0,
        0,  // A: pri, tries, successful
        14,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(2, 2));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_b", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);
}

TEST_F(AvbABFlowTest, StoredRollbackIndexBumped) {
  AvbSlotVerifyData* data;
  const char* requested_partitions[] = {"boot", NULL};

  SetMD(15,
        0,
        1,
        SV_OK,
        3,
        3,  // A: pri, tries, success, slot_validity, RIs
        14,
        0,
        1,
        SV_OK,
        3,
        3,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(2, 2));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(15,
        0,
        1,  // A: pri, tries, successful
        14,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(3, 3));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_a", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);

  // The case where different partitions have different rollback
  // index values.
  SetMD(15,
        0,
        1,
        SV_OK,
        4,
        9,  // A: pri, tries, success, slot_validity, RIs
        14,
        0,
        1,
        SV_OK,
        5,
        7,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(15,
        0,
        1,  // A: pri, tries, successful
        14,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(4, 7));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_a", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);

  // If the slot with the low RI fails verification (or is invalid),
  // check that these low Rollback Indexs are not taken into account
  // after marking it as unbootable.
  SetMD(15,
        0,
        1,
        SV_INV,
        4,
        9,  // A: pri, tries, success, slot_validity, RIs
        14,
        0,
        1,
        SV_OK,
        5,
        7,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(0,
        0,
        0,  // A: pri, tries, successful
        14,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(5, 7));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_b", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);
}

TEST_F(AvbABFlowTest, MarkSlotActive) {
  SetMD(15,
        0,
        1,
        SV_INV,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        11,
        0,
        1,
        SV_OK,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_IO_RESULT_OK, avb_ab_mark_slot_active(ops_.avb_ab_ops(), 0));
  ExpMD(15,
        7,
        0,  // A: pri, tries, successful
        11,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes

  // Note how priority of slot A is altered to make room for newly
  // activated slot.
  SetMD(15,
        0,
        1,
        SV_INV,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        14,
        0,
        1,
        SV_OK,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_IO_RESULT_OK, avb_ab_mark_slot_active(ops_.avb_ab_ops(), 1));
  ExpMD(14,
        0,
        1,  // A: pri, tries, successful
        15,
        7,
        0,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
}

TEST_F(AvbABFlowTest, MarkSlotUnbootable) {
  SetMD(15,
        0,
        1,
        SV_INV,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        11,
        0,
        1,
        SV_OK,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_IO_RESULT_OK,
            avb_ab_mark_slot_unbootable(ops_.avb_ab_ops(), 0));
  ExpMD(0,
        0,
        0,  // A: pri, tries, successful
        11,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes

  SetMD(15,
        0,
        1,
        SV_INV,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        14,
        0,
        1,
        SV_OK,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_IO_RESULT_OK,
            avb_ab_mark_slot_unbootable(ops_.avb_ab_ops(), 1));
  ExpMD(15,
        0,
        1,  // A: pri, tries, successful
        0,
        0,
        0,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
}

TEST_F(AvbABFlowTest, MarkSlotSuccessful) {
  SetMD(15,
        5,
        0,
        SV_INV,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        11,
        3,
        0,
        SV_OK,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_IO_RESULT_OK,
            avb_ab_mark_slot_successful(ops_.avb_ab_ops(), 0));
  ExpMD(15,
        0,
        1,  // A: pri, tries, successful
        11,
        3,
        0,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes

  SetMD(15,
        5,
        0,
        SV_INV,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        14,
        0,
        1,
        SV_OK,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_IO_RESULT_OK,
            avb_ab_mark_slot_successful(ops_.avb_ab_ops(), 1));
  ExpMD(15,
        5,
        0,  // A: pri, tries, successful
        14,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes

  // Marking an unbootable slot (A) as successful won't work (it's a
  // programmer error to do so)... notice however that the unbootable
  // slot is normalized in the process.
  SetMD(0,
        3,
        2,
        SV_INV,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        14,
        0,
        1,
        SV_OK,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_IO_RESULT_OK,
            avb_ab_mark_slot_successful(ops_.avb_ab_ops(), 0));
  ExpMD(0,
        0,
        0,  // A: pri, tries, successful
        14,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
}

static AvbABData my_serialized_data;

static AvbIOResult my_write_ab_metadata(AvbABOps* ops,
                                        const struct AvbABData* data) {
  avb_ab_data_update_crc_and_byteswap(data, &my_serialized_data);
  return AVB_IO_RESULT_OK;
}

static AvbIOResult my_read_ab_metadata(AvbABOps* ops, struct AvbABData* data) {
  if (!avb_ab_data_verify_and_byteswap(&my_serialized_data, data)) {
    avb_error(
        "Error validating A/B metadata from persistent storage. "
        "Resetting and writing new A/B metadata to persistent storage.\n");
    avb_ab_data_init(data);
    return my_write_ab_metadata(ops, data);
  }
  return AVB_IO_RESULT_OK;
}

TEST_F(AvbABFlowTest, OtherMetadataStorage) {
  AvbSlotVerifyData* data;
  const char* requested_partitions[] = {"boot", NULL};

  // Use our own A/B storage routines (see above).
  ops_.avb_ab_ops()->read_ab_metadata = my_read_ab_metadata;
  ops_.avb_ab_ops()->write_ab_metadata = my_write_ab_metadata;

  SetMD(14,
        0,
        1,
        SV_OK,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        15,
        0,
        1,
        SV_OK,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(14,
        0,
        1,  // A: pri, tries, successful
        15,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_b", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);

  // Also check the other slot.
  SetMD(15,
        0,
        1,
        SV_OK,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        14,
        0,
        1,
        SV_OK,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_NONE,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(15,
        0,
        1,  // A: pri, tries, successful
        14,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_a", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);

  // Check that 'misc' hasn't been written to at all.
  std::string misc_data;
  base::FilePath misc_path = testdir_.Append("misc.img");
  ASSERT_TRUE(base::ReadFileToString(misc_path, &misc_data));
  EXPECT_EQ(size_t(MISC_PART_SIZE), misc_data.size());
  for (size_t n = 0; n < misc_data.size(); n++) {
    ASSERT_EQ(uint8_t(misc_data[n]), 0);
  }
}

TEST_F(AvbABFlowTest, UnlockedUnverifiedSlot) {
  AvbSlotVerifyData* data;
  const char* requested_partitions[] = {"boot", NULL};

  SetMD(14,
        0,
        1,
        SV_OK,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        15,
        0,
        1,
        SV_UNV,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK_WITH_VERIFICATION_ERROR,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_ALLOW_VERIFICATION_ERROR,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(14,
        0,
        1,  // A: pri, tries, successful
        15,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_b", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);

  // Also check the other slot.
  SetMD(15,
        0,
        1,
        SV_UNV,
        0,
        0,  // A: pri, tries, success, slot_validity, RIs
        14,
        0,
        1,
        SV_OK,
        0,
        0,  // B: pri, tries, success, slot_validity, RIs
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  EXPECT_EQ(AVB_AB_FLOW_RESULT_OK_WITH_VERIFICATION_ERROR,
            avb_ab_flow(ops_.avb_ab_ops(),
                        requested_partitions,
                        AVB_SLOT_VERIFY_FLAGS_ALLOW_VERIFICATION_ERROR,
                        AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
                        &data));
  ExpMD(15,
        0,
        1,  // A: pri, tries, successful
        14,
        0,
        1,                           // B: pri, tries, successful
        MakeRollbackIndexes(0, 0));  // stored_rollback_indexes
  ASSERT_NE(nullptr, data);
  EXPECT_EQ("_a", std::string(data->ab_suffix));
  avb_slot_verify_data_free(data);
}

TEST_F(AvbABFlowTest, AvbtoolMetadataGeneratorEmptyFile) {
  AvbABData data;

  base::FilePath misc_path = testdir_.Append("misc.img");
  EXPECT_COMMAND(0,
                 "./avbtool set_ab_metadata"
                 " --misc_image %s"
                 " --slot_data 13:3:0:11:2:1",
                 misc_path.value().c_str());

  EXPECT_EQ(AVB_IO_RESULT_OK,
            ops_.avb_ab_ops()->read_ab_metadata(ops_.avb_ab_ops(), &data));
  EXPECT_EQ(13, data.slots[0].priority);
  EXPECT_EQ(3, data.slots[0].tries_remaining);
  EXPECT_EQ(0, data.slots[0].successful_boot);
  EXPECT_EQ(11, data.slots[1].priority);
  EXPECT_EQ(2, data.slots[1].tries_remaining);
  EXPECT_EQ(1, data.slots[1].successful_boot);
}

TEST_F(AvbABFlowTest, AvbtoolMetadataGeneratorExistingFile) {
  AvbABData data;
  size_t n;

  size_t misc_size = 1024 * 1024;
  base::FilePath misc_path = GenerateImage("misc.img", misc_size);
  EXPECT_COMMAND(0,
                 "./avbtool set_ab_metadata"
                 " --misc_image %s"
                 " --slot_data 12:2:1:10:5:0",
                 misc_path.value().c_str());

  EXPECT_EQ(AVB_IO_RESULT_OK,
            ops_.avb_ab_ops()->read_ab_metadata(ops_.avb_ab_ops(), &data));
  EXPECT_EQ(12, data.slots[0].priority);
  EXPECT_EQ(2, data.slots[0].tries_remaining);
  EXPECT_EQ(1, data.slots[0].successful_boot);
  EXPECT_EQ(10, data.slots[1].priority);
  EXPECT_EQ(5, data.slots[1].tries_remaining);
  EXPECT_EQ(0, data.slots[1].successful_boot);

  std::string misc_data;
  ASSERT_TRUE(base::ReadFileToString(misc_path, &misc_data));
  EXPECT_EQ(misc_size, misc_data.size());
  for (n = 0; n < 2048; n++) {
    ASSERT_EQ(uint8_t(misc_data[n]), uint8_t(n));
  }
  for (n = 2048 + 32; n < misc_data.size(); n++) {
    ASSERT_EQ(uint8_t(misc_data[n]), uint8_t(n));
  }
}

}  // namespace avb