Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ad758fca1f3ef94de03a65490ab011bc7ac49e24
frameworks_base/libs/androidfw/tests/LoadedArsc_test.cpp
Brandon Liu 742b11e05d Fix tests affected by sparse.apk 
Regenerated sparse.apk with latest aapt2 and updated resource qualifier
to orientation from sdk version because config sdk version was fully
dropped in aapt2. Also added tests with runtime apk generated by Soong
build target to make these tests more comprehensive. Applied
parameterized test to avoid duplicate code.

Bug: b/249370927
Test: Added and verified affected atests pass
Change-Id: I94f6758d7862375fe4053f42fe89953d4afa48fd
2022-11-11 22:57:18 +00:00

432 lines
18 KiB
C++
Raw Blame History

/*
* Copyright (C) 2016 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 "androidfw/LoadedArsc.h"
#include "android-base/file.h"
#include "androidfw/ResourceUtils.h"
#include "TestHelpers.h"
#include "data/basic/R.h"
#include "data/libclient/R.h"
#include "data/overlayable/R.h"
#include "data/sparse/R.h"
#include "data/styles/R.h"
#include "data/system/R.h"
namespace app = com::android::app;
namespace basic = com::android::basic;
namespace libclient = com::android::libclient;
namespace overlayable = com::android::overlayable;
namespace sparse = com::android::sparse;
using ::android::base::ReadFileToString;
using ::testing::Eq;
using ::testing::Ge;
using ::testing::IsNull;
using ::testing::NotNull;
using ::testing::SizeIs;
using ::testing::StrEq;
using PolicyFlags = android::ResTable_overlayable_policy_header::PolicyFlags;
namespace android {
TEST(LoadedArscTest, LoadSinglePackageArsc) {
std::string contents;
ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/styles/styles.apk", "resources.arsc",
&contents));
auto loaded_arsc = LoadedArsc::Load(reinterpret_cast<const void*>(contents.data()),
contents.length());
ASSERT_THAT(loaded_arsc, NotNull());
const LoadedPackage* package =
loaded_arsc->GetPackageById(get_package_id(app::R::string::string_one));
ASSERT_THAT(package, NotNull());
EXPECT_THAT(package->GetPackageName(), StrEq("com.android.app"));
EXPECT_THAT(package->GetPackageId(), Eq(0x7f));
const uint8_t type_index = get_type_id(app::R::string::string_one) - 1;
const uint16_t entry_index = get_entry_id(app::R::string::string_one);
const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(type_index);
ASSERT_THAT(type_spec, NotNull());
ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));
auto type = type_spec->type_entries[0];
ASSERT_TRUE(LoadedPackage::GetEntry(type.type, entry_index).has_value());
}
TEST(LoadedArscTest, LoadSharedLibrary) {
std::string contents;
ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/lib_one/lib_one.apk", "resources.arsc",
&contents));
std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
contents.length());
ASSERT_THAT(loaded_arsc, NotNull());
const auto& packages = loaded_arsc->GetPackages();
ASSERT_THAT(packages, SizeIs(1u));
EXPECT_TRUE(packages[0]->IsDynamic());
EXPECT_THAT(packages[0]->GetPackageName(), StrEq("com.android.lib_one"));
EXPECT_THAT(packages[0]->GetPackageId(), Eq(0));
const auto& dynamic_pkg_map = packages[0]->GetDynamicPackageMap();
// The library has no dependencies.
ASSERT_TRUE(dynamic_pkg_map.empty());
}
TEST(LoadedArscTest, LoadAppLinkedAgainstSharedLibrary) {
std::string contents;
ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/libclient/libclient.apk",
"resources.arsc", &contents));
std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
contents.length());
ASSERT_THAT(loaded_arsc, NotNull());
const auto& packages = loaded_arsc->GetPackages();
ASSERT_THAT(packages, SizeIs(1u));
EXPECT_FALSE(packages[0]->IsDynamic());
EXPECT_THAT(packages[0]->GetPackageName(), StrEq("com.android.libclient"));
EXPECT_THAT(packages[0]->GetPackageId(), Eq(0x7f));
const auto& dynamic_pkg_map = packages[0]->GetDynamicPackageMap();
// The library has two dependencies.
ASSERT_THAT(dynamic_pkg_map, SizeIs(2u));
EXPECT_THAT(dynamic_pkg_map[0].package_name, StrEq("com.android.lib_one"));
EXPECT_THAT(dynamic_pkg_map[0].package_id, Eq(0x02));
EXPECT_THAT(dynamic_pkg_map[1].package_name, StrEq("com.android.lib_two"));
EXPECT_THAT(dynamic_pkg_map[1].package_id, Eq(0x03));
}
TEST(LoadedArscTest, LoadAppAsSharedLibrary) {
std::string contents;
ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/appaslib/appaslib.apk",
"resources.arsc", &contents));
std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
contents.length(),
nullptr /* loaded_idmap */,
PROPERTY_DYNAMIC);
ASSERT_THAT(loaded_arsc, NotNull());
const auto& packages = loaded_arsc->GetPackages();
ASSERT_THAT(packages, SizeIs(1u));
EXPECT_TRUE(packages[0]->IsDynamic());
EXPECT_THAT(packages[0]->GetPackageId(), Eq(0x7f));
}
TEST(LoadedArscTest, LoadFeatureSplit) {
std::string contents;
ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/feature/feature.apk", "resources.arsc",
&contents));
std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
contents.length());
ASSERT_THAT(loaded_arsc, NotNull());
const LoadedPackage* package =
loaded_arsc->GetPackageById(get_package_id(basic::R::string::test3));
ASSERT_THAT(package, NotNull());
uint8_t type_index = get_type_id(basic::R::string::test3) - 1;
uint8_t entry_index = get_entry_id(basic::R::string::test3);
const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(type_index);
ASSERT_THAT(type_spec, NotNull());
ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));
auto type_name16 = package->GetTypeStringPool()->stringAt(type_spec->type_spec->id - 1);
ASSERT_TRUE(type_name16.has_value());
EXPECT_THAT(util::Utf16ToUtf8(*type_name16), StrEq("string"));
ASSERT_TRUE(LoadedPackage::GetEntry(type_spec->type_entries[0].type, entry_index).has_value());
}
// AAPT(2) generates resource tables with chunks in a certain order. The rule is that
// a RES_TABLE_TYPE_TYPE with id `i` must always be preceded by a RES_TABLE_TYPE_SPEC_TYPE with
// id `i`. The RES_TABLE_TYPE_SPEC_TYPE does not need to be directly preceding, however.
//
// AAPT(2) generates something like:
// RES_TABLE_TYPE_SPEC_TYPE id=1
// RES_TABLE_TYPE_TYPE id=1
// RES_TABLE_TYPE_SPEC_TYPE id=2
// RES_TABLE_TYPE_TYPE id=2
//
// But the following is valid too:
// RES_TABLE_TYPE_SPEC_TYPE id=1
// RES_TABLE_TYPE_SPEC_TYPE id=2
// RES_TABLE_TYPE_TYPE id=1
// RES_TABLE_TYPE_TYPE id=2
//
TEST(LoadedArscTest, LoadOutOfOrderTypeSpecs) {
std::string contents;
ASSERT_TRUE(
ReadFileFromZipToString(GetTestDataPath() + "/out_of_order_types/out_of_order_types.apk",
"resources.arsc", &contents));
std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
contents.length());
ASSERT_THAT(loaded_arsc, NotNull());
ASSERT_THAT(loaded_arsc->GetPackages(), SizeIs(1u));
const auto& package = loaded_arsc->GetPackages()[0];
ASSERT_THAT(package, NotNull());
const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(0);
ASSERT_THAT(type_spec, NotNull());
ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));
type_spec = package->GetTypeSpecByTypeIndex(1);
ASSERT_THAT(type_spec, NotNull());
ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));
}
TEST(LoadedArscTest, LoadOverlayable) {
std::string contents;
ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/overlayable/overlayable.apk",
"resources.arsc", &contents));
std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
contents.length());
ASSERT_THAT(loaded_arsc, NotNull());
const LoadedPackage* package = loaded_arsc->GetPackageById(
get_package_id(overlayable::R::string::not_overlayable));
const OverlayableInfo* info = package->GetOverlayableInfo(
overlayable::R::string::not_overlayable);
ASSERT_THAT(info, IsNull());
info = package->GetOverlayableInfo(overlayable::R::string::overlayable1);
ASSERT_THAT(info, NotNull());
EXPECT_THAT(info->name, Eq("OverlayableResources1"));
EXPECT_THAT(info->actor, Eq("overlay://theme"));
EXPECT_THAT(info->policy_flags, Eq(PolicyFlags::PUBLIC));
info = package->GetOverlayableInfo(overlayable::R::string::overlayable2);
ASSERT_THAT(info, NotNull());
EXPECT_THAT(info->name, Eq("OverlayableResources1"));
EXPECT_THAT(info->actor, Eq("overlay://theme"));
EXPECT_THAT(info->policy_flags,
Eq(PolicyFlags::SYSTEM_PARTITION
| PolicyFlags::PRODUCT_PARTITION));
info = package->GetOverlayableInfo(overlayable::R::string::overlayable3);
ASSERT_THAT(info, NotNull());
EXPECT_THAT(info->name, Eq("OverlayableResources2"));
EXPECT_THAT(info->actor, Eq("overlay://com.android.overlayable"));
EXPECT_THAT(info->policy_flags,
Eq(PolicyFlags::VENDOR_PARTITION
| PolicyFlags::PRODUCT_PARTITION));
info = package->GetOverlayableInfo(overlayable::R::string::overlayable4);
EXPECT_THAT(info->name, Eq("OverlayableResources1"));
EXPECT_THAT(info->actor, Eq("overlay://theme"));
ASSERT_THAT(info, NotNull());
EXPECT_THAT(info->policy_flags, Eq(PolicyFlags::PUBLIC));
}
TEST(LoadedArscTest, ResourceIdentifierIterator) {
std::string contents;
ASSERT_TRUE(
ReadFileFromZipToString(GetTestDataPath() + "/basic/basic.apk", "resources.arsc", &contents));
std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
contents.length());
ASSERT_NE(nullptr, loaded_arsc);
const std::vector<std::unique_ptr<const LoadedPackage>>& packages = loaded_arsc->GetPackages();
ASSERT_EQ(1u, packages.size());
ASSERT_EQ(std::string("com.android.basic"), packages[0]->GetPackageName());
const auto& loaded_package = packages[0];
auto iter = loaded_package->begin();
auto end = loaded_package->end();
ASSERT_NE(end, iter);
ASSERT_EQ(0x7f010000u, *iter++);
ASSERT_EQ(0x7f010001u, *iter++);
ASSERT_EQ(0x7f020000u, *iter++);
ASSERT_EQ(0x7f020001u, *iter++);
ASSERT_EQ(0x7f030000u, *iter++);
ASSERT_EQ(0x7f030001u, *iter++);
ASSERT_EQ(0x7f030002u, *iter++); // note: string without default, excluded by aapt2 dump
ASSERT_EQ(0x7f040000u, *iter++);
ASSERT_EQ(0x7f040001u, *iter++);
ASSERT_EQ(0x7f040002u, *iter++);
ASSERT_EQ(0x7f040003u, *iter++);
ASSERT_EQ(0x7f040004u, *iter++);
ASSERT_EQ(0x7f040005u, *iter++);
ASSERT_EQ(0x7f040006u, *iter++);
ASSERT_EQ(0x7f040007u, *iter++);
ASSERT_EQ(0x7f040008u, *iter++);
ASSERT_EQ(0x7f040009u, *iter++);
ASSERT_EQ(0x7f04000au, *iter++);
ASSERT_EQ(0x7f04000bu, *iter++);
ASSERT_EQ(0x7f04000cu, *iter++);
ASSERT_EQ(0x7f04000du, *iter++);
ASSERT_EQ(0x7f050000u, *iter++);
ASSERT_EQ(0x7f050001u, *iter++);
ASSERT_EQ(0x7f060000u, *iter++);
ASSERT_EQ(0x7f070000u, *iter++);
ASSERT_EQ(0x7f070001u, *iter++);
ASSERT_EQ(0x7f070002u, *iter++);
ASSERT_EQ(0x7f070003u, *iter++);
ASSERT_EQ(end, iter);
}
TEST(LoadedArscTest, GetOverlayableMap) {
std::string contents;
ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/overlayable/overlayable.apk",
"resources.arsc", &contents));
std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
contents.length());
ASSERT_NE(nullptr, loaded_arsc);
const std::vector<std::unique_ptr<const LoadedPackage>>& packages = loaded_arsc->GetPackages();
ASSERT_EQ(1u, packages.size());
ASSERT_EQ(std::string("com.android.overlayable"), packages[0]->GetPackageName());
const auto map = packages[0]->GetOverlayableMap();
ASSERT_EQ(3, map.size());
ASSERT_EQ(map.at("OverlayableResources1"), "overlay://theme");
ASSERT_EQ(map.at("OverlayableResources2"), "overlay://com.android.overlayable");
ASSERT_EQ(map.at("OverlayableResources3"), "");
}
TEST(LoadedArscTest, LoadCustomLoader) {
auto asset = AssetsProvider::CreateAssetFromFile(GetTestDataPath() + "/loader/resources.arsc");
ASSERT_THAT(asset, NotNull());
const StringPiece data(
reinterpret_cast<const char*>(asset->getBuffer(true /*wordAligned*/)),
asset->getLength());
std::unique_ptr<const LoadedArsc> loaded_arsc =
LoadedArsc::Load(data.data(), data.length(), nullptr, PROPERTY_LOADER);
ASSERT_THAT(loaded_arsc, NotNull());
const LoadedPackage* package =
loaded_arsc->GetPackageById(get_package_id(overlayable::R::string::overlayable11));
ASSERT_THAT(package, NotNull());
EXPECT_THAT(package->GetPackageName(), StrEq("com.android.loader"));
EXPECT_THAT(package->GetPackageId(), Eq(0x7f));
const uint8_t type_index = get_type_id(overlayable::R::string::overlayable11) - 1;
const uint16_t entry_index = get_entry_id(overlayable::R::string::overlayable11);
const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(type_index);
ASSERT_THAT(type_spec, NotNull());
ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));
auto type = type_spec->type_entries[0];
ASSERT_TRUE(LoadedPackage::GetEntry(type.type, entry_index).has_value());
}
// structs with size fields (like Res_value, ResTable_entry) should be
// backwards and forwards compatible (aka checking the size field against
// sizeof(Res_value) might not be backwards compatible.
// TEST(LoadedArscTest, LoadingShouldBeForwardsAndBackwardsCompatible) { ASSERT_TRUE(false); }
class LoadedArscParameterizedTest :
public testing::TestWithParam<std::string> {
};
TEST_P(LoadedArscParameterizedTest, LoadSparseEntryApp) {
std::string contents;
ASSERT_TRUE(ReadFileFromZipToString(GetParam(), "resources.arsc", &contents));
std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
contents.length());
ASSERT_THAT(loaded_arsc, NotNull());
const LoadedPackage* package =
loaded_arsc->GetPackageById(get_package_id(sparse::R::integer::foo_9));
ASSERT_THAT(package, NotNull());
const uint8_t type_index = get_type_id(sparse::R::integer::foo_9) - 1;
const uint16_t entry_index = get_entry_id(sparse::R::integer::foo_9);
const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(type_index);
ASSERT_THAT(type_spec, NotNull());
ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));
auto type = type_spec->type_entries[0];
ASSERT_TRUE(LoadedPackage::GetEntry(type.type, entry_index).has_value());
}
TEST_P(LoadedArscParameterizedTest, FindSparseEntryApp) {
std::string contents;
ASSERT_TRUE(ReadFileFromZipToString(GetParam(), "resources.arsc", &contents));
std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
contents.length());
ASSERT_THAT(loaded_arsc, NotNull());
const LoadedPackage* package =
loaded_arsc->GetPackageById(get_package_id(sparse::R::string::only_land));
ASSERT_THAT(package, NotNull());
const uint8_t type_index = get_type_id(sparse::R::string::only_land) - 1;
const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(type_index);
ASSERT_THAT(type_spec, NotNull());
ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));
// Type Entry with default orientation is not sparse encoded because the ratio of
// populated entries to total entries is above threshold.
// Only find out default locale because Soong build system will introduce pseudo
// locales for the apk generated at runtime.
auto type_entry_default = std::find_if(
type_spec->type_entries.begin(), type_spec->type_entries.end(),
[] (const TypeSpec::TypeEntry& x) { return x.config.orientation == 0 &&
x.config.locale == 0; });
ASSERT_NE(type_entry_default, type_spec->type_entries.end());
ASSERT_EQ(type_entry_default->type->flags & ResTable_type::FLAG_SPARSE, 0);
// Type Entry with land orientation is sparse encoded as expected.
// Only find out default locale because Soong build system will introduce pseudo
// locales for the apk generated at runtime.
auto type_entry_land = std::find_if(
type_spec->type_entries.begin(), type_spec->type_entries.end(),
[](const TypeSpec::TypeEntry& x) { return x.config.orientation ==
ResTable_config::ORIENTATION_LAND &&
x.config.locale == 0; });
ASSERT_NE(type_entry_land, type_spec->type_entries.end());
ASSERT_NE(type_entry_land->type->flags & ResTable_type::FLAG_SPARSE, 0);
// Test fetching a resource with only sparsely encoded configs by name.
auto id = package->FindEntryByName(u"string", u"only_land");
ASSERT_EQ(id.value(), fix_package_id(sparse::R::string::only_land, 0));
}
INSTANTIATE_TEST_SUITE_P(
FrameWorkResourcesLoadedArscTests,
LoadedArscParameterizedTest,
::testing::Values(
base::GetExecutableDirectory() + "/tests/data/sparse/sparse.apk",
base::GetExecutableDirectory() + "/FrameworkResourcesSparseTestApp.apk"
));
} // namespace android
Reference in New Issue View Git Blame Copy Permalink