dynamic_partition_test_utils.h - platform/system/update_engine - Git at Google

 //
 // Copyright (C) 2019 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.
 //

 #ifndef UPDATE_ENGINE_DYNAMIC_PARTITION_TEST_UTILS_H_
 #define UPDATE_ENGINE_DYNAMIC_PARTITION_TEST_UTILS_H_

 #include <stdint.h>

 #include <iostream>
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>

 #include <base/strings/string_util.h>
 #include <fs_mgr.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <liblp/builder.h>
 #include <storage_literals/storage_literals.h>

 #include "update_engine/common/boot_control_interface.h"
 #include "update_engine/update_metadata.pb.h"

 namespace chromeos_update_engine {

 using android::fs_mgr::MetadataBuilder;
 using testing::_;
 using testing::MakeMatcher;
 using testing::Matcher;
 using testing::MatcherInterface;
 using testing::MatchResultListener;
 using namespace android::storage_literals;  // NOLINT(build/namespaces)

 constexpr const uint32_t kMaxNumSlots = 2;
 constexpr const char* kSlotSuffixes[kMaxNumSlots] = {"_a", "_b"};
 constexpr const char* kFakeDevicePath = "/fake/dev/path/";
 constexpr const char* kFakeDmDevicePath = "/fake/dm/dev/path/";
 constexpr const uint32_t kFakeMetadataSize = 65536;
 constexpr const char* kDefaultGroup = "foo";
 constexpr const char* kFakeSuper = "fake_super";

 // A map describing the size of each partition.
 // "{name, size}"
 using PartitionSizes = std::map<std::string, uint64_t>;

 // "{name_a, size}"
 using PartitionSuffixSizes = std::map<std::string, uint64_t>;

 constexpr uint64_t kDefaultGroupSize = 5_GiB;
 // Super device size. 1 MiB for metadata.
 constexpr uint64_t kDefaultSuperSize = kDefaultGroupSize * 2 + 1_MiB;

 template <typename U, typename V>
 inline std::ostream& operator<<(std::ostream& os, const std::map<U, V>& param) {
   os << "{";
   bool first = true;
   for (const auto& pair : param) {
     if (!first)
       os << ", ";
     os << pair.first << ":" << pair.second;
     first = false;
   }
   return os << "}";
 }

 template <typename V>
 inline void VectorToStream(std::ostream& os, const V& param) {
   os << "[";
   bool first = true;
   for (const auto& e : param) {
     if (!first)
       os << ", ";
     os << e;
     first = false;
   }
   os << "]";
 }

 inline std::ostream& operator<<(std::ostream& os, const PartitionUpdate& p) {
   return os << "{" << p.partition_name() << ", "
             << p.new_partition_info().size() << "}";
 }

 inline std::ostream& operator<<(std::ostream& os,
                                 const DynamicPartitionGroup& g) {
   os << "{" << g.name() << ", " << g.size() << ", ";
   VectorToStream(os, g.partition_names());
   return os << "}";
 }

 inline std::ostream& operator<<(std::ostream& os,
                                 const DeltaArchiveManifest& m) {
   os << "{.groups = ";
   VectorToStream(os, m.dynamic_partition_metadata().groups());
   os << ", .partitions = ";
   VectorToStream(os, m.partitions());
   return os;
 }

 inline std::string GetDevice(const std::string& name) {
   return kFakeDevicePath + name;
 }

 inline std::string GetDmDevice(const std::string& name) {
   return kFakeDmDevicePath + name;
 }

 inline DynamicPartitionGroup* AddGroup(DeltaArchiveManifest* manifest,
                                        const std::string& group,
                                        uint64_t group_size) {
   auto* g = manifest->mutable_dynamic_partition_metadata()->add_groups();
   g->set_name(group);
   g->set_size(group_size);
   return g;
 }

 inline void AddPartition(DeltaArchiveManifest* manifest,
                          DynamicPartitionGroup* group,
                          const std::string& partition,
                          uint64_t partition_size) {
   group->add_partition_names(partition);
   auto* p = manifest->add_partitions();
   p->set_partition_name(partition);
   p->mutable_new_partition_info()->set_size(partition_size);
 }

 // To support legacy tests, auto-convert {name_a: size} map to
 // DeltaArchiveManifest.
 inline DeltaArchiveManifest PartitionSuffixSizesToManifest(
     const PartitionSuffixSizes& partition_sizes) {
   DeltaArchiveManifest manifest;
   for (const char* suffix : kSlotSuffixes) {
     AddGroup(&manifest, std::string(kDefaultGroup) + suffix, kDefaultGroupSize);
   }
   for (const auto& pair : partition_sizes) {
     for (size_t suffix_idx = 0; suffix_idx < kMaxNumSlots; ++suffix_idx) {
       if (base::EndsWith(pair.first,
                          kSlotSuffixes[suffix_idx],
                          base::CompareCase::SENSITIVE)) {
         AddPartition(
             &manifest,
             manifest.mutable_dynamic_partition_metadata()->mutable_groups(
                 suffix_idx),
             pair.first,
             pair.second);
       }
     }
   }
   return manifest;
 }

 // To support legacy tests, auto-convert {name: size} map to PartitionMetadata.
 inline DeltaArchiveManifest PartitionSizesToManifest(
     const PartitionSizes& partition_sizes) {
   DeltaArchiveManifest manifest;
   auto* g = AddGroup(&manifest, std::string(kDefaultGroup), kDefaultGroupSize);
   for (const auto& pair : partition_sizes) {
     AddPartition(&manifest, g, pair.first, pair.second);
   }
   return manifest;
 }

 inline std::unique_ptr<MetadataBuilder> NewFakeMetadata(
     const DeltaArchiveManifest& manifest) {
   auto builder =
       MetadataBuilder::New(kDefaultSuperSize, kFakeMetadataSize, kMaxNumSlots);
   for (const auto& group : manifest.dynamic_partition_metadata().groups()) {
     EXPECT_TRUE(builder->AddGroup(group.name(), group.size()));
     for (const auto& partition_name : group.partition_names()) {
       EXPECT_NE(
           nullptr,
           builder->AddPartition(partition_name, group.name(), 0 /* attr */));
     }
   }
   for (const auto& partition : manifest.partitions()) {
     auto p = builder->FindPartition(partition.partition_name());
     EXPECT_TRUE(p && builder->ResizePartition(
                          p, partition.new_partition_info().size()));
   }
   return builder;
 }

 class MetadataMatcher : public MatcherInterface<MetadataBuilder*> {
  public:
   explicit MetadataMatcher(const PartitionSuffixSizes& partition_sizes)
       : manifest_(PartitionSuffixSizesToManifest(partition_sizes)) {}
   explicit MetadataMatcher(const DeltaArchiveManifest& manifest)
       : manifest_(manifest) {}

   bool MatchAndExplain(MetadataBuilder* metadata,
                        MatchResultListener* listener) const override {
     bool success = true;
     for (const auto& group : manifest_.dynamic_partition_metadata().groups()) {
       for (const auto& partition_name : group.partition_names()) {
         auto p = metadata->FindPartition(partition_name);
         if (p == nullptr) {
           if (!success)
             *listener << "; ";
           *listener << "No partition " << partition_name;
           success = false;
           continue;
         }
         const auto& partition_updates = manifest_.partitions();
         auto it = std::find_if(partition_updates.begin(),
                                partition_updates.end(),
                                [&](const auto& p) {
                                  return p.partition_name() == partition_name;
                                });
         if (it == partition_updates.end()) {
           *listener << "Can't find partition update " << partition_name;
           success = false;
           continue;
         }
         auto partition_size = it->new_partition_info().size();
         if (p->size() != partition_size) {
           if (!success)
             *listener << "; ";
           *listener << "Partition " << partition_name << " has size "
                     << p->size() << ", expected " << partition_size;
           success = false;
         }
         if (p->group_name() != group.name()) {
           if (!success)
             *listener << "; ";
           *listener << "Partition " << partition_name << " has group "
                     << p->group_name() << ", expected " << group.name();
           success = false;
         }
       }
     }
     return success;
   }

   void DescribeTo(std::ostream* os) const override {
     *os << "expect: " << manifest_;
   }

   void DescribeNegationTo(std::ostream* os) const override {
     *os << "expect not: " << manifest_;
   }

  private:
   DeltaArchiveManifest manifest_;
 };

 inline Matcher<MetadataBuilder*> MetadataMatches(
     const PartitionSuffixSizes& partition_sizes) {
   return MakeMatcher(new MetadataMatcher(partition_sizes));
 }

 inline Matcher<MetadataBuilder*> MetadataMatches(
     const DeltaArchiveManifest& manifest) {
   return MakeMatcher(new MetadataMatcher(manifest));
 }

 MATCHER_P(HasGroup, group, " has group " + group) {
   auto groups = arg->ListGroups();
   return std::find(groups.begin(), groups.end(), group) != groups.end();
 }

 struct TestParam {
   uint32_t source;
   uint32_t target;
 };
 inline std::ostream& operator<<(std::ostream& os, const TestParam& param) {
   return os << "{source: " << param.source << ", target:" << param.target
             << "}";
 }

 }  // namespace chromeos_update_engine

 #endif  // UPDATE_ENGINE_DYNAMIC_PARTITION_TEST_UTILS_H_
	//
	// Copyright (C) 2019 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.
	//

	#ifndef UPDATE_ENGINE_DYNAMIC_PARTITION_TEST_UTILS_H_
	#define UPDATE_ENGINE_DYNAMIC_PARTITION_TEST_UTILS_H_

	#include <stdint.h>

	#include <iostream>
	#include <map>
	#include <memory>
	#include <string>
	#include <vector>

	#include <base/strings/string_util.h>
	#include <fs_mgr.h>
	#include <gmock/gmock.h>
	#include <gtest/gtest.h>
	#include <liblp/builder.h>
	#include <storage_literals/storage_literals.h>

	#include "update_engine/common/boot_control_interface.h"
	#include "update_engine/update_metadata.pb.h"

	namespace chromeos_update_engine {

	using android::fs_mgr::MetadataBuilder;
	using testing::_;
	using testing::MakeMatcher;
	using testing::Matcher;
	using testing::MatcherInterface;
	using testing::MatchResultListener;
	using namespace android::storage_literals; // NOLINT(build/namespaces)

	constexpr const uint32_t kMaxNumSlots = 2;
	constexpr const char* kSlotSuffixes[kMaxNumSlots] = {"_a", "_b"};
	constexpr const char* kFakeDevicePath = "/fake/dev/path/";
	constexpr const char* kFakeDmDevicePath = "/fake/dm/dev/path/";
	constexpr const uint32_t kFakeMetadataSize = 65536;
	constexpr const char* kDefaultGroup = "foo";
	constexpr const char* kFakeSuper = "fake_super";

	// A map describing the size of each partition.
	// "{name, size}"
	using PartitionSizes = std::map<std::string, uint64_t>;

	// "{name_a, size}"
	using PartitionSuffixSizes = std::map<std::string, uint64_t>;

	constexpr uint64_t kDefaultGroupSize = 5_GiB;
	// Super device size. 1 MiB for metadata.
	constexpr uint64_t kDefaultSuperSize = kDefaultGroupSize * 2 + 1_MiB;

	template <typename U, typename V>
	inline std::ostream& operator<<(std::ostream& os, const std::map<U, V>& param) {
	os << "{";
	bool first = true;
	for (const auto& pair : param) {
	if (!first)
	os << ", ";
	os << pair.first << ":" << pair.second;
	first = false;
	}
	return os << "}";
	}

	template <typename V>
	inline void VectorToStream(std::ostream& os, const V& param) {
	os << "[";
	bool first = true;
	for (const auto& e : param) {
	if (!first)
	os << ", ";
	os << e;
	first = false;
	}
	os << "]";
	}

	inline std::ostream& operator<<(std::ostream& os, const PartitionUpdate& p) {
	return os << "{" << p.partition_name() << ", "
	<< p.new_partition_info().size() << "}";
	}

	inline std::ostream& operator<<(std::ostream& os,
	const DynamicPartitionGroup& g) {
	os << "{" << g.name() << ", " << g.size() << ", ";
	VectorToStream(os, g.partition_names());
	return os << "}";
	}

	inline std::ostream& operator<<(std::ostream& os,
	const DeltaArchiveManifest& m) {
	os << "{.groups = ";
	VectorToStream(os, m.dynamic_partition_metadata().groups());
	os << ", .partitions = ";
	VectorToStream(os, m.partitions());
	return os;
	}

	inline std::string GetDevice(const std::string& name) {
	return kFakeDevicePath + name;
	}

	inline std::string GetDmDevice(const std::string& name) {
	return kFakeDmDevicePath + name;
	}

	inline DynamicPartitionGroup* AddGroup(DeltaArchiveManifest* manifest,
	const std::string& group,
	uint64_t group_size) {
	auto* g = manifest->mutable_dynamic_partition_metadata()->add_groups();
	g->set_name(group);
	g->set_size(group_size);
	return g;
	}

	inline void AddPartition(DeltaArchiveManifest* manifest,
	DynamicPartitionGroup* group,
	const std::string& partition,
	uint64_t partition_size) {
	group->add_partition_names(partition);
	auto* p = manifest->add_partitions();
	p->set_partition_name(partition);
	p->mutable_new_partition_info()->set_size(partition_size);
	}

	// To support legacy tests, auto-convert {name_a: size} map to
	// DeltaArchiveManifest.
	inline DeltaArchiveManifest PartitionSuffixSizesToManifest(
	const PartitionSuffixSizes& partition_sizes) {
	DeltaArchiveManifest manifest;
	for (const char* suffix : kSlotSuffixes) {
	AddGroup(&manifest, std::string(kDefaultGroup) + suffix, kDefaultGroupSize);
	}
	for (const auto& pair : partition_sizes) {
	for (size_t suffix_idx = 0; suffix_idx < kMaxNumSlots; ++suffix_idx) {
	if (base::EndsWith(pair.first,
	kSlotSuffixes[suffix_idx],
	base::CompareCase::SENSITIVE)) {
	AddPartition(
	&manifest,
	manifest.mutable_dynamic_partition_metadata()->mutable_groups(
	suffix_idx),
	pair.first,
	pair.second);
	}
	}
	}
	return manifest;
	}

	// To support legacy tests, auto-convert {name: size} map to PartitionMetadata.
	inline DeltaArchiveManifest PartitionSizesToManifest(
	const PartitionSizes& partition_sizes) {
	DeltaArchiveManifest manifest;
	auto* g = AddGroup(&manifest, std::string(kDefaultGroup), kDefaultGroupSize);
	for (const auto& pair : partition_sizes) {
	AddPartition(&manifest, g, pair.first, pair.second);
	}
	return manifest;
	}

	inline std::unique_ptr<MetadataBuilder> NewFakeMetadata(
	const DeltaArchiveManifest& manifest) {
	auto builder =
	MetadataBuilder::New(kDefaultSuperSize, kFakeMetadataSize, kMaxNumSlots);
	for (const auto& group : manifest.dynamic_partition_metadata().groups()) {
	EXPECT_TRUE(builder->AddGroup(group.name(), group.size()));
	for (const auto& partition_name : group.partition_names()) {
	EXPECT_NE(
	nullptr,
	builder->AddPartition(partition_name, group.name(), 0 /* attr */));
	}
	}
	for (const auto& partition : manifest.partitions()) {
	auto p = builder->FindPartition(partition.partition_name());
	EXPECT_TRUE(p && builder->ResizePartition(
	p, partition.new_partition_info().size()));
	}
	return builder;
	}

	class MetadataMatcher : public MatcherInterface<MetadataBuilder*> {
	public:
	explicit MetadataMatcher(const PartitionSuffixSizes& partition_sizes)
	: manifest_(PartitionSuffixSizesToManifest(partition_sizes)) {}
	explicit MetadataMatcher(const DeltaArchiveManifest& manifest)
	: manifest_(manifest) {}

	bool MatchAndExplain(MetadataBuilder* metadata,
	MatchResultListener* listener) const override {
	bool success = true;
	for (const auto& group : manifest_.dynamic_partition_metadata().groups()) {
	for (const auto& partition_name : group.partition_names()) {
	auto p = metadata->FindPartition(partition_name);
	if (p == nullptr) {
	if (!success)
	*listener << "; ";
	*listener << "No partition " << partition_name;
	success = false;
	continue;
	}
	const auto& partition_updates = manifest_.partitions();
	auto it = std::find_if(partition_updates.begin(),
	partition_updates.end(),
	[&](const auto& p) {
	return p.partition_name() == partition_name;
	});
	if (it == partition_updates.end()) {
	*listener << "Can't find partition update " << partition_name;
	success = false;
	continue;
	}
	auto partition_size = it->new_partition_info().size();
	if (p->size() != partition_size) {
	if (!success)
	*listener << "; ";
	*listener << "Partition " << partition_name << " has size "
	<< p->size() << ", expected " << partition_size;
	success = false;
	}
	if (p->group_name() != group.name()) {
	if (!success)
	*listener << "; ";
	*listener << "Partition " << partition_name << " has group "
	<< p->group_name() << ", expected " << group.name();
	success = false;
	}
	}
	}
	return success;
	}

	void DescribeTo(std::ostream* os) const override {
	*os << "expect: " << manifest_;
	}

	void DescribeNegationTo(std::ostream* os) const override {
	*os << "expect not: " << manifest_;
	}

	private:
	DeltaArchiveManifest manifest_;
	};

	inline Matcher<MetadataBuilder*> MetadataMatches(
	const PartitionSuffixSizes& partition_sizes) {
	return MakeMatcher(new MetadataMatcher(partition_sizes));
	}

	inline Matcher<MetadataBuilder*> MetadataMatches(
	const DeltaArchiveManifest& manifest) {
	return MakeMatcher(new MetadataMatcher(manifest));
	}

	MATCHER_P(HasGroup, group, " has group " + group) {
	auto groups = arg->ListGroups();
	return std::find(groups.begin(), groups.end(), group) != groups.end();
	}

	struct TestParam {
	uint32_t source;
	uint32_t target;
	};
	inline std::ostream& operator<<(std::ostream& os, const TestParam& param) {
	return os << "{source: " << param.source << ", target:" << param.target
	<< "}";
	}

	} // namespace chromeos_update_engine

	#endif // UPDATE_ENGINE_DYNAMIC_PARTITION_TEST_UTILS_H_