fastboot/vendor_boot_img_utils_test.cpp - platform/system/core - Git at Google

 /*
  * Copyright (C) 2021 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>

 #include <filesystem>
 #include <optional>
 #include <string_view>

 #include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/result.h>
 #include <android-base/strings.h>
 #include <bootimg.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <libavb/libavb.h>

 #include "vendor_boot_img_utils.h"

 using android::base::borrowed_fd;
 using android::base::ErrnoError;
 using android::base::GetExecutableDirectory;
 using android::base::ReadFdToString;
 using android::base::Result;
 using testing::AllOf;
 using testing::Each;
 using testing::Eq;
 using testing::HasSubstr;
 using testing::Not;
 using testing::Property;
 using std::string_literals::operator""s;

 // Expect that the Result<T> returned by |expr| is successful, and value matches |result_matcher|.
 #define EXPECT_RESULT(expr, result_matcher)                          \
     EXPECT_THAT(expr, AllOf(Property(&decltype(expr)::ok, Eq(true)), \
                             Property(&decltype(expr)::value, result_matcher)))

 // Expect that the Result<T> returned by |expr| fails, and error message matches |error_matcher|.
 #define EXPECT_ERROR(expr, error_matcher)                                                        \
     do {                                                                                         \
         EXPECT_THAT(                                                                             \
                 expr,                                                                            \
                 AllOf(Property(&decltype(expr)::ok, Eq(false)),                                  \
                       Property(&decltype(expr)::error,                                           \
                                Property(&decltype(expr)::error_type::message, error_matcher)))); \
     } while (0)

 namespace {

 // Wrapper of fstat.
 Result<uint64_t> FileSize(borrowed_fd fd, std::filesystem::path path) {
     struct stat sb;
     if (fstat(fd.get(), &sb) == -1) return ErrnoError() << "fstat(" << path << ")";
     return sb.st_size;
 }

 // Seek to beginning then read the whole file.
 Result<std::string> ReadStartOfFdToString(borrowed_fd fd, std::filesystem::path path) {
     if (lseek64(fd.get(), 0, SEEK_SET) != 0)
         return ErrnoError() << "lseek64(" << path << ", 0, SEEK_SET)";
     std::string content;
     if (!android::base::ReadFdToString(fd, &content)) return ErrnoError() << "read(" << path << ")";
     return content;
 }

 // Round |value| up to page boundary.
 inline uint32_t round_up(uint32_t value, uint32_t page_size) {
     return (value + page_size - 1) / page_size * page_size;
 }

 // Match is successful if |arg| is a zero-padded version of |expected|.
 MATCHER_P(IsPadded, expected, (negation ? "is" : "isn't") + " zero-padded of expected value"s) {
     if (arg.size() < expected.size()) return false;
     if (0 != memcmp(arg.data(), expected.data(), expected.size())) return false;
     auto remainder = std::string_view(arg).substr(expected.size());
     for (char e : remainder)
         if (e != '\0') return false;
     return true;
 }

 // Same as Eq, but don't print the content to avoid spam.
 MATCHER_P(MemEq, expected, (negation ? "is" : "isn't") + " expected value"s) {
     if (arg.size() != expected.size()) return false;
     return 0 == memcmp(arg.data(), expected.data(), expected.size());
 }

 // Expect that |arg| and |expected| has the same AVB footer.
 MATCHER_P(HasSameAvbFooter, expected,
           (negation ? "has" : "does not have") + "expected AVB footer"s) {
     if (expected.size() < AVB_FOOTER_SIZE || arg.size() < AVB_FOOTER_SIZE) return false;
     return std::string_view(expected).substr(expected.size() - AVB_FOOTER_SIZE) ==
            std::string_view(arg).substr(arg.size() - AVB_FOOTER_SIZE);
 }

 // A lazy handle of a file.
 struct TestFileHandle {
     virtual ~TestFileHandle() = default;
     // Lazily call OpenImpl(), cache result in open_result_.
     android::base::Result<void> Open() {
         if (!open_result_.has_value()) open_result_ = OpenImpl();
         return open_result_.value();
     }
     // The original size at the time when the file is opened. If the file has been modified,
     // this field is NOT updated.
     uint64_t size() {
         CHECK(open_result_.has_value());
         return size_;
     }
     // The current size of the file. If the file has been modified since opened,
     // this is updated.
     Result<uint64_t> fsize() {
         CHECK(open_result_.has_value());
         return FileSize(fd_, abs_path_);
     }
     borrowed_fd fd() {
         CHECK(open_result_.has_value());
         return fd_;
     }
     Result<std::string> Read() {
         CHECK(open_result_.has_value());
         return ReadStartOfFdToString(fd_, abs_path_);
     }

   private:
     std::filesystem::path abs_path_;
     uint64_t size_;
     std::optional<android::base::Result<void>> open_result_;
     borrowed_fd fd_{-1};
     // Opens |rel_path_| as a readonly fd, pass it to Transform, and store result to
     // |borrowed_fd_|.
     android::base::Result<void> OpenImpl() {
         android::base::unique_fd read_fd(TEMP_FAILURE_RETRY(
                 open(abs_path_.c_str(), O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_BINARY)));
         if (!read_fd.ok()) return ErrnoError() << "open(" << abs_path_ << ")";
         auto size = FileSize(read_fd, abs_path_);
         if (!size.ok()) return size.error();
         size_ = *size;

         auto borrowed_fd = Transform(abs_path_, std::move(read_fd));
         if (!borrowed_fd.ok()) return borrowed_fd.error();
         fd_ = borrowed_fd.value();

         return {};
     }

   protected:
     // |rel_path| is the relative path under test data directory.
     TestFileHandle(const std::filesystem::path& rel_path)
         : abs_path_(std::move(std::filesystem::path(GetExecutableDirectory()) / rel_path)) {}
     // Given |read_fd|, the readonly fd on the test file, return an fd that's suitable for client
     // to use. Implementation is responsible for managing the lifetime of the returned fd.
     virtual android::base::Result<borrowed_fd> Transform(const std::filesystem::path& abs_path,
                                                          android::base::unique_fd read_fd) = 0;
 };

 // A TestFileHandle where the file is readonly.
 struct ReadOnlyTestFileHandle : TestFileHandle {
     ReadOnlyTestFileHandle(const std::filesystem::path& rel_path) : TestFileHandle(rel_path) {}

   private:
     android::base::unique_fd owned_fd_;
     android::base::Result<borrowed_fd> Transform(const std::filesystem::path&,
                                                  android::base::unique_fd read_fd) override {
         owned_fd_ = std::move(read_fd);
         return owned_fd_;
     }
 };

 // A TestFileHandle where the test file is copies, hence read-writable.
 struct ReadWriteTestFileHandle : TestFileHandle {
     ReadWriteTestFileHandle(const std::filesystem::path& rel_path) : TestFileHandle(rel_path) {}

   private:
     std::unique_ptr<TemporaryFile> temp_file_;

     android::base::Result<borrowed_fd> Transform(const std::filesystem::path& abs_path,
                                                  android::base::unique_fd read_fd) override {
         // Make a copy to avoid writing to test data. Test files are small, so it is okay
         // to read the whole file.
         auto content = ReadStartOfFdToString(read_fd, abs_path);
         if (!content.ok()) return content.error();
         temp_file_ = std::make_unique<TemporaryFile>();
         if (temp_file_->fd == -1)
             return ErrnoError() << "copy " << abs_path << ": open temp file failed";
         if (!android::base::WriteStringToFd(*content, temp_file_->fd))
             return ErrnoError() << "copy " << abs_path << ": write temp file failed";

         return temp_file_->fd;
     }
 };

 class RepackVendorBootImgTestEnv : public ::testing::Environment {
   public:
     virtual void SetUp() {
         OpenTestFile("test_dtb.img", &dtb, &dtb_content);
         OpenTestFile("test_bootconfig.img", &bootconfig, &bootconfig_content);
         OpenTestFile("test_vendor_ramdisk_none.img", &none, &none_content);
         OpenTestFile("test_vendor_ramdisk_platform.img", &platform, &platform_content);
         OpenTestFile("test_vendor_ramdisk_replace.img", &replace, &replace_content);
     }

     std::unique_ptr<TestFileHandle> dtb;
     std::string dtb_content;
     std::unique_ptr<TestFileHandle> bootconfig;
     std::string bootconfig_content;
     std::unique_ptr<TestFileHandle> none;
     std::string none_content;
     std::unique_ptr<TestFileHandle> platform;
     std::string platform_content;
     std::unique_ptr<TestFileHandle> replace;
     std::string replace_content;

   private:
     void OpenTestFile(const char* rel_path, std::unique_ptr<TestFileHandle>* handle,
                       std::string* content) {
         *handle = std::make_unique<ReadOnlyTestFileHandle>(rel_path);
         ASSERT_RESULT_OK((*handle)->Open());
         auto content_res = (*handle)->Read();
         ASSERT_RESULT_OK(content_res);
         *content = *content_res;
     }
 };
 RepackVendorBootImgTestEnv* env = nullptr;

 struct RepackVendorBootImgTestParam {
     std::string vendor_boot_file_name;
     uint32_t expected_header_version;
     friend std::ostream& operator<<(std::ostream& os, const RepackVendorBootImgTestParam& param) {
         return os << param.vendor_boot_file_name;
     }
 };

 class RepackVendorBootImgTest : public ::testing::TestWithParam<RepackVendorBootImgTestParam> {
   public:
     virtual void SetUp() {
         vboot = std::make_unique<ReadWriteTestFileHandle>(GetParam().vendor_boot_file_name);
         ASSERT_RESULT_OK(vboot->Open());
     }
     std::unique_ptr<TestFileHandle> vboot;
 };

 TEST_P(RepackVendorBootImgTest, InvalidSize) {
     EXPECT_ERROR(replace_vendor_ramdisk(vboot->fd(), vboot->size() + 1, "default",
                                         env->replace->fd(), env->replace->size()),
                  HasSubstr("Size of vendor boot does not match"));
     EXPECT_ERROR(replace_vendor_ramdisk(vboot->fd(), vboot->size(), "default", env->replace->fd(),
                                         env->replace->size() + 1),
                  HasSubstr("Size of new vendor ramdisk does not match"));
 }

 TEST_P(RepackVendorBootImgTest, ReplaceUnknown) {
     auto res = replace_vendor_ramdisk(vboot->fd(), vboot->size(), "unknown", env->replace->fd(),
                                       env->replace->size());
     if (GetParam().expected_header_version == 3) {
         EXPECT_ERROR(res, Eq("Require vendor boot header V4 but is V3"));
     } else if (GetParam().expected_header_version == 4) {
         EXPECT_ERROR(res, Eq("Vendor ramdisk 'unknown' not found"));
     }
 }

 TEST_P(RepackVendorBootImgTest, ReplaceDefault) {
     auto old_content = vboot->Read();
     ASSERT_RESULT_OK(old_content);

     ASSERT_RESULT_OK(replace_vendor_ramdisk(vboot->fd(), vboot->size(), "default",
                                             env->replace->fd(), env->replace->size()));
     EXPECT_RESULT(vboot->fsize(), vboot->size()) << "File size should not change after repack";

     auto new_content_res = vboot->Read();
     ASSERT_RESULT_OK(new_content_res);
     std::string_view new_content(*new_content_res);

     auto hdr = reinterpret_cast<const vendor_boot_img_hdr_v3*>(new_content.data());
     ASSERT_EQ(0, memcmp(VENDOR_BOOT_MAGIC, hdr->magic, VENDOR_BOOT_MAGIC_SIZE));
     ASSERT_EQ(GetParam().expected_header_version, hdr->header_version);
     EXPECT_EQ(hdr->vendor_ramdisk_size, env->replace->size());
     EXPECT_EQ(hdr->dtb_size, env->dtb->size());

     auto o = round_up(sizeof(vendor_boot_img_hdr_v3), hdr->page_size);
     auto p = round_up(hdr->vendor_ramdisk_size, hdr->page_size);
     auto q = round_up(hdr->dtb_size, hdr->page_size);

     EXPECT_THAT(new_content.substr(o, p), IsPadded(env->replace_content));
     EXPECT_THAT(new_content.substr(o + p, q), IsPadded(env->dtb_content));

     if (hdr->header_version < 4) return;

     auto hdr_v4 = static_cast<const vendor_boot_img_hdr_v4*>(hdr);
     EXPECT_EQ(hdr_v4->vendor_ramdisk_table_entry_num, 1);
     EXPECT_EQ(hdr_v4->vendor_ramdisk_table_size, 1 * hdr_v4->vendor_ramdisk_table_entry_size);
     EXPECT_GE(hdr_v4->vendor_ramdisk_table_entry_size, sizeof(vendor_ramdisk_table_entry_v4));
     auto entry = reinterpret_cast<const vendor_ramdisk_table_entry_v4*>(&new_content[o + p + q]);
     EXPECT_EQ(entry->ramdisk_offset, 0);
     EXPECT_EQ(entry->ramdisk_size, hdr_v4->vendor_ramdisk_size);
     EXPECT_EQ(entry->ramdisk_type, VENDOR_RAMDISK_TYPE_NONE);

     EXPECT_EQ(hdr_v4->bootconfig_size, env->bootconfig->size());
     auto r = round_up(hdr_v4->vendor_ramdisk_table_size, hdr_v4->page_size);
     auto s = round_up(hdr_v4->bootconfig_size, hdr_v4->page_size);
     EXPECT_THAT(new_content.substr(o + p + q + r, s), IsPadded(env->bootconfig_content));

     EXPECT_THAT(new_content, HasSameAvbFooter(*old_content));
 }

 INSTANTIATE_TEST_SUITE_P(
         RepackVendorBootImgTest, RepackVendorBootImgTest,
         ::testing::Values(RepackVendorBootImgTestParam{"vendor_boot_v3.img", 3},
                           RepackVendorBootImgTestParam{"vendor_boot_v4_with_frag.img", 4},
                           RepackVendorBootImgTestParam{"vendor_boot_v4_without_frag.img", 4}),
         [](const auto& info) {
             return android::base::StringReplace(info.param.vendor_boot_file_name, ".", "_", false);
         });

 std::string_view GetRamdiskName(const vendor_ramdisk_table_entry_v4* entry) {
     auto ramdisk_name = reinterpret_cast<const char*>(entry->ramdisk_name);
     return std::string_view(ramdisk_name, strnlen(ramdisk_name, VENDOR_RAMDISK_NAME_SIZE));
 }

 class RepackVendorBootImgTestV4 : public ::testing::TestWithParam<uint32_t /* ramdisk type */> {
   public:
     virtual void SetUp() {
         vboot = std::make_unique<ReadWriteTestFileHandle>("vendor_boot_v4_with_frag.img");
         ASSERT_RESULT_OK(vboot->Open());
     }
     std::unique_ptr<TestFileHandle> vboot;
 };

 TEST_P(RepackVendorBootImgTestV4, Replace) {
     uint32_t replace_ramdisk_type = GetParam();
     std::string replace_ramdisk_name;
     std::string expect_new_ramdisk_content;
     uint32_t expect_none_size = env->none->size();
     uint32_t expect_platform_size = env->platform->size();
     switch (replace_ramdisk_type) {
         case VENDOR_RAMDISK_TYPE_NONE:
             replace_ramdisk_name = "none_ramdisk";
             expect_new_ramdisk_content = env->replace_content + env->platform_content;
             expect_none_size = env->replace->size();
             break;
         case VENDOR_RAMDISK_TYPE_PLATFORM:
             replace_ramdisk_name = "platform_ramdisk";
             expect_new_ramdisk_content = env->none_content + env->replace_content;
             expect_platform_size = env->replace->size();
             break;
         default:
             LOG(FATAL) << "Ramdisk type " << replace_ramdisk_type
                        << " is not supported by this test.";
     }

     auto old_content = vboot->Read();
     ASSERT_RESULT_OK(old_content);

     ASSERT_RESULT_OK(replace_vendor_ramdisk(vboot->fd(), vboot->size(), replace_ramdisk_name,
                                             env->replace->fd(), env->replace->size()));
     EXPECT_RESULT(vboot->fsize(), vboot->size()) << "File size should not change after repack";

     auto new_content_res = vboot->Read();
     ASSERT_RESULT_OK(new_content_res);
     std::string_view new_content(*new_content_res);

     auto hdr = reinterpret_cast<const vendor_boot_img_hdr_v4*>(new_content.data());
     ASSERT_EQ(0, memcmp(VENDOR_BOOT_MAGIC, hdr->magic, VENDOR_BOOT_MAGIC_SIZE));
     ASSERT_EQ(4, hdr->header_version);
     EXPECT_EQ(hdr->vendor_ramdisk_size, expect_none_size + expect_platform_size);
     EXPECT_EQ(hdr->dtb_size, env->dtb->size());
     EXPECT_EQ(hdr->bootconfig_size, env->bootconfig->size());

     auto o = round_up(sizeof(vendor_boot_img_hdr_v3), hdr->page_size);
     auto p = round_up(hdr->vendor_ramdisk_size, hdr->page_size);
     auto q = round_up(hdr->dtb_size, hdr->page_size);
     auto r = round_up(hdr->vendor_ramdisk_table_size, hdr->page_size);
     auto s = round_up(hdr->bootconfig_size, hdr->page_size);

     EXPECT_THAT(new_content.substr(o, p), IsPadded(expect_new_ramdisk_content));
     EXPECT_THAT(new_content.substr(o + p, q), IsPadded(env->dtb_content));

     // Check changes in table.
     EXPECT_EQ(hdr->vendor_ramdisk_table_entry_num, 2);
     EXPECT_EQ(hdr->vendor_ramdisk_table_size, 2 * hdr->vendor_ramdisk_table_entry_size);
     EXPECT_GE(hdr->vendor_ramdisk_table_entry_size, sizeof(vendor_ramdisk_table_entry_v4));
     auto entry_none =
             reinterpret_cast<const vendor_ramdisk_table_entry_v4*>(&new_content[o + p + q]);
     EXPECT_EQ(entry_none->ramdisk_offset, 0);
     EXPECT_EQ(entry_none->ramdisk_size, expect_none_size);
     EXPECT_EQ(entry_none->ramdisk_type, VENDOR_RAMDISK_TYPE_NONE);
     EXPECT_EQ(GetRamdiskName(entry_none), "none_ramdisk");

     auto entry_platform = reinterpret_cast<const vendor_ramdisk_table_entry_v4*>(
             &new_content[o + p + q + hdr->vendor_ramdisk_table_entry_size]);
     EXPECT_EQ(entry_platform->ramdisk_offset, expect_none_size);
     EXPECT_EQ(entry_platform->ramdisk_size, expect_platform_size);
     EXPECT_EQ(entry_platform->ramdisk_type, VENDOR_RAMDISK_TYPE_PLATFORM);
     EXPECT_EQ(GetRamdiskName(entry_platform), "platform_ramdisk");

     EXPECT_THAT(new_content.substr(o + p + q + r, s), IsPadded(env->bootconfig_content));

     EXPECT_THAT(new_content, HasSameAvbFooter(*old_content));
 }
 INSTANTIATE_TEST_SUITE_P(RepackVendorBootImgTest, RepackVendorBootImgTestV4,
                          ::testing::Values(VENDOR_RAMDISK_TYPE_NONE, VENDOR_RAMDISK_TYPE_PLATFORM),
                          [](const auto& info) {
                              return info.param == VENDOR_RAMDISK_TYPE_NONE ? "none" : "platform";
                          });

 }  // namespace

 int main(int argc, char* argv[]) {
     ::testing::InitGoogleTest(&argc, argv);
     env = static_cast<RepackVendorBootImgTestEnv*>(
             testing::AddGlobalTestEnvironment(new RepackVendorBootImgTestEnv));
     return RUN_ALL_TESTS();
 }
	/*
	* Copyright (C) 2021 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <string.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <unistd.h>

	#include <filesystem>
	#include <optional>
	#include <string_view>

	#include <android-base/file.h>
	#include <android-base/logging.h>
	#include <android-base/result.h>
	#include <android-base/strings.h>
	#include <bootimg.h>
	#include <gmock/gmock.h>
	#include <gtest/gtest.h>
	#include <libavb/libavb.h>

	#include "vendor_boot_img_utils.h"

	using android::base::borrowed_fd;
	using android::base::ErrnoError;
	using android::base::GetExecutableDirectory;
	using android::base::ReadFdToString;
	using android::base::Result;
	using testing::AllOf;
	using testing::Each;
	using testing::Eq;
	using testing::HasSubstr;
	using testing::Not;
	using testing::Property;
	using std::string_literals::operator""s;

	// Expect that the Result<T> returned by \|expr\| is successful, and value matches \|result_matcher\|.
	#define EXPECT_RESULT(expr, result_matcher) \
	EXPECT_THAT(expr, AllOf(Property(&decltype(expr)::ok, Eq(true)), \
	Property(&decltype(expr)::value, result_matcher)))

	// Expect that the Result<T> returned by \|expr\| fails, and error message matches \|error_matcher\|.
	#define EXPECT_ERROR(expr, error_matcher) \
	do { \
	EXPECT_THAT( \
	expr, \
	AllOf(Property(&decltype(expr)::ok, Eq(false)), \
	Property(&decltype(expr)::error, \
	Property(&decltype(expr)::error_type::message, error_matcher)))); \
	} while (0)

	namespace {

	// Wrapper of fstat.
	Result<uint64_t> FileSize(borrowed_fd fd, std::filesystem::path path) {
	struct stat sb;
	if (fstat(fd.get(), &sb) == -1) return ErrnoError() << "fstat(" << path << ")";
	return sb.st_size;
	}

	// Seek to beginning then read the whole file.
	Result<std::string> ReadStartOfFdToString(borrowed_fd fd, std::filesystem::path path) {
	if (lseek64(fd.get(), 0, SEEK_SET) != 0)
	return ErrnoError() << "lseek64(" << path << ", 0, SEEK_SET)";
	std::string content;
	if (!android::base::ReadFdToString(fd, &content)) return ErrnoError() << "read(" << path << ")";
	return content;
	}

	// Round \|value\| up to page boundary.
	inline uint32_t round_up(uint32_t value, uint32_t page_size) {
	return (value + page_size - 1) / page_size * page_size;
	}

	// Match is successful if \|arg\| is a zero-padded version of \|expected\|.
	MATCHER_P(IsPadded, expected, (negation ? "is" : "isn't") + " zero-padded of expected value"s) {
	if (arg.size() < expected.size()) return false;
	if (0 != memcmp(arg.data(), expected.data(), expected.size())) return false;
	auto remainder = std::string_view(arg).substr(expected.size());
	for (char e : remainder)
	if (e != '\0') return false;
	return true;
	}

	// Same as Eq, but don't print the content to avoid spam.
	MATCHER_P(MemEq, expected, (negation ? "is" : "isn't") + " expected value"s) {
	if (arg.size() != expected.size()) return false;
	return 0 == memcmp(arg.data(), expected.data(), expected.size());
	}

	// Expect that \|arg\| and \|expected\| has the same AVB footer.
	MATCHER_P(HasSameAvbFooter, expected,
	(negation ? "has" : "does not have") + "expected AVB footer"s) {
	if (expected.size() < AVB_FOOTER_SIZE \|\| arg.size() < AVB_FOOTER_SIZE) return false;
	return std::string_view(expected).substr(expected.size() - AVB_FOOTER_SIZE) ==
	std::string_view(arg).substr(arg.size() - AVB_FOOTER_SIZE);
	}

	// A lazy handle of a file.
	struct TestFileHandle {
	virtual ~TestFileHandle() = default;
	// Lazily call OpenImpl(), cache result in open_result_.
	android::base::Result<void> Open() {
	if (!open_result_.has_value()) open_result_ = OpenImpl();
	return open_result_.value();
	}
	// The original size at the time when the file is opened. If the file has been modified,
	// this field is NOT updated.
	uint64_t size() {
	CHECK(open_result_.has_value());
	return size_;
	}
	// The current size of the file. If the file has been modified since opened,
	// this is updated.
	Result<uint64_t> fsize() {
	CHECK(open_result_.has_value());
	return FileSize(fd_, abs_path_);
	}
	borrowed_fd fd() {
	CHECK(open_result_.has_value());
	return fd_;
	}
	Result<std::string> Read() {
	CHECK(open_result_.has_value());
	return ReadStartOfFdToString(fd_, abs_path_);
	}

	private:
	std::filesystem::path abs_path_;
	uint64_t size_;
	std::optional<android::base::Result<void>> open_result_;
	borrowed_fd fd_{-1};
	// Opens \|rel_path_\| as a readonly fd, pass it to Transform, and store result to
	// \|borrowed_fd_\|.
	android::base::Result<void> OpenImpl() {
	android::base::unique_fd read_fd(TEMP_FAILURE_RETRY(
	open(abs_path_.c_str(), O_RDONLY \| O_CLOEXEC \| O_NOFOLLOW \| O_BINARY)));
	if (!read_fd.ok()) return ErrnoError() << "open(" << abs_path_ << ")";
	auto size = FileSize(read_fd, abs_path_);
	if (!size.ok()) return size.error();
	size_ = *size;

	auto borrowed_fd = Transform(abs_path_, std::move(read_fd));
	if (!borrowed_fd.ok()) return borrowed_fd.error();
	fd_ = borrowed_fd.value();

	return {};
	}

	protected:
	// \|rel_path\| is the relative path under test data directory.
	TestFileHandle(const std::filesystem::path& rel_path)
	: abs_path_(std::move(std::filesystem::path(GetExecutableDirectory()) / rel_path)) {}
	// Given \|read_fd\|, the readonly fd on the test file, return an fd that's suitable for client
	// to use. Implementation is responsible for managing the lifetime of the returned fd.
	virtual android::base::Result<borrowed_fd> Transform(const std::filesystem::path& abs_path,
	android::base::unique_fd read_fd) = 0;
	};

	// A TestFileHandle where the file is readonly.
	struct ReadOnlyTestFileHandle : TestFileHandle {
	ReadOnlyTestFileHandle(const std::filesystem::path& rel_path) : TestFileHandle(rel_path) {}

	private:
	android::base::unique_fd owned_fd_;
	android::base::Result<borrowed_fd> Transform(const std::filesystem::path&,
	android::base::unique_fd read_fd) override {
	owned_fd_ = std::move(read_fd);
	return owned_fd_;
	}
	};

	// A TestFileHandle where the test file is copies, hence read-writable.
	struct ReadWriteTestFileHandle : TestFileHandle {
	ReadWriteTestFileHandle(const std::filesystem::path& rel_path) : TestFileHandle(rel_path) {}

	private:
	std::unique_ptr<TemporaryFile> temp_file_;

	android::base::Result<borrowed_fd> Transform(const std::filesystem::path& abs_path,
	android::base::unique_fd read_fd) override {
	// Make a copy to avoid writing to test data. Test files are small, so it is okay
	// to read the whole file.
	auto content = ReadStartOfFdToString(read_fd, abs_path);
	if (!content.ok()) return content.error();
	temp_file_ = std::make_unique<TemporaryFile>();
	if (temp_file_->fd == -1)
	return ErrnoError() << "copy " << abs_path << ": open temp file failed";
	if (!android::base::WriteStringToFd(*content, temp_file_->fd))
	return ErrnoError() << "copy " << abs_path << ": write temp file failed";

	return temp_file_->fd;
	}
	};

	class RepackVendorBootImgTestEnv : public ::testing::Environment {
	public:
	virtual void SetUp() {
	OpenTestFile("test_dtb.img", &dtb, &dtb_content);
	OpenTestFile("test_bootconfig.img", &bootconfig, &bootconfig_content);
	OpenTestFile("test_vendor_ramdisk_none.img", &none, &none_content);
	OpenTestFile("test_vendor_ramdisk_platform.img", &platform, &platform_content);
	OpenTestFile("test_vendor_ramdisk_replace.img", &replace, &replace_content);
	}

	std::unique_ptr<TestFileHandle> dtb;
	std::string dtb_content;
	std::unique_ptr<TestFileHandle> bootconfig;
	std::string bootconfig_content;
	std::unique_ptr<TestFileHandle> none;
	std::string none_content;
	std::unique_ptr<TestFileHandle> platform;
	std::string platform_content;
	std::unique_ptr<TestFileHandle> replace;
	std::string replace_content;

	private:
	void OpenTestFile(const char* rel_path, std::unique_ptr<TestFileHandle>* handle,
	std::string* content) {
	*handle = std::make_unique<ReadOnlyTestFileHandle>(rel_path);
	ASSERT_RESULT_OK((*handle)->Open());
	auto content_res = (*handle)->Read();
	ASSERT_RESULT_OK(content_res);
	content = content_res;
	}
	};
	RepackVendorBootImgTestEnv* env = nullptr;

	struct RepackVendorBootImgTestParam {
	std::string vendor_boot_file_name;
	uint32_t expected_header_version;
	friend std::ostream& operator<<(std::ostream& os, const RepackVendorBootImgTestParam& param) {
	return os << param.vendor_boot_file_name;
	}
	};

	class RepackVendorBootImgTest : public ::testing::TestWithParam<RepackVendorBootImgTestParam> {
	public:
	virtual void SetUp() {
	vboot = std::make_unique<ReadWriteTestFileHandle>(GetParam().vendor_boot_file_name);
	ASSERT_RESULT_OK(vboot->Open());
	}
	std::unique_ptr<TestFileHandle> vboot;
	};

	TEST_P(RepackVendorBootImgTest, InvalidSize) {
	EXPECT_ERROR(replace_vendor_ramdisk(vboot->fd(), vboot->size() + 1, "default",
	env->replace->fd(), env->replace->size()),
	HasSubstr("Size of vendor boot does not match"));
	EXPECT_ERROR(replace_vendor_ramdisk(vboot->fd(), vboot->size(), "default", env->replace->fd(),
	env->replace->size() + 1),
	HasSubstr("Size of new vendor ramdisk does not match"));
	}

	TEST_P(RepackVendorBootImgTest, ReplaceUnknown) {
	auto res = replace_vendor_ramdisk(vboot->fd(), vboot->size(), "unknown", env->replace->fd(),
	env->replace->size());
	if (GetParam().expected_header_version == 3) {
	EXPECT_ERROR(res, Eq("Require vendor boot header V4 but is V3"));
	} else if (GetParam().expected_header_version == 4) {
	EXPECT_ERROR(res, Eq("Vendor ramdisk 'unknown' not found"));
	}
	}

	TEST_P(RepackVendorBootImgTest, ReplaceDefault) {
	auto old_content = vboot->Read();
	ASSERT_RESULT_OK(old_content);

	ASSERT_RESULT_OK(replace_vendor_ramdisk(vboot->fd(), vboot->size(), "default",
	env->replace->fd(), env->replace->size()));
	EXPECT_RESULT(vboot->fsize(), vboot->size()) << "File size should not change after repack";

	auto new_content_res = vboot->Read();
	ASSERT_RESULT_OK(new_content_res);
	std::string_view new_content(*new_content_res);

	auto hdr = reinterpret_cast<const vendor_boot_img_hdr_v3*>(new_content.data());
	ASSERT_EQ(0, memcmp(VENDOR_BOOT_MAGIC, hdr->magic, VENDOR_BOOT_MAGIC_SIZE));
	ASSERT_EQ(GetParam().expected_header_version, hdr->header_version);
	EXPECT_EQ(hdr->vendor_ramdisk_size, env->replace->size());
	EXPECT_EQ(hdr->dtb_size, env->dtb->size());

	auto o = round_up(sizeof(vendor_boot_img_hdr_v3), hdr->page_size);
	auto p = round_up(hdr->vendor_ramdisk_size, hdr->page_size);
	auto q = round_up(hdr->dtb_size, hdr->page_size);

	EXPECT_THAT(new_content.substr(o, p), IsPadded(env->replace_content));
	EXPECT_THAT(new_content.substr(o + p, q), IsPadded(env->dtb_content));

	if (hdr->header_version < 4) return;

	auto hdr_v4 = static_cast<const vendor_boot_img_hdr_v4*>(hdr);
	EXPECT_EQ(hdr_v4->vendor_ramdisk_table_entry_num, 1);
	EXPECT_EQ(hdr_v4->vendor_ramdisk_table_size, 1 * hdr_v4->vendor_ramdisk_table_entry_size);
	EXPECT_GE(hdr_v4->vendor_ramdisk_table_entry_size, sizeof(vendor_ramdisk_table_entry_v4));
	auto entry = reinterpret_cast<const vendor_ramdisk_table_entry_v4*>(&new_content[o + p + q]);
	EXPECT_EQ(entry->ramdisk_offset, 0);
	EXPECT_EQ(entry->ramdisk_size, hdr_v4->vendor_ramdisk_size);
	EXPECT_EQ(entry->ramdisk_type, VENDOR_RAMDISK_TYPE_NONE);

	EXPECT_EQ(hdr_v4->bootconfig_size, env->bootconfig->size());
	auto r = round_up(hdr_v4->vendor_ramdisk_table_size, hdr_v4->page_size);
	auto s = round_up(hdr_v4->bootconfig_size, hdr_v4->page_size);
	EXPECT_THAT(new_content.substr(o + p + q + r, s), IsPadded(env->bootconfig_content));

	EXPECT_THAT(new_content, HasSameAvbFooter(*old_content));
	}

	INSTANTIATE_TEST_SUITE_P(
	RepackVendorBootImgTest, RepackVendorBootImgTest,
	::testing::Values(RepackVendorBootImgTestParam{"vendor_boot_v3.img", 3},
	RepackVendorBootImgTestParam{"vendor_boot_v4_with_frag.img", 4},
	RepackVendorBootImgTestParam{"vendor_boot_v4_without_frag.img", 4}),
	[](const auto& info) {
	return android::base::StringReplace(info.param.vendor_boot_file_name, ".", "_", false);
	});

	std::string_view GetRamdiskName(const vendor_ramdisk_table_entry_v4* entry) {
	auto ramdisk_name = reinterpret_cast<const char*>(entry->ramdisk_name);
	return std::string_view(ramdisk_name, strnlen(ramdisk_name, VENDOR_RAMDISK_NAME_SIZE));
	}

	class RepackVendorBootImgTestV4 : public ::testing::TestWithParam<uint32_t /* ramdisk type */> {
	public:
	virtual void SetUp() {
	vboot = std::make_unique<ReadWriteTestFileHandle>("vendor_boot_v4_with_frag.img");
	ASSERT_RESULT_OK(vboot->Open());
	}
	std::unique_ptr<TestFileHandle> vboot;
	};

	TEST_P(RepackVendorBootImgTestV4, Replace) {
	uint32_t replace_ramdisk_type = GetParam();
	std::string replace_ramdisk_name;
	std::string expect_new_ramdisk_content;
	uint32_t expect_none_size = env->none->size();
	uint32_t expect_platform_size = env->platform->size();
	switch (replace_ramdisk_type) {
	case VENDOR_RAMDISK_TYPE_NONE:
	replace_ramdisk_name = "none_ramdisk";
	expect_new_ramdisk_content = env->replace_content + env->platform_content;
	expect_none_size = env->replace->size();
	break;
	case VENDOR_RAMDISK_TYPE_PLATFORM:
	replace_ramdisk_name = "platform_ramdisk";
	expect_new_ramdisk_content = env->none_content + env->replace_content;
	expect_platform_size = env->replace->size();
	break;
	default:
	LOG(FATAL) << "Ramdisk type " << replace_ramdisk_type
	<< " is not supported by this test.";
	}

	auto old_content = vboot->Read();
	ASSERT_RESULT_OK(old_content);

	ASSERT_RESULT_OK(replace_vendor_ramdisk(vboot->fd(), vboot->size(), replace_ramdisk_name,
	env->replace->fd(), env->replace->size()));
	EXPECT_RESULT(vboot->fsize(), vboot->size()) << "File size should not change after repack";

	auto new_content_res = vboot->Read();
	ASSERT_RESULT_OK(new_content_res);
	std::string_view new_content(*new_content_res);

	auto hdr = reinterpret_cast<const vendor_boot_img_hdr_v4*>(new_content.data());
	ASSERT_EQ(0, memcmp(VENDOR_BOOT_MAGIC, hdr->magic, VENDOR_BOOT_MAGIC_SIZE));
	ASSERT_EQ(4, hdr->header_version);
	EXPECT_EQ(hdr->vendor_ramdisk_size, expect_none_size + expect_platform_size);
	EXPECT_EQ(hdr->dtb_size, env->dtb->size());
	EXPECT_EQ(hdr->bootconfig_size, env->bootconfig->size());

	auto o = round_up(sizeof(vendor_boot_img_hdr_v3), hdr->page_size);
	auto p = round_up(hdr->vendor_ramdisk_size, hdr->page_size);
	auto q = round_up(hdr->dtb_size, hdr->page_size);
	auto r = round_up(hdr->vendor_ramdisk_table_size, hdr->page_size);
	auto s = round_up(hdr->bootconfig_size, hdr->page_size);

	EXPECT_THAT(new_content.substr(o, p), IsPadded(expect_new_ramdisk_content));
	EXPECT_THAT(new_content.substr(o + p, q), IsPadded(env->dtb_content));

	// Check changes in table.
	EXPECT_EQ(hdr->vendor_ramdisk_table_entry_num, 2);
	EXPECT_EQ(hdr->vendor_ramdisk_table_size, 2 * hdr->vendor_ramdisk_table_entry_size);
	EXPECT_GE(hdr->vendor_ramdisk_table_entry_size, sizeof(vendor_ramdisk_table_entry_v4));
	auto entry_none =
	reinterpret_cast<const vendor_ramdisk_table_entry_v4*>(&new_content[o + p + q]);
	EXPECT_EQ(entry_none->ramdisk_offset, 0);
	EXPECT_EQ(entry_none->ramdisk_size, expect_none_size);
	EXPECT_EQ(entry_none->ramdisk_type, VENDOR_RAMDISK_TYPE_NONE);
	EXPECT_EQ(GetRamdiskName(entry_none), "none_ramdisk");

	auto entry_platform = reinterpret_cast<const vendor_ramdisk_table_entry_v4*>(
	&new_content[o + p + q + hdr->vendor_ramdisk_table_entry_size]);
	EXPECT_EQ(entry_platform->ramdisk_offset, expect_none_size);
	EXPECT_EQ(entry_platform->ramdisk_size, expect_platform_size);
	EXPECT_EQ(entry_platform->ramdisk_type, VENDOR_RAMDISK_TYPE_PLATFORM);
	EXPECT_EQ(GetRamdiskName(entry_platform), "platform_ramdisk");

	EXPECT_THAT(new_content.substr(o + p + q + r, s), IsPadded(env->bootconfig_content));

	EXPECT_THAT(new_content, HasSameAvbFooter(*old_content));
	}
	INSTANTIATE_TEST_SUITE_P(RepackVendorBootImgTest, RepackVendorBootImgTestV4,
	::testing::Values(VENDOR_RAMDISK_TYPE_NONE, VENDOR_RAMDISK_TYPE_PLATFORM),
	[](const auto& info) {
	return info.param == VENDOR_RAMDISK_TYPE_NONE ? "none" : "platform";
	});

	} // namespace

	int main(int argc, char* argv[]) {
	::testing::InitGoogleTest(&argc, argv);
	env = static_cast<RepackVendorBootImgTestEnv*>(
	testing::AddGlobalTestEnvironment(new RepackVendorBootImgTestEnv));
	return RUN_ALL_TESTS();
	}