idmap2: switch to improved Result class
Remove the old std::optional based Result class, replace uses with the
new std::variant based Result class.
Test: make idmap2_tests
Change-Id: I401cb36e5af06133a2872d835cf29bfb0b106597
diff --git a/cmds/idmap2/tests/FileUtilsTests.cpp b/cmds/idmap2/tests/FileUtilsTests.cpp
index 2e85eb6..34a0097 100644
--- a/cmds/idmap2/tests/FileUtilsTests.cpp
+++ b/cmds/idmap2/tests/FileUtilsTests.cpp
@@ -58,21 +58,15 @@
});
ASSERT_THAT(v, NotNull());
ASSERT_EQ(v->size(), 10U);
- ASSERT_EQ(
- std::set<std::string>(v->begin(), v->end()),
- std::set<std::string>(
- {
- root + "/target/target.apk",
- root + "/target/target-no-overlayable.apk",
- root + "/overlay/overlay.apk",
- root + "/overlay/overlay-no-name.apk",
- root + "/overlay/overlay-no-name-static.apk",
- root + "/overlay/overlay-static-1.apk",
- root + "/overlay/overlay-static-2.apk",
- root + "/signature-overlay/signature-overlay.apk",
- root + "/system-overlay/system-overlay.apk",
- root + "/system-overlay-invalid/system-overlay-invalid.apk"
- }));
+ ASSERT_EQ(std::set<std::string>(v->begin(), v->end()),
+ std::set<std::string>(
+ {root + "/target/target.apk", root + "/target/target-no-overlayable.apk",
+ root + "/overlay/overlay.apk", root + "/overlay/overlay-no-name.apk",
+ root + "/overlay/overlay-no-name-static.apk",
+ root + "/overlay/overlay-static-1.apk", root + "/overlay/overlay-static-2.apk",
+ root + "/signature-overlay/signature-overlay.apk",
+ root + "/system-overlay/system-overlay.apk",
+ root + "/system-overlay-invalid/system-overlay-invalid.apk"}));
}
TEST(FileUtilsTests, ReadFile) {
diff --git a/cmds/idmap2/tests/IdmapTests.cpp b/cmds/idmap2/tests/IdmapTests.cpp
index 53ec03b..bbfbad9 100644
--- a/cmds/idmap2/tests/IdmapTests.cpp
+++ b/cmds/idmap2/tests/IdmapTests.cpp
@@ -256,10 +256,10 @@
ASSERT_EQ(types[0]->GetOverlayTypeId(), 0x01U);
ASSERT_EQ(types[0]->GetEntryCount(), 4U);
ASSERT_EQ(types[0]->GetEntryOffset(), 6U);
- ASSERT_EQ(types[0]->GetEntry(0), 0x0000U); // string/policy_public
- ASSERT_EQ(types[0]->GetEntry(1), kNoEntry); // string/policy_signature
- ASSERT_EQ(types[0]->GetEntry(2), 0x0001U); // string/policy_system
- ASSERT_EQ(types[0]->GetEntry(3), 0x0002U); // string/policy_system_vendor
+ ASSERT_EQ(types[0]->GetEntry(0), 0x0000U); // string/policy_public
+ ASSERT_EQ(types[0]->GetEntry(1), kNoEntry); // string/policy_signature
+ ASSERT_EQ(types[0]->GetEntry(2), 0x0001U); // string/policy_system
+ ASSERT_EQ(types[0]->GetEntry(3), 0x0002U); // string/policy_system_vendor
}
TEST(IdmapOverlayableTests, CreateIdmapFromApkAssetsPolicySignature) {
@@ -267,7 +267,8 @@
std::unique_ptr<const ApkAssets> target_apk = ApkAssets::Load(target_apk_path);
ASSERT_THAT(target_apk, NotNull());
- const std::string overlay_apk_path(GetTestDataPath() + "/signature-overlay/signature-overlay.apk");
+ const std::string overlay_apk_path(GetTestDataPath() +
+ "/signature-overlay/signature-overlay.apk");
std::unique_ptr<const ApkAssets> overlay_apk = ApkAssets::Load(overlay_apk_path);
ASSERT_THAT(overlay_apk, NotNull());
@@ -294,7 +295,7 @@
ASSERT_EQ(types[0]->GetOverlayTypeId(), 0x01U);
ASSERT_EQ(types[0]->GetEntryCount(), 1U);
ASSERT_EQ(types[0]->GetEntryOffset(), 7U);
- ASSERT_EQ(types[0]->GetEntry(0), 0x0000U); // string/policy_signature
+ ASSERT_EQ(types[0]->GetEntry(0), 0x0000U); // string/policy_signature
}
TEST(IdmapOverlayableTests, CreateIdmapFromApkAssetsPolicySignatureNotFulfilled) {
@@ -302,7 +303,8 @@
std::unique_ptr<const ApkAssets> target_apk = ApkAssets::Load(target_apk_path);
ASSERT_THAT(target_apk, NotNull());
- const std::string overlay_apk_path(GetTestDataPath() + "/signature-overlay/signature-overlay.apk");
+ const std::string overlay_apk_path(GetTestDataPath() +
+ "/signature-overlay/signature-overlay.apk");
std::unique_ptr<const ApkAssets> overlay_apk = ApkAssets::Load(overlay_apk_path);
ASSERT_THAT(overlay_apk, NotNull());
@@ -323,7 +325,7 @@
ASSERT_EQ(data->GetHeader()->GetTypeCount(), 0U);
const std::vector<std::unique_ptr<const IdmapData::TypeEntry>>& types = data->GetTypeEntries();
- ASSERT_EQ(types.size(), 0U); // can't overlay, so contains nothing
+ ASSERT_EQ(types.size(), 0U); // can't overlay, so contains nothing
}
// Overlays should abide by all overlayable restrictions if enforcement of overlayable is enabled.
@@ -359,10 +361,10 @@
ASSERT_EQ(types[0]->GetOverlayTypeId(), 0x01U);
ASSERT_EQ(types[0]->GetEntryCount(), 4U);
ASSERT_EQ(types[0]->GetEntryOffset(), 6U);
- ASSERT_EQ(types[0]->GetEntry(0), 0x0003U); // string/policy_public
- ASSERT_EQ(types[0]->GetEntry(1), kNoEntry); // string/policy_signature
- ASSERT_EQ(types[0]->GetEntry(2), 0x0005U); // string/policy_system
- ASSERT_EQ(types[0]->GetEntry(3), 0x0006U); // string/policy_system_vendor
+ ASSERT_EQ(types[0]->GetEntry(0), 0x0003U); // string/policy_public
+ ASSERT_EQ(types[0]->GetEntry(1), kNoEntry); // string/policy_signature
+ ASSERT_EQ(types[0]->GetEntry(2), 0x0005U); // string/policy_system
+ ASSERT_EQ(types[0]->GetEntry(3), 0x0006U); // string/policy_system_vendor
}
// Overlays should ignore all overlayable restrictions if enforcement of overlayable is disabled.
diff --git a/cmds/idmap2/tests/PoliciesTests.cpp b/cmds/idmap2/tests/PoliciesTests.cpp
index ab567ad..a76da53 100644
--- a/cmds/idmap2/tests/PoliciesTests.cpp
+++ b/cmds/idmap2/tests/PoliciesTests.cpp
@@ -27,44 +27,42 @@
namespace android::idmap2 {
TEST(PoliciesTests, PoliciesToBitmasks) {
- const Result<PolicyBitmask> bitmask1 = PoliciesToBitmask({"system"}, std::cerr);
- ASSERT_NE(bitmask1, kResultError);
- ASSERT_EQ(bitmask1, PolicyFlags::POLICY_SYSTEM_PARTITION);
+ const auto bitmask1 = PoliciesToBitmask({"system"});
+ ASSERT_TRUE(bitmask1);
+ ASSERT_EQ(*bitmask1, PolicyFlags::POLICY_SYSTEM_PARTITION);
- const Result<PolicyBitmask> bitmask2 = PoliciesToBitmask({"system", "vendor"}, std::cerr);
- ASSERT_NE(bitmask2, kResultError);
- ASSERT_EQ(bitmask2, PolicyFlags::POLICY_SYSTEM_PARTITION | PolicyFlags::POLICY_VENDOR_PARTITION);
+ const auto bitmask2 = PoliciesToBitmask({"system", "vendor"});
+ ASSERT_TRUE(bitmask2);
+ ASSERT_EQ(*bitmask2, PolicyFlags::POLICY_SYSTEM_PARTITION | PolicyFlags::POLICY_VENDOR_PARTITION);
- const Result<PolicyBitmask> bitmask3 = PoliciesToBitmask({"vendor", "system"}, std::cerr);
- ASSERT_NE(bitmask3, kResultError);
- ASSERT_EQ(bitmask3, PolicyFlags::POLICY_SYSTEM_PARTITION | PolicyFlags::POLICY_VENDOR_PARTITION);
+ const auto bitmask3 = PoliciesToBitmask({"vendor", "system"});
+ ASSERT_TRUE(bitmask3);
+ ASSERT_EQ(*bitmask3, PolicyFlags::POLICY_SYSTEM_PARTITION | PolicyFlags::POLICY_VENDOR_PARTITION);
- const Result<PolicyBitmask> bitmask4 =
- PoliciesToBitmask({"public", "product", "system", "vendor"}, std::cerr);
- ASSERT_NE(bitmask4, kResultError);
- ASSERT_EQ(bitmask4, PolicyFlags::POLICY_PUBLIC | PolicyFlags::POLICY_PRODUCT_PARTITION |
- PolicyFlags::POLICY_SYSTEM_PARTITION |
- PolicyFlags::POLICY_VENDOR_PARTITION);
+ const auto bitmask4 = PoliciesToBitmask({"public", "product", "system", "vendor"});
+ ASSERT_TRUE(bitmask4);
+ ASSERT_EQ(*bitmask4, PolicyFlags::POLICY_PUBLIC | PolicyFlags::POLICY_PRODUCT_PARTITION |
+ PolicyFlags::POLICY_SYSTEM_PARTITION |
+ PolicyFlags::POLICY_VENDOR_PARTITION);
- const Result<PolicyBitmask> bitmask5 =
- PoliciesToBitmask({"system", "system", "system"}, std::cerr);
- ASSERT_NE(bitmask5, kResultError);
- ASSERT_EQ(bitmask5, PolicyFlags::POLICY_SYSTEM_PARTITION);
+ const auto bitmask5 = PoliciesToBitmask({"system", "system", "system"});
+ ASSERT_TRUE(bitmask5);
+ ASSERT_EQ(*bitmask5, PolicyFlags::POLICY_SYSTEM_PARTITION);
- const Result<PolicyBitmask> bitmask6 = PoliciesToBitmask({""}, std::cerr);
- ASSERT_EQ(bitmask6, kResultError);
+ const auto bitmask6 = PoliciesToBitmask({""});
+ ASSERT_FALSE(bitmask6);
- const Result<PolicyBitmask> bitmask7 = PoliciesToBitmask({"foo"}, std::cerr);
- ASSERT_EQ(bitmask7, kResultError);
+ const auto bitmask7 = PoliciesToBitmask({"foo"});
+ ASSERT_FALSE(bitmask7);
- const Result<PolicyBitmask> bitmask8 = PoliciesToBitmask({"system", "foo"}, std::cerr);
- ASSERT_EQ(bitmask8, kResultError);
+ const auto bitmask8 = PoliciesToBitmask({"system", "foo"});
+ ASSERT_FALSE(bitmask8);
- const Result<PolicyBitmask> bitmask9 = PoliciesToBitmask({"system", ""}, std::cerr);
- ASSERT_EQ(bitmask9, kResultError);
+ const auto bitmask9 = PoliciesToBitmask({"system", ""});
+ ASSERT_FALSE(bitmask9);
- const Result<PolicyBitmask> bitmask10 = PoliciesToBitmask({"system "}, std::cerr);
- ASSERT_EQ(bitmask10, kResultError);
+ const auto bitmask10 = PoliciesToBitmask({"system "});
+ ASSERT_FALSE(bitmask10);
}
} // namespace android::idmap2
diff --git a/cmds/idmap2/tests/ResultTests.cpp b/cmds/idmap2/tests/ResultTests.cpp
index d82f0c4..5f4daed 100644
--- a/cmds/idmap2/tests/ResultTests.cpp
+++ b/cmds/idmap2/tests/ResultTests.cpp
@@ -32,28 +32,28 @@
// Tests: Error
TEST(ResultTests, ErrorTraits) {
- ASSERT_TRUE(std::is_move_constructible<v2::Error>::value);
- ASSERT_TRUE(std::is_move_assignable<v2::Error>::value);
- ASSERT_TRUE(std::is_copy_constructible<v2::Error>::value);
- ASSERT_TRUE(std::is_copy_assignable<v2::Error>::value);
+ ASSERT_TRUE(std::is_move_constructible<Error>::value);
+ ASSERT_TRUE(std::is_move_assignable<Error>::value);
+ ASSERT_TRUE(std::is_copy_constructible<Error>::value);
+ ASSERT_TRUE(std::is_copy_assignable<Error>::value);
}
TEST(ResultTests, ErrorCtorFormat) {
- v2::Error e("%s=0x%08x", "resid", 0x7f010002);
+ Error e("%s=0x%08x", "resid", 0x7f010002);
ASSERT_EQ(e.GetMessage(), "resid=0x7f010002");
}
TEST(ResultTests, ErrorPropagateParent) {
- v2::Error e1("foo");
+ Error e1("foo");
ASSERT_EQ(e1.GetMessage(), "foo");
- v2::Error e2(e1, "bar");
+ Error e2(e1, "bar");
ASSERT_EQ(e2.GetMessage(), "foo -> bar");
- v2::Error e3(e2); // NOLINT(performance-unnecessary-copy-initialization)
+ Error e3(e2); // NOLINT(performance-unnecessary-copy-initialization)
ASSERT_EQ(e3.GetMessage(), "foo -> bar");
- v2::Error e4(e3, "%02d", 1);
+ Error e4(e3, "%02d", 1);
ASSERT_EQ(e4.GetMessage(), "foo -> bar -> 01");
}
@@ -61,13 +61,13 @@
// Result(const Result&)
TEST(ResultTests, CopyConstructor) {
- v2::Result<uint32_t> r1(42U);
+ Result<uint32_t> r1(42U);
- v2::Result<uint32_t> r2(r1);
+ Result<uint32_t> r2(r1);
ASSERT_TRUE(r2);
ASSERT_EQ(*r2, 42U);
- v2::Result<uint32_t> r3 = r2;
+ Result<uint32_t> r3 = r2;
ASSERT_TRUE(r3);
ASSERT_EQ(*r3, 42U);
}
@@ -75,23 +75,23 @@
// Result(const T&)
TEST(ResultTests, Constructor) {
uint32_t v = 42U;
- v2::Result<uint32_t> r1(v);
+ Result<uint32_t> r1(v);
ASSERT_TRUE(r1);
ASSERT_EQ(*r1, 42U);
- v2::Error e("foo");
- v2::Result<uint32_t> r2(e);
+ Error e("foo");
+ Result<uint32_t> r2(e);
ASSERT_FALSE(r2);
ASSERT_EQ(r2.GetErrorMessage(), "foo");
}
// Result(const T&&)
TEST(ResultTests, MoveConstructor) {
- v2::Result<uint32_t> r1(42U);
+ Result<uint32_t> r1(42U);
ASSERT_TRUE(r1);
ASSERT_EQ(*r1, 42U);
- v2::Result<uint32_t> r2(v2::Error("foo"));
+ Result<uint32_t> r2(Error("foo"));
ASSERT_FALSE(r2);
ASSERT_EQ(r2.GetErrorMessage(), "foo");
}
@@ -99,52 +99,52 @@
// operator=
TEST(ResultTests, CopyAssignmentOperator) {
// note: 'Result<...> r2 = r1;' calls the copy ctor
- v2::Result<uint32_t> r1(42U);
- v2::Result<uint32_t> r2(0U);
+ Result<uint32_t> r1(42U);
+ Result<uint32_t> r2(0U);
r2 = r1;
ASSERT_TRUE(r2);
ASSERT_EQ(*r2, 42U);
- v2::Result<uint32_t> r3(v2::Error("foo"));
+ Result<uint32_t> r3(Error("foo"));
r2 = r3;
ASSERT_FALSE(r2);
ASSERT_EQ(r2.GetErrorMessage(), "foo");
}
TEST(ResultTests, MoveAssignmentOperator) {
- v2::Result<uint32_t> r(0U);
- r = v2::Result<uint32_t>(42U);
+ Result<uint32_t> r(0U);
+ r = Result<uint32_t>(42U);
ASSERT_TRUE(r);
ASSERT_EQ(*r, 42U);
- r = v2::Result<uint32_t>(v2::Error("foo"));
+ r = Result<uint32_t>(Error("foo"));
ASSERT_FALSE(r);
ASSERT_EQ(r.GetErrorMessage(), "foo");
}
// operator bool()
TEST(ResultTests, BoolOperator) {
- v2::Result<uint32_t> r1(42U);
+ Result<uint32_t> r1(42U);
ASSERT_TRUE(r1);
ASSERT_EQ(*r1, 42U);
- v2::Result<uint32_t> r2(v2::Error("foo"));
+ Result<uint32_t> r2(Error("foo"));
ASSERT_FALSE(r2);
ASSERT_EQ(r2.GetErrorMessage(), "foo");
}
// operator*
TEST(ResultTests, IndirectionOperator) {
- const v2::Result<uint32_t> r1(42U);
+ const Result<uint32_t> r1(42U);
ASSERT_TRUE(r1);
ASSERT_EQ(*r1, 42U);
- const v2::Result<Container> r2(Container{42U});
+ const Result<Container> r2(Container{42U});
ASSERT_TRUE(r2);
const Container& c = *r2;
ASSERT_EQ(c.value, 42U);
- v2::Result<Container> r3(Container{42U});
+ Result<Container> r3(Container{42U});
ASSERT_TRUE(r3);
ASSERT_EQ((*r3).value, 42U);
(*r3).value = 0U;
@@ -153,11 +153,11 @@
// operator->
TEST(ResultTests, DereferenceOperator) {
- const v2::Result<Container> r1(Container{42U});
+ const Result<Container> r1(Container{42U});
ASSERT_TRUE(r1);
ASSERT_EQ(r1->value, 42U);
- v2::Result<Container> r2(Container{42U});
+ Result<Container> r2(Container{42U});
ASSERT_TRUE(r2);
ASSERT_EQ(r2->value, 42U);
r2->value = 0U;
@@ -167,14 +167,14 @@
// Tests: intended use of Result<T>
TEST(ResultTests, ResultTraits) {
- ASSERT_TRUE(std::is_move_constructible<v2::Result<uint32_t>>::value);
- ASSERT_TRUE(std::is_move_assignable<v2::Result<uint32_t>>::value);
- ASSERT_TRUE(std::is_copy_constructible<v2::Result<uint32_t>>::value);
- ASSERT_TRUE(std::is_copy_assignable<v2::Result<uint32_t>>::value);
+ ASSERT_TRUE(std::is_move_constructible<Result<uint32_t>>::value);
+ ASSERT_TRUE(std::is_move_assignable<Result<uint32_t>>::value);
+ ASSERT_TRUE(std::is_copy_constructible<Result<uint32_t>>::value);
+ ASSERT_TRUE(std::is_copy_assignable<Result<uint32_t>>::value);
}
TEST(ResultTests, UnitTypeResult) {
- v2::Result<v2::Unit> r(v2::Unit{});
+ Result<Unit> r(Unit{});
ASSERT_TRUE(r);
}
@@ -220,16 +220,16 @@
ASSERT_FALSE(std::is_copy_assignable<RefCountContainer>::value);
RefCountData rc{0, 0, 0, 0};
- { v2::Result<RefCountContainer> r(RefCountContainer{rc}); }
+ { Result<RefCountContainer> r(RefCountContainer{rc}); }
ASSERT_EQ(rc.ctor, 1);
ASSERT_EQ(rc.copy_ctor, 1);
ASSERT_EQ(rc.move, 0);
ASSERT_EQ(rc.dtor, 2);
}
-v2::Result<Container> CreateContainer(bool succeed) {
+Result<Container> CreateContainer(bool succeed) {
if (!succeed) {
- return v2::Error("foo");
+ return Error("foo");
}
return Container{42U};
}
@@ -245,10 +245,10 @@
ASSERT_EQ(r2.GetError().GetMessage(), "foo");
}
-v2::Result<Container> FailToCreateContainer() {
+Result<Container> FailToCreateContainer() {
auto container = CreateContainer(false);
if (!container) {
- return v2::Error(container.GetError(), "bar");
+ return Error(container.GetError(), "bar");
}
return container;
}
@@ -264,9 +264,9 @@
DISALLOW_COPY_AND_ASSIGN(NoCopyContainer);
};
-v2::Result<std::unique_ptr<NoCopyContainer>> CreateNoCopyContainer(bool succeed) {
+Result<std::unique_ptr<NoCopyContainer>> CreateNoCopyContainer(bool succeed) {
if (!succeed) {
- return v2::Error("foo");
+ return Error("foo");
}
std::unique_ptr<NoCopyContainer> p(new NoCopyContainer{0U});
p->value = 42U;