Adam Lesinski | 7ad1110 | 2016-10-28 16:39:15 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2016 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #include "androidfw/LoadedArsc.h" |
| 18 | |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 19 | #include "androidfw/ResourceUtils.h" |
| 20 | |
Adam Lesinski | 7ad1110 | 2016-10-28 16:39:15 -0700 | [diff] [blame] | 21 | #include "TestHelpers.h" |
| 22 | #include "data/basic/R.h" |
Adam Lesinski | da431a2 | 2016-12-29 16:08:16 -0500 | [diff] [blame] | 23 | #include "data/libclient/R.h" |
Adam Lesinski | 73f6f9d | 2017-11-14 10:18:05 -0800 | [diff] [blame] | 24 | #include "data/sparse/R.h" |
Adam Lesinski | 7ad1110 | 2016-10-28 16:39:15 -0700 | [diff] [blame] | 25 | #include "data/styles/R.h" |
| 26 | |
| 27 | namespace app = com::android::app; |
| 28 | namespace basic = com::android::basic; |
Adam Lesinski | da431a2 | 2016-12-29 16:08:16 -0500 | [diff] [blame] | 29 | namespace libclient = com::android::libclient; |
Adam Lesinski | 73f6f9d | 2017-11-14 10:18:05 -0800 | [diff] [blame] | 30 | namespace sparse = com::android::sparse; |
Adam Lesinski | 7ad1110 | 2016-10-28 16:39:15 -0700 | [diff] [blame] | 31 | |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 32 | using ::testing::Eq; |
| 33 | using ::testing::Ge; |
| 34 | using ::testing::IsNull; |
| 35 | using ::testing::NotNull; |
| 36 | using ::testing::SizeIs; |
| 37 | using ::testing::StrEq; |
| 38 | |
Adam Lesinski | 7ad1110 | 2016-10-28 16:39:15 -0700 | [diff] [blame] | 39 | namespace android { |
| 40 | |
| 41 | TEST(LoadedArscTest, LoadSinglePackageArsc) { |
Adam Lesinski | 7ad1110 | 2016-10-28 16:39:15 -0700 | [diff] [blame] | 42 | std::string contents; |
| 43 | ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/styles/styles.apk", "resources.arsc", |
| 44 | &contents)); |
| 45 | |
Adam Lesinski | 970bd8d | 2017-09-25 13:21:55 -0700 | [diff] [blame] | 46 | std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(StringPiece(contents)); |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 47 | ASSERT_THAT(loaded_arsc, NotNull()); |
Adam Lesinski | 7ad1110 | 2016-10-28 16:39:15 -0700 | [diff] [blame] | 48 | |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 49 | const LoadedPackage* package = |
| 50 | loaded_arsc->GetPackageById(get_package_id(app::R::string::string_one)); |
| 51 | ASSERT_THAT(package, NotNull()); |
| 52 | EXPECT_THAT(package->GetPackageName(), StrEq("com.android.app")); |
| 53 | EXPECT_THAT(package->GetPackageId(), Eq(0x7f)); |
Adam Lesinski | da431a2 | 2016-12-29 16:08:16 -0500 | [diff] [blame] | 54 | |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 55 | const uint8_t type_index = get_type_id(app::R::string::string_one) - 1; |
| 56 | const uint16_t entry_index = get_entry_id(app::R::string::string_one); |
Adam Lesinski | 7ad1110 | 2016-10-28 16:39:15 -0700 | [diff] [blame] | 57 | |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 58 | const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(type_index); |
| 59 | ASSERT_THAT(type_spec, NotNull()); |
| 60 | ASSERT_THAT(type_spec->type_count, Ge(1u)); |
Adam Lesinski | 7ad1110 | 2016-10-28 16:39:15 -0700 | [diff] [blame] | 61 | |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 62 | const ResTable_type* type = type_spec->types[0]; |
| 63 | ASSERT_THAT(type, NotNull()); |
| 64 | ASSERT_THAT(LoadedPackage::GetEntry(type, entry_index), NotNull()); |
Adam Lesinski | 7ad1110 | 2016-10-28 16:39:15 -0700 | [diff] [blame] | 65 | } |
| 66 | |
Adam Lesinski | 73f6f9d | 2017-11-14 10:18:05 -0800 | [diff] [blame] | 67 | TEST(LoadedArscTest, LoadSparseEntryApp) { |
| 68 | std::string contents; |
| 69 | ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/sparse/sparse.apk", "resources.arsc", |
| 70 | &contents)); |
| 71 | |
| 72 | std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(StringPiece(contents)); |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 73 | ASSERT_THAT(loaded_arsc, NotNull()); |
Adam Lesinski | 73f6f9d | 2017-11-14 10:18:05 -0800 | [diff] [blame] | 74 | |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 75 | const LoadedPackage* package = |
| 76 | loaded_arsc->GetPackageById(get_package_id(sparse::R::integer::foo_9)); |
| 77 | ASSERT_THAT(package, NotNull()); |
Adam Lesinski | 73f6f9d | 2017-11-14 10:18:05 -0800 | [diff] [blame] | 78 | |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 79 | const uint8_t type_index = get_type_id(sparse::R::integer::foo_9) - 1; |
| 80 | const uint16_t entry_index = get_entry_id(sparse::R::integer::foo_9); |
| 81 | |
| 82 | const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(type_index); |
| 83 | ASSERT_THAT(type_spec, NotNull()); |
| 84 | ASSERT_THAT(type_spec->type_count, Ge(1u)); |
| 85 | |
| 86 | const ResTable_type* type = type_spec->types[0]; |
| 87 | ASSERT_THAT(type, NotNull()); |
| 88 | ASSERT_THAT(LoadedPackage::GetEntry(type, entry_index), NotNull()); |
Adam Lesinski | 73f6f9d | 2017-11-14 10:18:05 -0800 | [diff] [blame] | 89 | } |
| 90 | |
Adam Lesinski | da431a2 | 2016-12-29 16:08:16 -0500 | [diff] [blame] | 91 | TEST(LoadedArscTest, LoadSharedLibrary) { |
| 92 | std::string contents; |
| 93 | ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/lib_one/lib_one.apk", "resources.arsc", |
| 94 | &contents)); |
| 95 | |
Adam Lesinski | 970bd8d | 2017-09-25 13:21:55 -0700 | [diff] [blame] | 96 | std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(StringPiece(contents)); |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 97 | ASSERT_THAT(loaded_arsc, NotNull()); |
Adam Lesinski | da431a2 | 2016-12-29 16:08:16 -0500 | [diff] [blame] | 98 | |
| 99 | const auto& packages = loaded_arsc->GetPackages(); |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 100 | ASSERT_THAT(packages, SizeIs(1u)); |
Adam Lesinski | da431a2 | 2016-12-29 16:08:16 -0500 | [diff] [blame] | 101 | EXPECT_TRUE(packages[0]->IsDynamic()); |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 102 | EXPECT_THAT(packages[0]->GetPackageName(), StrEq("com.android.lib_one")); |
| 103 | EXPECT_THAT(packages[0]->GetPackageId(), Eq(0)); |
Adam Lesinski | da431a2 | 2016-12-29 16:08:16 -0500 | [diff] [blame] | 104 | |
| 105 | const auto& dynamic_pkg_map = packages[0]->GetDynamicPackageMap(); |
| 106 | |
| 107 | // The library has no dependencies. |
| 108 | ASSERT_TRUE(dynamic_pkg_map.empty()); |
| 109 | } |
| 110 | |
| 111 | TEST(LoadedArscTest, LoadAppLinkedAgainstSharedLibrary) { |
| 112 | std::string contents; |
| 113 | ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/libclient/libclient.apk", |
| 114 | "resources.arsc", &contents)); |
| 115 | |
Adam Lesinski | 970bd8d | 2017-09-25 13:21:55 -0700 | [diff] [blame] | 116 | std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(StringPiece(contents)); |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 117 | ASSERT_THAT(loaded_arsc, NotNull()); |
Adam Lesinski | da431a2 | 2016-12-29 16:08:16 -0500 | [diff] [blame] | 118 | |
| 119 | const auto& packages = loaded_arsc->GetPackages(); |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 120 | ASSERT_THAT(packages, SizeIs(1u)); |
Adam Lesinski | da431a2 | 2016-12-29 16:08:16 -0500 | [diff] [blame] | 121 | EXPECT_FALSE(packages[0]->IsDynamic()); |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 122 | EXPECT_THAT(packages[0]->GetPackageName(), StrEq("com.android.libclient")); |
| 123 | EXPECT_THAT(packages[0]->GetPackageId(), Eq(0x7f)); |
Adam Lesinski | da431a2 | 2016-12-29 16:08:16 -0500 | [diff] [blame] | 124 | |
| 125 | const auto& dynamic_pkg_map = packages[0]->GetDynamicPackageMap(); |
| 126 | |
| 127 | // The library has two dependencies. |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 128 | ASSERT_THAT(dynamic_pkg_map, SizeIs(2u)); |
| 129 | EXPECT_THAT(dynamic_pkg_map[0].package_name, StrEq("com.android.lib_one")); |
| 130 | EXPECT_THAT(dynamic_pkg_map[0].package_id, Eq(0x02)); |
Adam Lesinski | da431a2 | 2016-12-29 16:08:16 -0500 | [diff] [blame] | 131 | |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 132 | EXPECT_THAT(dynamic_pkg_map[1].package_name, StrEq("com.android.lib_two")); |
| 133 | EXPECT_THAT(dynamic_pkg_map[1].package_id, Eq(0x03)); |
Adam Lesinski | da431a2 | 2016-12-29 16:08:16 -0500 | [diff] [blame] | 134 | } |
| 135 | |
| 136 | TEST(LoadedArscTest, LoadAppAsSharedLibrary) { |
| 137 | std::string contents; |
| 138 | ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/appaslib/appaslib.apk", |
| 139 | "resources.arsc", &contents)); |
| 140 | |
Adam Lesinski | 970bd8d | 2017-09-25 13:21:55 -0700 | [diff] [blame] | 141 | std::unique_ptr<const LoadedArsc> loaded_arsc = |
| 142 | LoadedArsc::Load(StringPiece(contents), nullptr /*loaded_idmap*/, false /*system*/, |
| 143 | true /*load_as_shared_library*/); |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 144 | ASSERT_THAT(loaded_arsc, NotNull()); |
Adam Lesinski | da431a2 | 2016-12-29 16:08:16 -0500 | [diff] [blame] | 145 | |
| 146 | const auto& packages = loaded_arsc->GetPackages(); |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 147 | ASSERT_THAT(packages, SizeIs(1u)); |
Adam Lesinski | da431a2 | 2016-12-29 16:08:16 -0500 | [diff] [blame] | 148 | EXPECT_TRUE(packages[0]->IsDynamic()); |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 149 | EXPECT_THAT(packages[0]->GetPackageId(), Eq(0x7f)); |
Adam Lesinski | da431a2 | 2016-12-29 16:08:16 -0500 | [diff] [blame] | 150 | } |
| 151 | |
Adam Lesinski | c6aada9 | 2017-01-13 15:34:14 -0800 | [diff] [blame] | 152 | TEST(LoadedArscTest, LoadFeatureSplit) { |
| 153 | std::string contents; |
| 154 | ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/feature/feature.apk", "resources.arsc", |
| 155 | &contents)); |
Adam Lesinski | 970bd8d | 2017-09-25 13:21:55 -0700 | [diff] [blame] | 156 | std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(StringPiece(contents)); |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 157 | ASSERT_THAT(loaded_arsc, NotNull()); |
Adam Lesinski | c6aada9 | 2017-01-13 15:34:14 -0800 | [diff] [blame] | 158 | |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 159 | const LoadedPackage* package = |
| 160 | loaded_arsc->GetPackageById(get_package_id(basic::R::string::test3)); |
| 161 | ASSERT_THAT(package, NotNull()); |
Adam Lesinski | c6aada9 | 2017-01-13 15:34:14 -0800 | [diff] [blame] | 162 | |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 163 | uint8_t type_index = get_type_id(basic::R::string::test3) - 1; |
| 164 | uint8_t entry_index = get_entry_id(basic::R::string::test3); |
| 165 | |
| 166 | const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(type_index); |
| 167 | ASSERT_THAT(type_spec, NotNull()); |
| 168 | ASSERT_THAT(type_spec->type_count, Ge(1u)); |
| 169 | ASSERT_THAT(type_spec->types[0], NotNull()); |
Adam Lesinski | c6aada9 | 2017-01-13 15:34:14 -0800 | [diff] [blame] | 170 | |
| 171 | size_t len; |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 172 | const char16_t* type_name16 = |
| 173 | package->GetTypeStringPool()->stringAt(type_spec->type_spec->id - 1, &len); |
| 174 | ASSERT_THAT(type_name16, NotNull()); |
| 175 | EXPECT_THAT(util::Utf16ToUtf8(StringPiece16(type_name16, len)), StrEq("string")); |
Adam Lesinski | c6aada9 | 2017-01-13 15:34:14 -0800 | [diff] [blame] | 176 | |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 177 | ASSERT_THAT(LoadedPackage::GetEntry(type_spec->types[0], entry_index), NotNull()); |
Adam Lesinski | c6aada9 | 2017-01-13 15:34:14 -0800 | [diff] [blame] | 178 | } |
| 179 | |
Adam Lesinski | 970bd8d | 2017-09-25 13:21:55 -0700 | [diff] [blame] | 180 | class MockLoadedIdmap : public LoadedIdmap { |
| 181 | public: |
| 182 | MockLoadedIdmap() : LoadedIdmap() { |
| 183 | local_header_.magic = kIdmapMagic; |
| 184 | local_header_.version = kIdmapCurrentVersion; |
| 185 | local_header_.target_package_id = 0x08; |
| 186 | local_header_.type_count = 1; |
| 187 | header_ = &local_header_; |
| 188 | |
| 189 | entry_header = util::unique_cptr<IdmapEntry_header>( |
| 190 | (IdmapEntry_header*)::malloc(sizeof(IdmapEntry_header) + sizeof(uint32_t))); |
| 191 | entry_header->target_type_id = 0x03; |
| 192 | entry_header->overlay_type_id = 0x02; |
| 193 | entry_header->entry_id_offset = 1; |
| 194 | entry_header->entry_count = 1; |
| 195 | entry_header->entries[0] = 0x00000000u; |
| 196 | type_map_[entry_header->overlay_type_id] = entry_header.get(); |
| 197 | } |
| 198 | |
| 199 | private: |
| 200 | Idmap_header local_header_; |
| 201 | util::unique_cptr<IdmapEntry_header> entry_header; |
| 202 | }; |
| 203 | |
| 204 | TEST(LoadedArscTest, LoadOverlay) { |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 205 | std::string contents; |
Adam Lesinski | 970bd8d | 2017-09-25 13:21:55 -0700 | [diff] [blame] | 206 | ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/overlay/overlay.apk", "resources.arsc", |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 207 | &contents)); |
Adam Lesinski | 970bd8d | 2017-09-25 13:21:55 -0700 | [diff] [blame] | 208 | |
| 209 | MockLoadedIdmap loaded_idmap; |
| 210 | |
| 211 | std::unique_ptr<const LoadedArsc> loaded_arsc = |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 212 | LoadedArsc::Load(StringPiece(contents), &loaded_idmap); |
| 213 | ASSERT_THAT(loaded_arsc, NotNull()); |
Adam Lesinski | 970bd8d | 2017-09-25 13:21:55 -0700 | [diff] [blame] | 214 | |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 215 | const LoadedPackage* package = loaded_arsc->GetPackageById(0x08u); |
| 216 | ASSERT_THAT(package, NotNull()); |
Adam Lesinski | 970bd8d | 2017-09-25 13:21:55 -0700 | [diff] [blame] | 217 | |
Adam Lesinski | 64ee69d | 2018-01-08 17:38:30 -0800 | [diff] [blame] | 218 | const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(0x03u - 1); |
| 219 | ASSERT_THAT(type_spec, NotNull()); |
| 220 | ASSERT_THAT(type_spec->type_count, Ge(1u)); |
| 221 | ASSERT_THAT(type_spec->types[0], NotNull()); |
| 222 | |
| 223 | // The entry being overlaid doesn't exist at the original entry index. |
| 224 | ASSERT_THAT(LoadedPackage::GetEntry(type_spec->types[0], 0x0001u), IsNull()); |
| 225 | |
| 226 | // Since this is an overlay, the actual entry ID must be mapped. |
| 227 | ASSERT_THAT(type_spec->idmap_entries, NotNull()); |
| 228 | uint16_t target_entry_id = 0u; |
| 229 | ASSERT_TRUE(LoadedIdmap::Lookup(type_spec->idmap_entries, 0x0001u, &target_entry_id)); |
| 230 | ASSERT_THAT(target_entry_id, Eq(0x0u)); |
| 231 | ASSERT_THAT(LoadedPackage::GetEntry(type_spec->types[0], 0x0000), NotNull()); |
Adam Lesinski | 970bd8d | 2017-09-25 13:21:55 -0700 | [diff] [blame] | 232 | } |
| 233 | |
Adam Lesinski | 7ad1110 | 2016-10-28 16:39:15 -0700 | [diff] [blame] | 234 | // structs with size fields (like Res_value, ResTable_entry) should be |
| 235 | // backwards and forwards compatible (aka checking the size field against |
| 236 | // sizeof(Res_value) might not be backwards compatible. |
| 237 | TEST(LoadedArscTest, LoadingShouldBeForwardsAndBackwardsCompatible) { ASSERT_TRUE(false); } |
| 238 | |
| 239 | } // namespace android |