aosp/update_attempter_android_integration_test.cc - platform/system/update_engine - 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 <algorithm>

            
            #include <memory>

            
            #include <string>

            
            #include <utility>


            #include <fcntl.h>

            
            #include <sys/sendfile.h>

            
            #include <unistd.h>


            #include <android-base/strings.h>

            
            #include <brillo/data_encoding.h>

            
            #include <brillo/message_loops/fake_message_loop.h>

            
            #include <bsdiff/bsdiff.h>

            
            #include <gtest/gtest.h>

            
            #include <liblp/builder.h>

            
            #include <fs_mgr.h>

            
            #include <liblp/liblp.h>


            #include "update_engine/aosp/boot_control_android.h"

            
            #include "update_engine/aosp/daemon_state_android.h"

            
            #include "update_engine/aosp/update_attempter_android.h"

            
            #include "update_engine/common/constants.h"

            
            #include "update_engine/common/fake_boot_control.h"

            
            #include "update_engine/common/fake_hardware.h"

            
            #include "update_engine/common/hash_calculator.h"

            
            #include "update_engine/common/prefs.h"

            
            #include "update_engine/common/test_utils.h"

            
            #include "update_engine/common/testing_constants.h"

            
            #include "update_engine/common/utils.h"

            
            #include "update_engine/payload_consumer/file_descriptor.h"

            
            #include "update_engine/payload_consumer/install_plan.h"

            
            #include "update_engine/payload_consumer/payload_constants.h"

            
            #include "update_engine/payload_generator/delta_diff_generator.h"

            
            #include "update_engine/payload_generator/extent_ranges.h"

            
            #include "update_engine/payload_generator/payload_file.h"

            
            #include "update_engine/payload_generator/payload_signer.h"

            
            #include "update_engine/update_metadata.pb.h"

            
            #include "update_engine/update_status_utils.h"


            namespace chromeos_update_engine {


            class UpdateAttempterAndroidIntegrationTest : public ::testing::Test,

            
                                                          public ServiceObserverInterface {

            
              void AddFakePartitionGroup() {

            
                dynamic_control_ = boot_control_.dynamic_control_.get();

            
                auto super_device = dynamic_control_->GetSuperDevice();

            
                ASSERT_TRUE(super_device.has_value());

            
                super_device_ = super_device->value();

            
                builder_ = android::fs_mgr::MetadataBuilder::New(

            
                    super_device->value(), boot_control_.GetCurrentSlot());

            
                ASSERT_NE(builder_, nullptr);


                // Remove dangling fake partitions, if test crashed before they might not

            
                // get cleaned up properly.

            
                RemoveFakePartitionGroup();

            
                ASSERT_TRUE(builder_->AddGroup("fake_group", kFakePartitionSize * 2));

            
                ExportPartitionTable();

            
              }

            
              void RemoveFakePartitionGroup() {

            
                builder_->RemovePartition("fake_a");

            
                builder_->RemovePartition("fake_b");

            
                builder_->RemoveGroupAndPartitions("fake_group");

            
              }


              // Fill partition |path| with arbitrary data.

            
              void FillPartition(const std::string& path, const bool is_source) {

            
                std::array<uint8_t, kBlockSize> data;

            
                EintrSafeFileDescriptor fd;

            
                fd.Open(path.c_str(), O_RDWR);

            
                for (size_t i = 0; i < kFakePartitionSize / kBlockSize; i++) {

            
                  if (is_source) {

            
                    std::fill(data.begin(), data.end(), i);

            
                  } else {

            
                    std::fill(

            
                        data.begin(), data.end(), kFakePartitionSize / kBlockSize - i - 1);

            
                  }

            
                  fd.Write(data.data(), kBlockSize);

            
                }

            
              }


              void SetUp() override {

            
                FillPartition(old_part_.path(), true);

            
                FillPartition(new_part_.path(), false);

            
                ASSERT_TRUE(boot_control_.Init());

            
                if (!DynamicPartitionEnabled()) {

            
                  return;

            
                }

            
                ASSERT_NO_FATAL_FAILURE(AddFakePartitionGroup());

            
                message_loop_.SetAsCurrent();

            
                // Set official build to false so that hash checks are non-mandatory

            
                hardware_.SetIsOfficialBuild(false);

            
                truncate64(blob_file_.path().c_str(), 0);


                update_attempter_android_.set_update_certificates_path(

            
                    test_utils::GetBuildArtifactsPath(kUnittestOTACertsPath));


                // Basic setup to create VABC OTA

            
                manifest_.set_partial_update(true);

            
                manifest_.set_minor_version(kPartialUpdateMinorPayloadVersion);

            
                auto dap_group =

            
                    manifest_.mutable_dynamic_partition_metadata()->add_groups();

            
                dap_group->set_name("fake_group");

            
                dap_group->add_partition_names("fake");


                manifest_.mutable_dynamic_partition_metadata()->set_snapshot_enabled(true);

            
                manifest_.mutable_dynamic_partition_metadata()->set_vabc_enabled(true);

            
                manifest_.mutable_dynamic_partition_metadata()->set_cow_version(

            
                    android::snapshot::kCowVersionMajor);

            
              }


              void TearDown() override {

            
                if (!builder_ || !DynamicPartitionEnabled()) {

            
                  return;

            
                }

            
                auto dynamic_control = boot_control_.GetDynamicPartitionControl();

            
                if (dynamic_control) {

            
                  dynamic_control->UnmapAllPartitions();

            
                  dynamic_control->ResetUpdate(&prefs_);

            
                }

            
                RemoveFakePartitionGroup();

            
                ExportPartitionTable();

            
              }


              void CreateFakePartition() {

            
                // Create a fake partition for testing purposes

            
                auto partition_a = builder_->AddPartition(

            
                    boot_control_.GetCurrentSlot() == 0 ? "fake_a" : "fake_b",

            
                    "fake_group",

            
                    0);

            
                ASSERT_NE(partition_a, nullptr);

            
                ASSERT_TRUE(builder_->ResizePartition(partition_a, kFakePartitionSize));

            
                ExportPartitionTable();

            
                std::string source_part;

            
                ASSERT_TRUE(

            
                    dynamic_control_->GetPartitionDevice("fake",

            
                                                         boot_control_.GetCurrentSlot(),

            
                                                         boot_control_.GetCurrentSlot(),

            
                                                         &source_part));

            
                int out_fd = open(source_part.c_str(), O_RDWR);

            
                ScopedFdCloser closer{&out_fd};

            
                ASSERT_GE(out_fd, 0) << android::base::ErrnoNumberAsString(errno);

            
                ASSERT_TRUE(utils::SendFile(out_fd, old_part_.fd(), kFakePartitionSize));

            
              }


              void SendStatusUpdate(

            
                  const update_engine::UpdateEngineStatus& update_engine_status) override {

            
                LOG(INFO) << UpdateStatusToString(update_engine_status.status) << ", "

            
                          << update_engine_status.progress;

            
              }


              // Called whenever an update attempt is completed.

            
              void SendPayloadApplicationComplete(ErrorCode error_code) override {

            
                completion_code_ = error_code;

            
              }


              void ExportPartitionTable() {

            
                auto metadata = builder_->Export();

            
                ASSERT_NE(metadata, nullptr);

            
                android::fs_mgr::UpdatePartitionTable(

            
                    super_device_, *metadata, boot_control_.GetCurrentSlot());

            
              }


             public:

            
              bool DynamicPartitionEnabled() {

            
                auto dynamic_control = boot_control_.GetDynamicPartitionControl();

            
                return dynamic_control &&

            
                       dynamic_control->GetDynamicPartitionsFeatureFlag().IsEnabled();

            
              }

            
              void AddSignatureInfoToPayload(DeltaArchiveManifest* manifest,

            
                                             const std::string& private_key_path) {

            
                size_t total_blob_size = 0;

            
                for (const auto& part : manifest->partitions()) {

            
                  for (const auto& op : part.operations()) {

            
                    if (!op.has_data_offset())

            
                      continue;

            
                    ASSERT_EQ(total_blob_size, op.data_offset())

            
                        << "Ops not ordered by blob isze";

            
                    total_blob_size += op.data_length();

            
                  }

            
                }

            
                // Signatures appear at the end of the blobs. Note the offset in the

            
                // |manifest_|.

            
                uint64_t signature_blob_length = 0;

            
                if (!private_key_path.empty()) {

            
                  ASSERT_TRUE(PayloadSigner::SignatureBlobLength({private_key_path},

            
                                                                 &signature_blob_length));

            
                  PayloadSigner::AddSignatureToManifest(

            
                      total_blob_size, signature_blob_length, manifest);

            
                }

            
              }


              // Generate blob data according to ops specified in the manifest.

            
              // Also update |new_part_|'s content to match expectation of ops.

            
              void HydratePayload(DeltaArchiveManifest* manifest) {

            
                for (auto& partition : *manifest->mutable_partitions()) {

            
                  for (auto& op : *partition.mutable_operations()) {

            
                    if (op.type() == InstallOperation::REPLACE) {

            
                      ASSERT_GE(lseek64(blob_file_.fd(), op.data_offset(), SEEK_SET), 0);

            
                      ASSERT_TRUE(utils::SendFile(

            
                          new_part_.fd(), blob_file_.fd(), op.data_length()));

            
                    } else if (op.type() == InstallOperation::BROTLI_BSDIFF) {

            
                      brillo::Blob old_data;

            
                      ASSERT_TRUE(utils::ReadExtents(

            
                          old_part_.path(), op.src_extents(), &old_data, kBlockSize))

            
                          << "Failed to read source data: "

            
                          << android::base::ErrnoNumberAsString(errno);

            
                      brillo::Blob new_data;

            
                      ASSERT_TRUE(utils::ReadExtents(

            
                          new_part_.path(), op.dst_extents(), &new_data, kBlockSize))

            
                          << "Failed to read target data: "

            
                          << android::base::ErrnoNumberAsString(errno);

            
                      ScopedTempFile patch_file{"bspatch.XXXXXX", true};

            
                      ASSERT_EQ(bsdiff::bsdiff(old_data.data(),

            
                                               old_data.size(),

            
                                               new_data.data(),

            
                                               new_data.size(),

            
                                               patch_file.path().c_str(),

            
                                               nullptr),

            
                                0);

            
                      op.set_data_length(utils::FileSize(patch_file.fd()));

            
                      const auto offset = lseek64(blob_file_.fd(), 0, SEEK_CUR);

            
                      ASSERT_GE(offset, 0);

            
                      op.set_data_offset(offset);

            
                      brillo::Blob src_data_hash;

            
                      HashCalculator::RawHashOfData(old_data, &src_data_hash);

            
                      op.set_src_sha256_hash(src_data_hash.data(), src_data_hash.size());

            
                      utils::SendFile(blob_file_.fd(), patch_file.fd(), op.data_length());


                    } else if (op.type() == InstallOperation::ZERO) {

            
                      auto zero = utils::GetReadonlyZeroString(

            
                          utils::BlocksInExtents(op.dst_extents()) * kBlockSize);

            
                      for (const auto& ext : op.dst_extents()) {

            
                        utils::PWriteAll(new_part_.fd(),

            
                                         zero.data(),

            
                                         ext.num_blocks() * kBlockSize,

            
                                         ext.start_block() * kBlockSize);

            
                      }

            
                    } else if (op.type() == InstallOperation::SOURCE_COPY) {

            
                      brillo::Blob data;

            
                      ASSERT_TRUE(utils::ReadExtents(

            
                          old_part_.path(), op.src_extents(), &data, kBlockSize));

            
                      ASSERT_TRUE(utils::WriteExtents(

            
                          new_part_.path(), op.dst_extents(), data, kBlockSize));

            
                    } else {

            
                      FAIL() << "Unsupported install op type: " << op.type();

            
                    }

            
                  }

            
                }

            
              }


              void ApplyPayload(DeltaArchiveManifest* manifest) {

            
                ASSERT_FALSE(manifest->partitions().empty());

            
                ASSERT_NO_FATAL_FAILURE(HydratePayload(manifest));

            
                const auto private_key_path =

            
                    test_utils::GetBuildArtifactsPath(kUnittestPrivateKeyPath);

            
                ASSERT_NO_FATAL_FAILURE(

            
                    AddSignatureInfoToPayload(manifest, private_key_path));


                brillo::Blob hash;

            
                HashCalculator::RawHashOfFile(new_part_.path(), &hash);

            
                auto partition = &manifest->mutable_partitions()->at(0);

            
                partition->mutable_new_partition_info()->set_size(kFakePartitionSize);

            
                partition->mutable_new_partition_info()->set_hash(hash.data(), hash.size());

            
                const bool source_exist =

            
                    std::any_of(partition->operations().begin(),

            
                                partition->operations().end(),

            
                                [](const auto& op) { return op.src_extents_size() > 0; });

            
                if (source_exist) {

            
                  HashCalculator::RawHashOfFile(old_part_.path(), &hash);

            
                  partition->mutable_old_partition_info()->set_size(kFakePartitionSize);

            
                  partition->mutable_old_partition_info()->set_hash(hash.data(),

            
                                                                    hash.size());

            
                  // Only create fake partition if the update is incremental

            
                  LOG(INFO) << "Creating fake partition";

            
                  ASSERT_NO_FATAL_FAILURE(CreateFakePartition());

            
                }

            
                uint64_t metadata_size = 0;

            
                ASSERT_TRUE(PayloadFile::WritePayload(payload_file_.path(),

            
                                                      blob_file_.path(),

            
                                                      private_key_path,

            
                                                      kBrilloMajorPayloadVersion,

            
                                                      *manifest,

            
                                                      &metadata_size));

            
                LOG(INFO) << "Signature offset: " << manifest->signatures_offset()

            
                          << ", Signature size: " << manifest->signatures_size();

            
                brillo::ErrorPtr error;

            
                HashCalculator::RawHashOfFile(payload_file_.path(), &hash);

            
                daemon_state_.AddObserver(this);

            
                ASSERT_TRUE(update_attempter_android_.ApplyPayload(

            
                    "file://" + payload_file_.path(),

            
                    0,

            
                    utils::FileSize(payload_file_.path()),

            
                    {kPayloadPropertyMetadataSize + ("=" + std::to_string(metadata_size)),

            
                     kPayloadPropertyFileHash +

            
                         ("=" + brillo::data_encoding::Base64Encode(hash))},

            
                    &error));

            
                brillo::MessageLoop::current()->Run();

            
                if (error) {

            
                  LOG(ERROR) << error->GetMessage();

            
                }

            
                ASSERT_EQ(error, nullptr);

            
                ASSERT_EQ(completion_code_, ErrorCode::kSuccess);

            
              }


              // Compare contents of fake_b partition to |new_part_| and print difference

            
              void DumpTargetPartitionDiff() {

            
                dynamic_control_->MapAllPartitions();

            
                auto partition_device =

            
                    dynamic_control_->GetPartitionDevice("fake",

            
                                                         1 - boot_control_.GetCurrentSlot(),

            
                                                         boot_control_.GetCurrentSlot(),

            
                                                         false);

            
                if (!partition_device.has_value()) {

            
                  LOG(INFO) << "Failed to get target fake partition, skip diff report";

            
                  return;

            
                }


                EintrSafeFileDescriptor actual_part;

            
                CHECK(actual_part.Open(partition_device->readonly_device_path.c_str(),

            
                                       O_RDONLY));

            
                EintrSafeFileDescriptor expected_part;

            
                CHECK(expected_part.Open(new_part_.path().c_str(), O_RDONLY));


                std::array<uint8_t, kBlockSize> actual_block;

            
                std::array<uint8_t, kBlockSize> expected_block;

            
                for (size_t i = 0; i < kFakePartitionSize / kBlockSize; i++) {

            
                  actual_part.Read(actual_block.data(), actual_block.size());

            
                  expected_part.Read(expected_block.data(), expected_block.size());

            
                  if (actual_block != expected_block) {

            
                    LOG(ERROR) << "Block " << i << " differs.";

            
                  }

            
                }

            
              }

            
              // use 25MB max to avoid super not having enough space

            
              static constexpr size_t kFakePartitionSize = 1024 * 1024 * 25;

            
              static_assert(kFakePartitionSize % kBlockSize == 0);

            
              BootControlAndroid boot_control_;


              std::unique_ptr<android::fs_mgr::MetadataBuilder> builder_;

            
              std::string super_device_;

            
              FakeHardware hardware_;

            
              ScopedTempFile payload_file_;

            
              ScopedTempFile blob_file_{"blob_file.XXXXXX", true};

            
              // Contains expected data for old partition. Will be copied to fake_a on test

            
              // start.

            
              ScopedTempFile old_part_{"old_part.XXXXXX", true, kFakePartitionSize};

            
              // Expected data for new partition, will be compared against actual data in

            
              // fake_b once test finishes.

            
              ScopedTempFile new_part_{"new_part.XXXXXX", true, kFakePartitionSize};

            
              DaemonStateAndroid daemon_state_;

            
              MemoryPrefs prefs_;

            
              ErrorCode completion_code_;

            
              DynamicPartitionControlAndroid* dynamic_control_{nullptr};

            
              brillo::FakeMessageLoop message_loop_{nullptr};


              DeltaArchiveManifest manifest_;

            
              UpdateAttempterAndroid update_attempter_android_{

            
                  &daemon_state_, &prefs_, &boot_control_, &hardware_, nullptr};

            
            };


            namespace {


            TEST_F(UpdateAttempterAndroidIntegrationTest, NewPartitionTest) {

            
              if (!DynamicPartitionEnabled()) {

            
                return;

            
              }

            
              auto partition = manifest_.add_partitions();

            
              partition->set_partition_name("fake");

            
              partition->set_estimate_cow_size(kFakePartitionSize);

            
              {

            
                auto op = partition->add_operations();

            
                op->set_type(InstallOperation::REPLACE);

            
                *op->add_dst_extents() = ExtentForRange(0, 1);

            
                op->set_data_offset(0);

            
                op->set_data_length(kBlockSize);

            
                truncate(blob_file_.path().c_str(), kBlockSize);

            
              }

            
              {

            
                auto op = partition->add_operations();

            
                op->set_type(InstallOperation::ZERO);

            
                *op->add_dst_extents() =

            
                    ExtentForRange(1, kFakePartitionSize / kBlockSize - 1);

            
              }


              ApplyPayload(&manifest_);

            
              if (completion_code_ == ErrorCode::kNewRootfsVerificationError) {

            
                DumpTargetPartitionDiff();

            
              }

            
            }


            TEST_F(UpdateAttempterAndroidIntegrationTest, XorOpsTest) {

            
              if (!DynamicPartitionEnabled()) {

            
                return;

            
              }

            
              auto partition = manifest_.add_partitions();

            
              partition->set_partition_name("fake");

            
              partition->set_estimate_cow_size(kFakePartitionSize);

            
              {

            
                auto op = partition->add_operations();

            
                op->set_type(InstallOperation::BROTLI_BSDIFF);

            
                *op->add_src_extents() = ExtentForRange(0, 10);

            
                *op->add_dst_extents() = ExtentForRange(0, 10);

            
              }

            
              {

            
                auto op = partition->add_operations();

            
                op->set_type(InstallOperation::BROTLI_BSDIFF);

            
                *op->add_src_extents() = ExtentForRange(10, 10);

            
                *op->add_dst_extents() = ExtentForRange(10, 10);

            
              }

            
              {

            
                auto op = partition->add_operations();

            
                op->set_type(InstallOperation::SOURCE_COPY);

            
                *op->add_src_extents() =

            
                    ExtentForRange(20, kFakePartitionSize / kBlockSize - 20);

            
                *op->add_dst_extents() =

            
                    ExtentForRange(20, kFakePartitionSize / kBlockSize - 20);

            
              }

            
              {

            
                auto op = partition->add_merge_operations();

            
                op->set_type(CowMergeOperation::COW_XOR);

            
                op->set_src_offset(123);

            
                *op->mutable_src_extent() = ExtentForRange(2, 8);

            
                *op->mutable_dst_extent() = ExtentForRange(0, 8);

            
              }

            
              {

            
                auto op = partition->add_merge_operations();

            
                op->set_type(CowMergeOperation::COW_XOR);

            
                op->set_src_offset(456);

            
                *op->mutable_src_extent() = ExtentForRange(10, 8);

            
                *op->mutable_dst_extent() = ExtentForRange(12, 8);

            
              }


              ApplyPayload(&manifest_);

            
              if (completion_code_ == ErrorCode::kNewRootfsVerificationError) {

            
                DumpTargetPartitionDiff();

            
              }

            
            }


            }  // namespace


            }  // namespace chromeos_update_engine
	//
	// 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 <algorithm>
	#include <memory>
	#include <string>
	#include <utility>

	#include <fcntl.h>
	#include <sys/sendfile.h>
	#include <unistd.h>

	#include <android-base/strings.h>
	#include <brillo/data_encoding.h>
	#include <brillo/message_loops/fake_message_loop.h>
	#include <bsdiff/bsdiff.h>
	#include <gtest/gtest.h>
	#include <liblp/builder.h>
	#include <fs_mgr.h>
	#include <liblp/liblp.h>

	#include "update_engine/aosp/boot_control_android.h"
	#include "update_engine/aosp/daemon_state_android.h"
	#include "update_engine/aosp/update_attempter_android.h"
	#include "update_engine/common/constants.h"
	#include "update_engine/common/fake_boot_control.h"
	#include "update_engine/common/fake_hardware.h"
	#include "update_engine/common/hash_calculator.h"
	#include "update_engine/common/prefs.h"
	#include "update_engine/common/test_utils.h"
	#include "update_engine/common/testing_constants.h"
	#include "update_engine/common/utils.h"
	#include "update_engine/payload_consumer/file_descriptor.h"
	#include "update_engine/payload_consumer/install_plan.h"
	#include "update_engine/payload_consumer/payload_constants.h"
	#include "update_engine/payload_generator/delta_diff_generator.h"
	#include "update_engine/payload_generator/extent_ranges.h"
	#include "update_engine/payload_generator/payload_file.h"
	#include "update_engine/payload_generator/payload_signer.h"
	#include "update_engine/update_metadata.pb.h"
	#include "update_engine/update_status_utils.h"

	namespace chromeos_update_engine {

	class UpdateAttempterAndroidIntegrationTest : public ::testing::Test,
	public ServiceObserverInterface {
	void AddFakePartitionGroup() {
	dynamic_control_ = boot_control_.dynamic_control_.get();
	auto super_device = dynamic_control_->GetSuperDevice();
	ASSERT_TRUE(super_device.has_value());
	super_device_ = super_device->value();
	builder_ = android::fs_mgr::MetadataBuilder::New(
	super_device->value(), boot_control_.GetCurrentSlot());
	ASSERT_NE(builder_, nullptr);

	// Remove dangling fake partitions, if test crashed before they might not
	// get cleaned up properly.
	RemoveFakePartitionGroup();
	ASSERT_TRUE(builder_->AddGroup("fake_group", kFakePartitionSize * 2));
	ExportPartitionTable();
	}
	void RemoveFakePartitionGroup() {
	builder_->RemovePartition("fake_a");
	builder_->RemovePartition("fake_b");
	builder_->RemoveGroupAndPartitions("fake_group");
	}

	// Fill partition \|path\| with arbitrary data.
	void FillPartition(const std::string& path, const bool is_source) {
	std::array<uint8_t, kBlockSize> data;
	EintrSafeFileDescriptor fd;
	fd.Open(path.c_str(), O_RDWR);
	for (size_t i = 0; i < kFakePartitionSize / kBlockSize; i++) {
	if (is_source) {
	std::fill(data.begin(), data.end(), i);
	} else {
	std::fill(
	data.begin(), data.end(), kFakePartitionSize / kBlockSize - i - 1);
	}
	fd.Write(data.data(), kBlockSize);
	}
	}

	void SetUp() override {
	FillPartition(old_part_.path(), true);
	FillPartition(new_part_.path(), false);
	ASSERT_TRUE(boot_control_.Init());
	if (!DynamicPartitionEnabled()) {
	return;
	}
	ASSERT_NO_FATAL_FAILURE(AddFakePartitionGroup());
	message_loop_.SetAsCurrent();
	// Set official build to false so that hash checks are non-mandatory
	hardware_.SetIsOfficialBuild(false);
	truncate64(blob_file_.path().c_str(), 0);

	update_attempter_android_.set_update_certificates_path(
	test_utils::GetBuildArtifactsPath(kUnittestOTACertsPath));

	// Basic setup to create VABC OTA
	manifest_.set_partial_update(true);
	manifest_.set_minor_version(kPartialUpdateMinorPayloadVersion);
	auto dap_group =
	manifest_.mutable_dynamic_partition_metadata()->add_groups();
	dap_group->set_name("fake_group");
	dap_group->add_partition_names("fake");

	manifest_.mutable_dynamic_partition_metadata()->set_snapshot_enabled(true);
	manifest_.mutable_dynamic_partition_metadata()->set_vabc_enabled(true);
	manifest_.mutable_dynamic_partition_metadata()->set_cow_version(
	android::snapshot::kCowVersionMajor);
	}

	void TearDown() override {
	if (!builder_ \|\| !DynamicPartitionEnabled()) {
	return;
	}
	auto dynamic_control = boot_control_.GetDynamicPartitionControl();
	if (dynamic_control) {
	dynamic_control->UnmapAllPartitions();
	dynamic_control->ResetUpdate(&prefs_);
	}
	RemoveFakePartitionGroup();
	ExportPartitionTable();
	}

	void CreateFakePartition() {
	// Create a fake partition for testing purposes
	auto partition_a = builder_->AddPartition(
	boot_control_.GetCurrentSlot() == 0 ? "fake_a" : "fake_b",
	"fake_group",
	0);
	ASSERT_NE(partition_a, nullptr);
	ASSERT_TRUE(builder_->ResizePartition(partition_a, kFakePartitionSize));
	ExportPartitionTable();
	std::string source_part;
	ASSERT_TRUE(
	dynamic_control_->GetPartitionDevice("fake",
	boot_control_.GetCurrentSlot(),
	boot_control_.GetCurrentSlot(),
	&source_part));
	int out_fd = open(source_part.c_str(), O_RDWR);
	ScopedFdCloser closer{&out_fd};
	ASSERT_GE(out_fd, 0) << android::base::ErrnoNumberAsString(errno);
	ASSERT_TRUE(utils::SendFile(out_fd, old_part_.fd(), kFakePartitionSize));
	}

	void SendStatusUpdate(
	const update_engine::UpdateEngineStatus& update_engine_status) override {
	LOG(INFO) << UpdateStatusToString(update_engine_status.status) << ", "
	<< update_engine_status.progress;
	}

	// Called whenever an update attempt is completed.
	void SendPayloadApplicationComplete(ErrorCode error_code) override {
	completion_code_ = error_code;
	}

	void ExportPartitionTable() {
	auto metadata = builder_->Export();
	ASSERT_NE(metadata, nullptr);
	android::fs_mgr::UpdatePartitionTable(
	super_device_, *metadata, boot_control_.GetCurrentSlot());
	}

	public:
	bool DynamicPartitionEnabled() {
	auto dynamic_control = boot_control_.GetDynamicPartitionControl();
	return dynamic_control &&
	dynamic_control->GetDynamicPartitionsFeatureFlag().IsEnabled();
	}
	void AddSignatureInfoToPayload(DeltaArchiveManifest* manifest,
	const std::string& private_key_path) {
	size_t total_blob_size = 0;
	for (const auto& part : manifest->partitions()) {
	for (const auto& op : part.operations()) {
	if (!op.has_data_offset())
	continue;
	ASSERT_EQ(total_blob_size, op.data_offset())
	<< "Ops not ordered by blob isze";
	total_blob_size += op.data_length();
	}
	}
	// Signatures appear at the end of the blobs. Note the offset in the
	// \|manifest_\|.
	uint64_t signature_blob_length = 0;
	if (!private_key_path.empty()) {
	ASSERT_TRUE(PayloadSigner::SignatureBlobLength({private_key_path},
	&signature_blob_length));
	PayloadSigner::AddSignatureToManifest(
	total_blob_size, signature_blob_length, manifest);
	}
	}

	// Generate blob data according to ops specified in the manifest.
	// Also update \|new_part_\|'s content to match expectation of ops.
	void HydratePayload(DeltaArchiveManifest* manifest) {
	for (auto& partition : *manifest->mutable_partitions()) {
	for (auto& op : *partition.mutable_operations()) {
	if (op.type() == InstallOperation::REPLACE) {
	ASSERT_GE(lseek64(blob_file_.fd(), op.data_offset(), SEEK_SET), 0);
	ASSERT_TRUE(utils::SendFile(
	new_part_.fd(), blob_file_.fd(), op.data_length()));
	} else if (op.type() == InstallOperation::BROTLI_BSDIFF) {
	brillo::Blob old_data;
	ASSERT_TRUE(utils::ReadExtents(
	old_part_.path(), op.src_extents(), &old_data, kBlockSize))
	<< "Failed to read source data: "
	<< android::base::ErrnoNumberAsString(errno);
	brillo::Blob new_data;
	ASSERT_TRUE(utils::ReadExtents(
	new_part_.path(), op.dst_extents(), &new_data, kBlockSize))
	<< "Failed to read target data: "
	<< android::base::ErrnoNumberAsString(errno);
	ScopedTempFile patch_file{"bspatch.XXXXXX", true};
	ASSERT_EQ(bsdiff::bsdiff(old_data.data(),
	old_data.size(),
	new_data.data(),
	new_data.size(),
	patch_file.path().c_str(),
	nullptr),
	0);
	op.set_data_length(utils::FileSize(patch_file.fd()));
	const auto offset = lseek64(blob_file_.fd(), 0, SEEK_CUR);
	ASSERT_GE(offset, 0);
	op.set_data_offset(offset);
	brillo::Blob src_data_hash;
	HashCalculator::RawHashOfData(old_data, &src_data_hash);
	op.set_src_sha256_hash(src_data_hash.data(), src_data_hash.size());
	utils::SendFile(blob_file_.fd(), patch_file.fd(), op.data_length());

	} else if (op.type() == InstallOperation::ZERO) {
	auto zero = utils::GetReadonlyZeroString(
	utils::BlocksInExtents(op.dst_extents()) * kBlockSize);
	for (const auto& ext : op.dst_extents()) {
	utils::PWriteAll(new_part_.fd(),
	zero.data(),
	ext.num_blocks() * kBlockSize,
	ext.start_block() * kBlockSize);
	}
	} else if (op.type() == InstallOperation::SOURCE_COPY) {
	brillo::Blob data;
	ASSERT_TRUE(utils::ReadExtents(
	old_part_.path(), op.src_extents(), &data, kBlockSize));
	ASSERT_TRUE(utils::WriteExtents(
	new_part_.path(), op.dst_extents(), data, kBlockSize));
	} else {
	FAIL() << "Unsupported install op type: " << op.type();
	}
	}
	}
	}

	void ApplyPayload(DeltaArchiveManifest* manifest) {
	ASSERT_FALSE(manifest->partitions().empty());
	ASSERT_NO_FATAL_FAILURE(HydratePayload(manifest));
	const auto private_key_path =
	test_utils::GetBuildArtifactsPath(kUnittestPrivateKeyPath);
	ASSERT_NO_FATAL_FAILURE(
	AddSignatureInfoToPayload(manifest, private_key_path));

	brillo::Blob hash;
	HashCalculator::RawHashOfFile(new_part_.path(), &hash);
	auto partition = &manifest->mutable_partitions()->at(0);
	partition->mutable_new_partition_info()->set_size(kFakePartitionSize);
	partition->mutable_new_partition_info()->set_hash(hash.data(), hash.size());
	const bool source_exist =
	std::any_of(partition->operations().begin(),
	partition->operations().end(),
	[](const auto& op) { return op.src_extents_size() > 0; });
	if (source_exist) {
	HashCalculator::RawHashOfFile(old_part_.path(), &hash);
	partition->mutable_old_partition_info()->set_size(kFakePartitionSize);
	partition->mutable_old_partition_info()->set_hash(hash.data(),
	hash.size());
	// Only create fake partition if the update is incremental
	LOG(INFO) << "Creating fake partition";
	ASSERT_NO_FATAL_FAILURE(CreateFakePartition());
	}
	uint64_t metadata_size = 0;
	ASSERT_TRUE(PayloadFile::WritePayload(payload_file_.path(),
	blob_file_.path(),
	private_key_path,
	kBrilloMajorPayloadVersion,
	*manifest,
	&metadata_size));
	LOG(INFO) << "Signature offset: " << manifest->signatures_offset()
	<< ", Signature size: " << manifest->signatures_size();
	brillo::ErrorPtr error;
	HashCalculator::RawHashOfFile(payload_file_.path(), &hash);
	daemon_state_.AddObserver(this);
	ASSERT_TRUE(update_attempter_android_.ApplyPayload(
	"file://" + payload_file_.path(),
	0,
	utils::FileSize(payload_file_.path()),
	{kPayloadPropertyMetadataSize + ("=" + std::to_string(metadata_size)),
	kPayloadPropertyFileHash +
	("=" + brillo::data_encoding::Base64Encode(hash))},
	&error));
	brillo::MessageLoop::current()->Run();
	if (error) {
	LOG(ERROR) << error->GetMessage();
	}
	ASSERT_EQ(error, nullptr);
	ASSERT_EQ(completion_code_, ErrorCode::kSuccess);
	}

	// Compare contents of fake_b partition to \|new_part_\| and print difference
	void DumpTargetPartitionDiff() {
	dynamic_control_->MapAllPartitions();
	auto partition_device =
	dynamic_control_->GetPartitionDevice("fake",
	1 - boot_control_.GetCurrentSlot(),
	boot_control_.GetCurrentSlot(),
	false);
	if (!partition_device.has_value()) {
	LOG(INFO) << "Failed to get target fake partition, skip diff report";
	return;
	}

	EintrSafeFileDescriptor actual_part;
	CHECK(actual_part.Open(partition_device->readonly_device_path.c_str(),
	O_RDONLY));
	EintrSafeFileDescriptor expected_part;
	CHECK(expected_part.Open(new_part_.path().c_str(), O_RDONLY));

	std::array<uint8_t, kBlockSize> actual_block;
	std::array<uint8_t, kBlockSize> expected_block;
	for (size_t i = 0; i < kFakePartitionSize / kBlockSize; i++) {
	actual_part.Read(actual_block.data(), actual_block.size());
	expected_part.Read(expected_block.data(), expected_block.size());
	if (actual_block != expected_block) {
	LOG(ERROR) << "Block " << i << " differs.";
	}
	}
	}
	// use 25MB max to avoid super not having enough space
	static constexpr size_t kFakePartitionSize = 1024 * 1024 * 25;
	static_assert(kFakePartitionSize % kBlockSize == 0);
	BootControlAndroid boot_control_;

	std::unique_ptr<android::fs_mgr::MetadataBuilder> builder_;
	std::string super_device_;
	FakeHardware hardware_;
	ScopedTempFile payload_file_;
	ScopedTempFile blob_file_{"blob_file.XXXXXX", true};
	// Contains expected data for old partition. Will be copied to fake_a on test
	// start.
	ScopedTempFile old_part_{"old_part.XXXXXX", true, kFakePartitionSize};
	// Expected data for new partition, will be compared against actual data in
	// fake_b once test finishes.
	ScopedTempFile new_part_{"new_part.XXXXXX", true, kFakePartitionSize};
	DaemonStateAndroid daemon_state_;
	MemoryPrefs prefs_;
	ErrorCode completion_code_;
	DynamicPartitionControlAndroid* dynamic_control_{nullptr};
	brillo::FakeMessageLoop message_loop_{nullptr};

	DeltaArchiveManifest manifest_;
	UpdateAttempterAndroid update_attempter_android_{
	&daemon_state_, &prefs_, &boot_control_, &hardware_, nullptr};
	};

	namespace {

	TEST_F(UpdateAttempterAndroidIntegrationTest, NewPartitionTest) {
	if (!DynamicPartitionEnabled()) {
	return;
	}
	auto partition = manifest_.add_partitions();
	partition->set_partition_name("fake");
	partition->set_estimate_cow_size(kFakePartitionSize);
	{
	auto op = partition->add_operations();
	op->set_type(InstallOperation::REPLACE);
	*op->add_dst_extents() = ExtentForRange(0, 1);
	op->set_data_offset(0);
	op->set_data_length(kBlockSize);
	truncate(blob_file_.path().c_str(), kBlockSize);
	}
	{
	auto op = partition->add_operations();
	op->set_type(InstallOperation::ZERO);
	*op->add_dst_extents() =
	ExtentForRange(1, kFakePartitionSize / kBlockSize - 1);
	}

	ApplyPayload(&manifest_);
	if (completion_code_ == ErrorCode::kNewRootfsVerificationError) {
	DumpTargetPartitionDiff();
	}
	}

	TEST_F(UpdateAttempterAndroidIntegrationTest, XorOpsTest) {
	if (!DynamicPartitionEnabled()) {
	return;
	}
	auto partition = manifest_.add_partitions();
	partition->set_partition_name("fake");
	partition->set_estimate_cow_size(kFakePartitionSize);
	{
	auto op = partition->add_operations();
	op->set_type(InstallOperation::BROTLI_BSDIFF);
	*op->add_src_extents() = ExtentForRange(0, 10);
	*op->add_dst_extents() = ExtentForRange(0, 10);
	}
	{
	auto op = partition->add_operations();
	op->set_type(InstallOperation::BROTLI_BSDIFF);
	*op->add_src_extents() = ExtentForRange(10, 10);
	*op->add_dst_extents() = ExtentForRange(10, 10);
	}
	{
	auto op = partition->add_operations();
	op->set_type(InstallOperation::SOURCE_COPY);
	*op->add_src_extents() =
	ExtentForRange(20, kFakePartitionSize / kBlockSize - 20);
	*op->add_dst_extents() =
	ExtentForRange(20, kFakePartitionSize / kBlockSize - 20);
	}
	{
	auto op = partition->add_merge_operations();
	op->set_type(CowMergeOperation::COW_XOR);
	op->set_src_offset(123);
	*op->mutable_src_extent() = ExtentForRange(2, 8);
	*op->mutable_dst_extent() = ExtentForRange(0, 8);
	}
	{
	auto op = partition->add_merge_operations();
	op->set_type(CowMergeOperation::COW_XOR);
	op->set_src_offset(456);
	*op->mutable_src_extent() = ExtentForRange(10, 8);
	*op->mutable_dst_extent() = ExtentForRange(12, 8);
	}

	ApplyPayload(&manifest_);
	if (completion_code_ == ErrorCode::kNewRootfsVerificationError) {
	DumpTargetPartitionDiff();
	}
	}

	} // namespace

	} // namespace chromeos_update_engine