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/AssetManager2.h"
18 #include "androidfw/AssetManager.h"
19
20 #include "TestHelpers.h"
21 #include "android-base/file.h"
22 #include "android-base/logging.h"
23 #include "androidfw/ResourceUtils.h"
24 #include "data/appaslib/R.h"
25 #include "data/basic/R.h"
26 #include "data/lib_one/R.h"
27 #include "data/lib_two/R.h"
28 #include "data/libclient/R.h"
29 #include "data/styles/R.h"
30 #include "data/system/R.h"
31
32 namespace app = com::android::app;
33 namespace appaslib = com::android::appaslib::app;
34 namespace basic = com::android::basic;
35 namespace lib_one = com::android::lib_one;
36 namespace lib_two = com::android::lib_two;
37 namespace libclient = com::android::libclient;
38
39 using ::testing::Eq;
40 using ::testing::NotNull;
41 using ::testing::StrEq;
42
43 namespace android {
44
45 class AssetManager2Test : public ::testing::Test {
46 public:
SetUp()47 void SetUp() override {
48 // Move to the test data directory so the idmap can locate the overlay APK.
49 std::string original_path = base::GetExecutableDirectory();
50 chdir(GetTestDataPath().c_str());
51
52 basic_assets_ = ApkAssets::Load("basic/basic.apk");
53 ASSERT_NE(nullptr, basic_assets_);
54
55 basic_de_fr_assets_ = ApkAssets::Load("basic/basic_de_fr.apk");
56 ASSERT_NE(nullptr, basic_de_fr_assets_);
57
58 basic_xhdpi_assets_ = ApkAssets::Load("basic/basic_xhdpi-v4.apk");
59 ASSERT_NE(nullptr, basic_de_fr_assets_);
60
61 basic_xxhdpi_assets_ = ApkAssets::Load("basic/basic_xxhdpi-v4.apk");
62 ASSERT_NE(nullptr, basic_de_fr_assets_);
63
64 style_assets_ = ApkAssets::Load("styles/styles.apk");
65 ASSERT_NE(nullptr, style_assets_);
66
67 lib_one_assets_ = ApkAssets::Load("lib_one/lib_one.apk");
68 ASSERT_NE(nullptr, lib_one_assets_);
69
70 lib_two_assets_ = ApkAssets::Load("lib_two/lib_two.apk");
71 ASSERT_NE(nullptr, lib_two_assets_);
72
73 libclient_assets_ = ApkAssets::Load("libclient/libclient.apk");
74 ASSERT_NE(nullptr, libclient_assets_);
75
76 appaslib_assets_ = ApkAssets::Load("appaslib/appaslib.apk", PROPERTY_DYNAMIC);
77 ASSERT_NE(nullptr, appaslib_assets_);
78
79 system_assets_ = ApkAssets::Load("system/system.apk", PROPERTY_SYSTEM);
80 ASSERT_NE(nullptr, system_assets_);
81
82 app_assets_ = ApkAssets::Load("app/app.apk");
83 ASSERT_THAT(app_assets_, NotNull());
84
85 overlay_assets_ = ApkAssets::LoadOverlay("overlay/overlay.idmap");
86 ASSERT_NE(nullptr, overlay_assets_);
87
88 overlayable_assets_ = ApkAssets::Load("overlayable/overlayable.apk");
89 ASSERT_THAT(overlayable_assets_, NotNull());
90 chdir(original_path.c_str());
91 }
92
93 protected:
94 std::unique_ptr<const ApkAssets> basic_assets_;
95 std::unique_ptr<const ApkAssets> basic_de_fr_assets_;
96 std::unique_ptr<const ApkAssets> basic_xhdpi_assets_;
97 std::unique_ptr<const ApkAssets> basic_xxhdpi_assets_;
98 std::unique_ptr<const ApkAssets> style_assets_;
99 std::unique_ptr<const ApkAssets> lib_one_assets_;
100 std::unique_ptr<const ApkAssets> lib_two_assets_;
101 std::unique_ptr<const ApkAssets> libclient_assets_;
102 std::unique_ptr<const ApkAssets> appaslib_assets_;
103 std::unique_ptr<const ApkAssets> system_assets_;
104 std::unique_ptr<const ApkAssets> app_assets_;
105 std::unique_ptr<const ApkAssets> overlay_assets_;
106 std::unique_ptr<const ApkAssets> overlayable_assets_;
107 };
108
TEST_F(AssetManager2Test,FindsResourceFromSingleApkAssets)109 TEST_F(AssetManager2Test, FindsResourceFromSingleApkAssets) {
110 ResTable_config desired_config;
111 memset(&desired_config, 0, sizeof(desired_config));
112 desired_config.language[0] = 'd';
113 desired_config.language[1] = 'e';
114
115 AssetManager2 assetmanager;
116 assetmanager.SetConfiguration(desired_config);
117 assetmanager.SetApkAssets({basic_assets_.get()});
118
119 auto value = assetmanager.GetResource(basic::R::string::test1);
120 ASSERT_TRUE(value.has_value());
121
122 // Came from our ApkAssets.
123 EXPECT_EQ(0, value->cookie);
124
125 // It is the default config.
126 EXPECT_EQ(0, value->config.language[0]);
127 EXPECT_EQ(0, value->config.language[1]);
128
129 // It is a string.
130 EXPECT_EQ(Res_value::TYPE_STRING, value->type);
131 }
132
TEST_F(AssetManager2Test,FindsResourceFromMultipleApkAssets)133 TEST_F(AssetManager2Test, FindsResourceFromMultipleApkAssets) {
134 ResTable_config desired_config;
135 memset(&desired_config, 0, sizeof(desired_config));
136 desired_config.language[0] = 'd';
137 desired_config.language[1] = 'e';
138
139 AssetManager2 assetmanager;
140 assetmanager.SetConfiguration(desired_config);
141 assetmanager.SetApkAssets({basic_assets_.get(), basic_de_fr_assets_.get()});
142
143 auto value = assetmanager.GetResource(basic::R::string::test1);
144 ASSERT_TRUE(value.has_value());
145
146 // Came from our de_fr ApkAssets.
147 EXPECT_EQ(1, value->cookie);
148
149 // The configuration is German.
150 EXPECT_EQ('d', value->config.language[0]);
151 EXPECT_EQ('e', value->config.language[1]);
152
153 // It is a string.
154 EXPECT_EQ(Res_value::TYPE_STRING, value->type);
155 }
156
TEST_F(AssetManager2Test,FindsResourceFromSharedLibrary)157 TEST_F(AssetManager2Test, FindsResourceFromSharedLibrary) {
158 AssetManager2 assetmanager;
159
160 // libclient is built with lib_one and then lib_two in order.
161 // Reverse the order to test that proper package ID re-assignment is happening.
162 assetmanager.SetApkAssets(
163 {lib_two_assets_.get(), lib_one_assets_.get(), libclient_assets_.get()});
164
165 auto value = assetmanager.GetResource(libclient::R::string::foo_one);
166 ASSERT_TRUE(value.has_value());
167
168 // Reference comes from libclient.
169 EXPECT_EQ(2, value->cookie);
170 EXPECT_EQ(Res_value::TYPE_REFERENCE, value->type);
171
172 // Lookup the reference.
173 value = assetmanager.GetResource(value->data);
174 ASSERT_TRUE(value.has_value());
175 EXPECT_EQ(1, value->cookie);
176 EXPECT_EQ(Res_value::TYPE_STRING, value->type);
177 EXPECT_EQ(std::string("Foo from lib_one"),
178 GetStringFromPool(assetmanager.GetStringPoolForCookie(value->cookie), value->data));
179
180 value = assetmanager.GetResource(libclient::R::string::foo_two);
181 ASSERT_TRUE(value.has_value());
182
183 // Reference comes from libclient.
184 EXPECT_EQ(2, value->cookie);
185 EXPECT_EQ(Res_value::TYPE_REFERENCE, value->type);
186
187 // Lookup the reference.
188 value = assetmanager.GetResource(value->data);
189 ASSERT_TRUE(value.has_value());
190 EXPECT_EQ(0, value->cookie);
191 EXPECT_EQ(Res_value::TYPE_STRING, value->type);
192 EXPECT_EQ(std::string("Foo from lib_two"),
193 GetStringFromPool(assetmanager.GetStringPoolForCookie(value->cookie), value->data));
194 }
195
TEST_F(AssetManager2Test,FindsResourceFromAppLoadedAsSharedLibrary)196 TEST_F(AssetManager2Test, FindsResourceFromAppLoadedAsSharedLibrary) {
197 AssetManager2 assetmanager;
198 assetmanager.SetApkAssets({appaslib_assets_.get()});
199
200 // The appaslib package will have been assigned the package ID 0x02.
201 auto value = assetmanager.GetResource(fix_package_id(appaslib::R::integer::number1, 0x02));
202 ASSERT_TRUE(value.has_value());
203 EXPECT_EQ(Res_value::TYPE_REFERENCE, value->type);
204 EXPECT_EQ(fix_package_id(appaslib::R::array::integerArray1, 0x02), value->data);
205 }
206
TEST_F(AssetManager2Test,AssignsOverlayPackageIdLast)207 TEST_F(AssetManager2Test, AssignsOverlayPackageIdLast) {
208 AssetManager2 assetmanager;
209 assetmanager.SetApkAssets(
210 {overlayable_assets_.get(), overlay_assets_.get(), lib_one_assets_.get()});
211
212 auto apk_assets = assetmanager.GetApkAssets();
213 ASSERT_EQ(3, apk_assets.size());
214 ASSERT_EQ(overlayable_assets_.get(), apk_assets[0]);
215 ASSERT_EQ(overlay_assets_.get(), apk_assets[1]);
216 ASSERT_EQ(lib_one_assets_.get(), apk_assets[2]);
217
218 auto get_first_package_id = [&assetmanager](const ApkAssets* apkAssets) -> uint8_t {
219 return assetmanager.GetAssignedPackageId(apkAssets->GetLoadedArsc()->GetPackages()[0].get());
220 };
221
222 ASSERT_EQ(0x7f, get_first_package_id(overlayable_assets_.get()));
223 ASSERT_EQ(0x03, get_first_package_id(overlay_assets_.get()));
224 ASSERT_EQ(0x02, get_first_package_id(lib_one_assets_.get()));
225 }
226
TEST_F(AssetManager2Test,GetSharedLibraryResourceName)227 TEST_F(AssetManager2Test, GetSharedLibraryResourceName) {
228 AssetManager2 assetmanager;
229 assetmanager.SetApkAssets({lib_one_assets_.get()});
230
231 auto name = assetmanager.GetResourceName(lib_one::R::string::foo);
232 ASSERT_TRUE(name.has_value());
233 ASSERT_EQ("com.android.lib_one:string/foo", ToFormattedResourceString(*name));
234 }
235
TEST_F(AssetManager2Test,GetResourceNameNonMatchingConfig)236 TEST_F(AssetManager2Test, GetResourceNameNonMatchingConfig) {
237 AssetManager2 assetmanager;
238 assetmanager.SetApkAssets({basic_de_fr_assets_.get()});
239
240 auto value = assetmanager.GetResourceName(basic::R::string::test1);
241 ASSERT_TRUE(value.has_value());
242 EXPECT_EQ("com.android.basic:string/test1", ToFormattedResourceString(*value));
243 }
244
TEST_F(AssetManager2Test,GetResourceTypeSpecFlags)245 TEST_F(AssetManager2Test, GetResourceTypeSpecFlags) {
246 AssetManager2 assetmanager;
247 assetmanager.SetApkAssets({basic_de_fr_assets_.get()});
248
249 auto value = assetmanager.GetResourceTypeSpecFlags(basic::R::string::test1);
250 ASSERT_TRUE(value.has_value());
251 EXPECT_EQ(ResTable_typeSpec::SPEC_PUBLIC | ResTable_config::CONFIG_LOCALE, *value);
252 }
253
TEST_F(AssetManager2Test,FindsBagResourceFromSingleApkAssets)254 TEST_F(AssetManager2Test, FindsBagResourceFromSingleApkAssets) {
255 AssetManager2 assetmanager;
256 assetmanager.SetApkAssets({basic_assets_.get()});
257
258 auto bag = assetmanager.GetBag(basic::R::array::integerArray1);
259 ASSERT_TRUE(bag.has_value());
260
261 ASSERT_EQ(3u, (*bag)->entry_count);
262
263 EXPECT_EQ(static_cast<uint8_t>(Res_value::TYPE_INT_DEC), (*bag)->entries[0].value.dataType);
264 EXPECT_EQ(1u, (*bag)->entries[0].value.data);
265 EXPECT_EQ(0, (*bag)->entries[0].cookie);
266
267 EXPECT_EQ(static_cast<uint8_t>(Res_value::TYPE_INT_DEC), (*bag)->entries[1].value.dataType);
268 EXPECT_EQ(2u, (*bag)->entries[1].value.data);
269 EXPECT_EQ(0, (*bag)->entries[1].cookie);
270
271 EXPECT_EQ(static_cast<uint8_t>(Res_value::TYPE_INT_DEC), (*bag)->entries[2].value.dataType);
272 EXPECT_EQ(3u, (*bag)->entries[2].value.data);
273 EXPECT_EQ(0, (*bag)->entries[2].cookie);
274 }
275
TEST_F(AssetManager2Test,FindsBagResourceFromMultipleApkAssets)276 TEST_F(AssetManager2Test, FindsBagResourceFromMultipleApkAssets) {}
277
TEST_F(AssetManager2Test,FindsBagResourceFromSharedLibrary)278 TEST_F(AssetManager2Test, FindsBagResourceFromSharedLibrary) {
279 AssetManager2 assetmanager;
280
281 // libclient is built with lib_one and then lib_two in order.
282 // Reverse the order to test that proper package ID re-assignment is happening.
283 assetmanager.SetApkAssets(
284 {lib_two_assets_.get(), lib_one_assets_.get(), libclient_assets_.get()});
285
286 auto bag = assetmanager.GetBag(fix_package_id(lib_one::R::style::Theme, 0x03));
287 ASSERT_TRUE(bag.has_value());
288
289 ASSERT_GE((*bag)->entry_count, 2u);
290
291 // First two attributes come from lib_one.
292 EXPECT_EQ(1, (*bag)->entries[0].cookie);
293 EXPECT_EQ(0x03, get_package_id((*bag)->entries[0].key));
294 EXPECT_EQ(1, (*bag)->entries[1].cookie);
295 EXPECT_EQ(0x03, get_package_id((*bag)->entries[1].key));
296 }
297
TEST_F(AssetManager2Test,FindsBagResourceFromMultipleSharedLibraries)298 TEST_F(AssetManager2Test, FindsBagResourceFromMultipleSharedLibraries) {
299 AssetManager2 assetmanager;
300
301 // libclient is built with lib_one and then lib_two in order.
302 // Reverse the order to test that proper package ID re-assignment is happening.
303 assetmanager.SetApkAssets(
304 {lib_two_assets_.get(), lib_one_assets_.get(), libclient_assets_.get()});
305
306 auto bag = assetmanager.GetBag(libclient::R::style::ThemeMultiLib);
307 ASSERT_TRUE(bag.has_value());
308 ASSERT_EQ((*bag)->entry_count, 2u);
309
310 // First attribute comes from lib_two.
311 EXPECT_EQ(2, (*bag)->entries[0].cookie);
312 EXPECT_EQ(0x02, get_package_id((*bag)->entries[0].key));
313
314 // The next two attributes come from lib_one.
315 EXPECT_EQ(2, (*bag)->entries[1].cookie);
316 EXPECT_EQ(0x03, get_package_id((*bag)->entries[1].key));
317 }
318
TEST_F(AssetManager2Test,FindsStyleResourceWithParentFromSharedLibrary)319 TEST_F(AssetManager2Test, FindsStyleResourceWithParentFromSharedLibrary) {
320 AssetManager2 assetmanager;
321
322 // libclient is built with lib_one and then lib_two in order.
323 // Reverse the order to test that proper package ID re-assignment is happening.
324 assetmanager.SetApkAssets(
325 {lib_two_assets_.get(), lib_one_assets_.get(), libclient_assets_.get()});
326
327 auto bag = assetmanager.GetBag(libclient::R::style::Theme);
328 ASSERT_TRUE(bag.has_value());
329 ASSERT_GE((*bag)->entry_count, 2u);
330
331 // First two attributes come from lib_one.
332 EXPECT_EQ(1, (*bag)->entries[0].cookie);
333 EXPECT_EQ(0x03, get_package_id((*bag)->entries[0].key));
334 EXPECT_EQ(1, (*bag)->entries[1].cookie);
335 EXPECT_EQ(0x03, get_package_id((*bag)->entries[1].key));
336 }
337
TEST_F(AssetManager2Test,MergesStylesWithParentFromSingleApkAssets)338 TEST_F(AssetManager2Test, MergesStylesWithParentFromSingleApkAssets) {
339 AssetManager2 assetmanager;
340 assetmanager.SetApkAssets({style_assets_.get()});
341
342 auto bag_one = assetmanager.GetBag(app::R::style::StyleOne);
343 ASSERT_TRUE(bag_one.has_value());
344 ASSERT_EQ(2u, (*bag_one)->entry_count);
345
346 EXPECT_EQ(app::R::attr::attr_one, (*bag_one)->entries[0].key);
347 EXPECT_EQ(Res_value::TYPE_INT_DEC, (*bag_one)->entries[0].value.dataType);
348 EXPECT_EQ(1u, (*bag_one)->entries[0].value.data);
349 EXPECT_EQ(0, (*bag_one)->entries[0].cookie);
350
351 EXPECT_EQ(app::R::attr::attr_two, (*bag_one)->entries[1].key);
352 EXPECT_EQ(Res_value::TYPE_INT_DEC, (*bag_one)->entries[1].value.dataType);
353 EXPECT_EQ(2u, (*bag_one)->entries[1].value.data);
354 EXPECT_EQ(0, (*bag_one)->entries[1].cookie);
355
356 auto bag_two = assetmanager.GetBag(app::R::style::StyleTwo);
357 ASSERT_TRUE(bag_two.has_value());
358 ASSERT_EQ(6u, (*bag_two)->entry_count);
359
360 // attr_one is inherited from StyleOne.
361 EXPECT_EQ(app::R::attr::attr_one, (*bag_two)->entries[0].key);
362 EXPECT_EQ(Res_value::TYPE_INT_DEC, (*bag_two)->entries[0].value.dataType);
363 EXPECT_EQ(1u, (*bag_two)->entries[0].value.data);
364 EXPECT_EQ(0, (*bag_two)->entries[0].cookie);
365 EXPECT_EQ(app::R::style::StyleOne, (*bag_two)->entries[0].style);
366
367 // attr_two should be overridden from StyleOne by StyleTwo.
368 EXPECT_EQ(app::R::attr::attr_two, (*bag_two)->entries[1].key);
369 EXPECT_EQ(Res_value::TYPE_STRING, (*bag_two)->entries[1].value.dataType);
370 EXPECT_EQ(0, (*bag_two)->entries[1].cookie);
371 EXPECT_EQ(app::R::style::StyleTwo, (*bag_two)->entries[1].style);
372 EXPECT_EQ(std::string("string"), GetStringFromPool(assetmanager.GetStringPoolForCookie(0),
373 (*bag_two)->entries[1].value.data));
374
375 // The rest are new attributes.
376
377 EXPECT_EQ(app::R::attr::attr_three, (*bag_two)->entries[2].key);
378 EXPECT_EQ(Res_value::TYPE_ATTRIBUTE, (*bag_two)->entries[2].value.dataType);
379 EXPECT_EQ(app::R::attr::attr_indirect, (*bag_two)->entries[2].value.data);
380 EXPECT_EQ(0, (*bag_two)->entries[2].cookie);
381 EXPECT_EQ(app::R::style::StyleTwo, (*bag_two)->entries[2].style);
382
383 EXPECT_EQ(app::R::attr::attr_five, (*bag_two)->entries[3].key);
384 EXPECT_EQ(Res_value::TYPE_REFERENCE, (*bag_two)->entries[3].value.dataType);
385 EXPECT_EQ(app::R::string::string_one, (*bag_two)->entries[3].value.data);
386 EXPECT_EQ(0, (*bag_two)->entries[3].cookie);
387 EXPECT_EQ(app::R::style::StyleTwo, (*bag_two)->entries[3].style);
388
389 EXPECT_EQ(app::R::attr::attr_indirect, (*bag_two)->entries[4].key);
390 EXPECT_EQ(Res_value::TYPE_INT_DEC, (*bag_two)->entries[4].value.dataType);
391 EXPECT_EQ(3u, (*bag_two)->entries[4].value.data);
392 EXPECT_EQ(0, (*bag_two)->entries[4].cookie);
393 EXPECT_EQ(app::R::style::StyleTwo, (*bag_two)->entries[4].style);
394
395 EXPECT_EQ(app::R::attr::attr_empty, (*bag_two)->entries[5].key);
396 EXPECT_EQ(Res_value::TYPE_NULL, (*bag_two)->entries[5].value.dataType);
397 EXPECT_EQ(Res_value::DATA_NULL_EMPTY, (*bag_two)->entries[5].value.data);
398 EXPECT_EQ(0, (*bag_two)->entries[5].cookie);
399 EXPECT_EQ(app::R::style::StyleTwo, (*bag_two)->entries[5].style);
400 }
401
TEST_F(AssetManager2Test,MergeStylesCircularDependency)402 TEST_F(AssetManager2Test, MergeStylesCircularDependency) {
403 AssetManager2 assetmanager;
404 assetmanager.SetApkAssets({style_assets_.get()});
405
406 // GetBag should stop traversing the parents of styles when a circular
407 // dependency is detected
408 auto bag = assetmanager.GetBag(app::R::style::StyleFour);
409 ASSERT_TRUE(bag.has_value());
410 ASSERT_EQ(3u, (*bag)->entry_count);
411 }
412
TEST_F(AssetManager2Test,ResolveReferenceToResource)413 TEST_F(AssetManager2Test, ResolveReferenceToResource) {
414 AssetManager2 assetmanager;
415 assetmanager.SetApkAssets({basic_assets_.get()});
416
417 auto value = assetmanager.GetResource(basic::R::integer::ref1);
418 ASSERT_TRUE(value.has_value());
419 EXPECT_EQ(Res_value::TYPE_REFERENCE, value->type);
420 EXPECT_EQ(basic::R::integer::ref2, value->data);
421
422 auto result = assetmanager.ResolveReference(*value);
423 ASSERT_TRUE(result.has_value());
424 EXPECT_EQ(Res_value::TYPE_INT_DEC, value->type);
425 EXPECT_EQ(12000u, value->data);
426 EXPECT_EQ(basic::R::integer::ref2, value->resid);
427 }
428
TEST_F(AssetManager2Test,ResolveReferenceToBag)429 TEST_F(AssetManager2Test, ResolveReferenceToBag) {
430 AssetManager2 assetmanager;
431 assetmanager.SetApkAssets({basic_assets_.get()});
432
433 auto value = assetmanager.GetResource(basic::R::integer::number2, true /*may_be_bag*/);
434 ASSERT_TRUE(value.has_value());
435 EXPECT_EQ(Res_value::TYPE_REFERENCE, value->type);
436 EXPECT_EQ(basic::R::array::integerArray1, value->data);
437
438 auto result = assetmanager.ResolveReference(*value);
439 ASSERT_TRUE(result.has_value());
440 EXPECT_EQ(Res_value::TYPE_REFERENCE, value->type);
441 EXPECT_EQ(basic::R::array::integerArray1, value->data);
442 EXPECT_EQ(basic::R::array::integerArray1, value->resid);
443 }
444
TEST_F(AssetManager2Test,ResolveDeepIdReference)445 TEST_F(AssetManager2Test, ResolveDeepIdReference) {
446 AssetManager2 assetmanager;
447 assetmanager.SetApkAssets({basic_assets_.get()});
448
449 // Set up the resource ids
450 auto high_ref = assetmanager.GetResourceId("@id/high_ref", "values", "com.android.basic");
451 ASSERT_TRUE(high_ref.has_value());
452
453 auto middle_ref = assetmanager.GetResourceId("@id/middle_ref", "values", "com.android.basic");
454 ASSERT_TRUE(middle_ref.has_value());
455
456 auto low_ref = assetmanager.GetResourceId("@id/low_ref", "values", "com.android.basic");
457 ASSERT_TRUE(low_ref.has_value());
458
459 // Retrieve the most shallow resource
460 auto value = assetmanager.GetResource(*high_ref);
461 ASSERT_TRUE(value.has_value());
462 EXPECT_EQ(Res_value::TYPE_REFERENCE, value->type);
463 EXPECT_EQ(*middle_ref, value->data);;
464
465 // Check that resolving the reference resolves to the deepest id
466 auto result = assetmanager.ResolveReference(*value);
467 ASSERT_TRUE(result.has_value());
468 EXPECT_EQ(*low_ref, value->resid);
469 }
470
TEST_F(AssetManager2Test,DensityOverride)471 TEST_F(AssetManager2Test, DensityOverride) {
472 AssetManager2 assetmanager;
473 assetmanager.SetApkAssets({basic_assets_.get(), basic_xhdpi_assets_.get(),
474 basic_xxhdpi_assets_.get()});
475 assetmanager.SetConfiguration({
476 .density = ResTable_config::DENSITY_XHIGH,
477 .sdkVersion = 21,
478 });
479
480 auto value = assetmanager.GetResource(basic::R::string::density, false /*may_be_bag*/);
481 ASSERT_TRUE(value.has_value());
482 EXPECT_EQ(Res_value::TYPE_STRING, value->type);
483 EXPECT_EQ("xhdpi", GetStringFromPool(assetmanager.GetStringPoolForCookie(value->cookie),
484 value->data));
485
486 value = assetmanager.GetResource(basic::R::string::density, false /*may_be_bag*/,
487 ResTable_config::DENSITY_XXHIGH);
488 ASSERT_TRUE(value.has_value());
489 EXPECT_EQ(Res_value::TYPE_STRING, value->type);
490 EXPECT_EQ("xxhdpi", GetStringFromPool(assetmanager.GetStringPoolForCookie(value->cookie),
491 value->data));
492 }
493
TEST_F(AssetManager2Test,KeepLastReferenceIdUnmodifiedIfNoReferenceIsResolved)494 TEST_F(AssetManager2Test, KeepLastReferenceIdUnmodifiedIfNoReferenceIsResolved) {
495 AssetManager2 assetmanager;
496 assetmanager.SetApkAssets({basic_assets_.get()});
497
498 // Create some kind of value that is NOT a reference.
499 AssetManager2::SelectedValue value{};
500 value.cookie = 1;
501 value.type = Res_value::TYPE_STRING;
502 value.resid = basic::R::string::test1;
503
504 auto result = assetmanager.ResolveReference(value);
505 ASSERT_TRUE(result.has_value());
506 EXPECT_EQ(1, value.cookie);
507 EXPECT_EQ(basic::R::string::test1, value.resid);
508 }
509
TEST_F(AssetManager2Test,ResolveReferenceMissingResourceDoNotCacheFlags)510 TEST_F(AssetManager2Test, ResolveReferenceMissingResourceDoNotCacheFlags) {
511 AssetManager2 assetmanager;
512 assetmanager.SetApkAssets({basic_assets_.get()});
513 {
514 AssetManager2::SelectedValue value{};
515 value.data = basic::R::string::test1;
516 value.type = Res_value::TYPE_REFERENCE;
517 value.flags = ResTable_config::CONFIG_KEYBOARD;
518
519 auto result = assetmanager.ResolveReference(value);
520 ASSERT_TRUE(result.has_value());
521 EXPECT_EQ(Res_value::TYPE_STRING, value.type);
522 EXPECT_EQ(0, value.cookie);
523 EXPECT_EQ(basic::R::string::test1, value.resid);
524 EXPECT_EQ(ResTable_typeSpec::SPEC_PUBLIC | ResTable_config::CONFIG_KEYBOARD, value.flags);
525 }
526 {
527 AssetManager2::SelectedValue value{};
528 value.data = basic::R::string::test1;
529 value.type = Res_value::TYPE_REFERENCE;
530 value.flags = ResTable_config::CONFIG_COLOR_MODE;
531
532 auto result = assetmanager.ResolveReference(value);
533 ASSERT_TRUE(result.has_value());
534 EXPECT_EQ(Res_value::TYPE_STRING, value.type);
535 EXPECT_EQ(0, value.cookie);
536 EXPECT_EQ(basic::R::string::test1, value.resid);
537 EXPECT_EQ(ResTable_typeSpec::SPEC_PUBLIC | ResTable_config::CONFIG_COLOR_MODE, value.flags);
538 }
539 }
540
TEST_F(AssetManager2Test,ResolveReferenceMissingResource)541 TEST_F(AssetManager2Test, ResolveReferenceMissingResource) {
542 AssetManager2 assetmanager;
543 assetmanager.SetApkAssets({basic_assets_.get()});
544
545 const uint32_t kMissingResId = 0x8001ffff;
546 AssetManager2::SelectedValue value{};
547 value.type = Res_value::TYPE_REFERENCE;
548 value.data = kMissingResId;
549
550 auto result = assetmanager.ResolveReference(value);
551 ASSERT_FALSE(result.has_value());
552 EXPECT_EQ(Res_value::TYPE_REFERENCE, value.type);
553 EXPECT_EQ(kMissingResId, value.data);
554 EXPECT_EQ(kMissingResId, value.resid);
555 EXPECT_EQ(-1, value.cookie);
556 EXPECT_EQ(0, value.flags);
557 }
558
TEST_F(AssetManager2Test,ResolveReferenceMissingResourceLib)559 TEST_F(AssetManager2Test, ResolveReferenceMissingResourceLib) {
560 AssetManager2 assetmanager;
561 assetmanager.SetApkAssets({libclient_assets_.get()});
562
563 AssetManager2::SelectedValue value{};
564 value.type = Res_value::TYPE_REFERENCE;
565 value.data = libclient::R::string::foo_one;
566
567 auto result = assetmanager.ResolveReference(value);
568 ASSERT_TRUE(result.has_value());
569 EXPECT_EQ(Res_value::TYPE_DYNAMIC_REFERENCE, value.type);
570 EXPECT_EQ(lib_one::R::string::foo, value.data);
571 EXPECT_EQ(libclient::R::string::foo_one, value.resid);
572 EXPECT_EQ(0, value.cookie);
573 EXPECT_EQ(static_cast<uint32_t>(ResTable_typeSpec::SPEC_PUBLIC), value.flags);
574 }
575
IsConfigurationPresent(const std::set<ResTable_config> & configurations,const ResTable_config & configuration)576 static bool IsConfigurationPresent(const std::set<ResTable_config>& configurations,
577 const ResTable_config& configuration) {
578 return configurations.count(configuration) > 0;
579 }
580
TEST_F(AssetManager2Test,GetResourceConfigurations)581 TEST_F(AssetManager2Test, GetResourceConfigurations) {
582 AssetManager2 assetmanager;
583 assetmanager.SetApkAssets({system_assets_.get(), basic_de_fr_assets_.get()});
584
585 auto configurations = assetmanager.GetResourceConfigurations();
586 ASSERT_TRUE(configurations.has_value());
587
588 // We expect the locale sv from the system assets, and de and fr from basic_de_fr assets.
589 // And one extra for the default configuration.
590 EXPECT_EQ(4u, configurations->size());
591
592 ResTable_config expected_config;
593 memset(&expected_config, 0, sizeof(expected_config));
594 expected_config.language[0] = 's';
595 expected_config.language[1] = 'v';
596 EXPECT_TRUE(IsConfigurationPresent(*configurations, expected_config));
597
598 expected_config.language[0] = 'd';
599 expected_config.language[1] = 'e';
600 EXPECT_TRUE(IsConfigurationPresent(*configurations, expected_config));
601
602 expected_config.language[0] = 'f';
603 expected_config.language[1] = 'r';
604 EXPECT_TRUE(IsConfigurationPresent(*configurations, expected_config));
605
606 // Take out the system assets.
607 configurations = assetmanager.GetResourceConfigurations(true /* exclude_system */);
608 ASSERT_TRUE(configurations.has_value());
609
610 // We expect de and fr from basic_de_fr assets.
611 EXPECT_EQ(2u, configurations->size());
612
613 expected_config.language[0] = 's';
614 expected_config.language[1] = 'v';
615 EXPECT_FALSE(IsConfigurationPresent(*configurations, expected_config));
616
617 expected_config.language[0] = 'd';
618 expected_config.language[1] = 'e';
619 EXPECT_TRUE(IsConfigurationPresent(*configurations, expected_config));
620
621 expected_config.language[0] = 'f';
622 expected_config.language[1] = 'r';
623 EXPECT_TRUE(IsConfigurationPresent(*configurations, expected_config));
624 }
625
TEST_F(AssetManager2Test,GetResourceLocales)626 TEST_F(AssetManager2Test, GetResourceLocales) {
627 AssetManager2 assetmanager;
628 assetmanager.SetApkAssets({system_assets_.get(), basic_de_fr_assets_.get()});
629
630 std::set<std::string> locales = assetmanager.GetResourceLocales();
631
632 // We expect the locale sv from the system assets, and de and fr from basic_de_fr assets.
633 EXPECT_EQ(3u, locales.size());
634 EXPECT_GT(locales.count("sv"), 0u);
635 EXPECT_GT(locales.count("de"), 0u);
636 EXPECT_GT(locales.count("fr"), 0u);
637
638 locales = assetmanager.GetResourceLocales(true /*exclude_system*/);
639 // We expect the de and fr locales from basic_de_fr assets.
640 EXPECT_EQ(2u, locales.size());
641 EXPECT_GT(locales.count("de"), 0u);
642 EXPECT_GT(locales.count("fr"), 0u);
643 }
644
TEST_F(AssetManager2Test,GetResourceId)645 TEST_F(AssetManager2Test, GetResourceId) {
646 AssetManager2 assetmanager;
647 assetmanager.SetApkAssets({basic_assets_.get()});
648
649 auto resid = assetmanager.GetResourceId("com.android.basic:layout/main", "", "");
650 ASSERT_TRUE(resid.has_value());
651 EXPECT_EQ(basic::R::layout::main, *resid);
652
653 resid = assetmanager.GetResourceId("layout/main", "", "com.android.basic");
654 ASSERT_TRUE(resid.has_value());
655 EXPECT_EQ(basic::R::layout::main, *resid);
656
657 resid = assetmanager.GetResourceId("main", "layout", "com.android.basic");
658 ASSERT_TRUE(resid.has_value());
659 EXPECT_EQ(basic::R::layout::main, *resid);
660 }
661
TEST_F(AssetManager2Test,OpensFileFromSingleApkAssets)662 TEST_F(AssetManager2Test, OpensFileFromSingleApkAssets) {
663 AssetManager2 assetmanager;
664 assetmanager.SetApkAssets({system_assets_.get()});
665
666 std::unique_ptr<Asset> asset = assetmanager.Open("file.txt", Asset::ACCESS_BUFFER);
667 ASSERT_THAT(asset, NotNull());
668
669 const char* data = reinterpret_cast<const char*>(asset->getBuffer(false /*wordAligned*/));
670 ASSERT_THAT(data, NotNull());
671 EXPECT_THAT(std::string(data, asset->getLength()), StrEq("file\n"));
672 }
673
TEST_F(AssetManager2Test,OpensFileFromMultipleApkAssets)674 TEST_F(AssetManager2Test, OpensFileFromMultipleApkAssets) {
675 AssetManager2 assetmanager;
676 assetmanager.SetApkAssets({system_assets_.get(), app_assets_.get()});
677
678 std::unique_ptr<Asset> asset = assetmanager.Open("file.txt", Asset::ACCESS_BUFFER);
679 ASSERT_THAT(asset, NotNull());
680
681 const char* data = reinterpret_cast<const char*>(asset->getBuffer(false /*wordAligned*/));
682 ASSERT_THAT(data, NotNull());
683 EXPECT_THAT(std::string(data, asset->getLength()), StrEq("app override file\n"));
684 }
685
TEST_F(AssetManager2Test,OpenDir)686 TEST_F(AssetManager2Test, OpenDir) {
687 AssetManager2 assetmanager;
688 assetmanager.SetApkAssets({system_assets_.get()});
689
690 std::unique_ptr<AssetDir> asset_dir = assetmanager.OpenDir("");
691 ASSERT_THAT(asset_dir, NotNull());
692 ASSERT_THAT(asset_dir->getFileCount(), Eq(2u));
693
694 EXPECT_THAT(asset_dir->getFileName(0), Eq(String8("file.txt")));
695 EXPECT_THAT(asset_dir->getFileType(0), Eq(FileType::kFileTypeRegular));
696
697 EXPECT_THAT(asset_dir->getFileName(1), Eq(String8("subdir")));
698 EXPECT_THAT(asset_dir->getFileType(1), Eq(FileType::kFileTypeDirectory));
699
700 asset_dir = assetmanager.OpenDir("subdir");
701 ASSERT_THAT(asset_dir, NotNull());
702 ASSERT_THAT(asset_dir->getFileCount(), Eq(1u));
703
704 EXPECT_THAT(asset_dir->getFileName(0), Eq(String8("subdir_file.txt")));
705 EXPECT_THAT(asset_dir->getFileType(0), Eq(FileType::kFileTypeRegular));
706 }
707
TEST_F(AssetManager2Test,OpenDirFromManyApks)708 TEST_F(AssetManager2Test, OpenDirFromManyApks) {
709 AssetManager2 assetmanager;
710 assetmanager.SetApkAssets({system_assets_.get(), app_assets_.get()});
711
712 std::unique_ptr<AssetDir> asset_dir = assetmanager.OpenDir("");
713 ASSERT_THAT(asset_dir, NotNull());
714 ASSERT_THAT(asset_dir->getFileCount(), Eq(3u));
715
716 EXPECT_THAT(asset_dir->getFileName(0), Eq(String8("app_file.txt")));
717 EXPECT_THAT(asset_dir->getFileType(0), Eq(FileType::kFileTypeRegular));
718
719 EXPECT_THAT(asset_dir->getFileName(1), Eq(String8("file.txt")));
720 EXPECT_THAT(asset_dir->getFileType(1), Eq(FileType::kFileTypeRegular));
721
722 EXPECT_THAT(asset_dir->getFileName(2), Eq(String8("subdir")));
723 EXPECT_THAT(asset_dir->getFileType(2), Eq(FileType::kFileTypeDirectory));
724 }
725
TEST_F(AssetManager2Test,GetLastPathWithoutEnablingReturnsEmpty)726 TEST_F(AssetManager2Test, GetLastPathWithoutEnablingReturnsEmpty) {
727 ResTable_config desired_config;
728
729 AssetManager2 assetmanager;
730 assetmanager.SetConfiguration(desired_config);
731 assetmanager.SetApkAssets({basic_assets_.get()});
732 assetmanager.SetResourceResolutionLoggingEnabled(false);
733
734 auto value = assetmanager.GetResource(basic::R::string::test1);
735 ASSERT_TRUE(value.has_value());
736
737 auto result = assetmanager.GetLastResourceResolution();
738 EXPECT_EQ("", result);
739 }
740
TEST_F(AssetManager2Test,GetLastPathWithoutResolutionReturnsEmpty)741 TEST_F(AssetManager2Test, GetLastPathWithoutResolutionReturnsEmpty) {
742 ResTable_config desired_config;
743
744 AssetManager2 assetmanager;
745 assetmanager.SetConfiguration(desired_config);
746 assetmanager.SetApkAssets({basic_assets_.get()});
747
748 auto result = assetmanager.GetLastResourceResolution();
749 EXPECT_EQ("", result);
750 }
751
TEST_F(AssetManager2Test,GetLastPathWithSingleApkAssets)752 TEST_F(AssetManager2Test, GetLastPathWithSingleApkAssets) {
753 ResTable_config desired_config;
754 memset(&desired_config, 0, sizeof(desired_config));
755 desired_config.language[0] = 'd';
756 desired_config.language[1] = 'e';
757
758 AssetManager2 assetmanager;
759 assetmanager.SetResourceResolutionLoggingEnabled(true);
760 assetmanager.SetConfiguration(desired_config);
761 assetmanager.SetApkAssets({basic_assets_.get()});
762
763 auto value = assetmanager.GetResource(basic::R::string::test1);
764 ASSERT_TRUE(value.has_value());
765
766 auto result = assetmanager.GetLastResourceResolution();
767 EXPECT_EQ("Resolution for 0x7f030000 com.android.basic:string/test1\n"
768 "\tFor config - de\n"
769 "\tFound initial: basic/basic.apk", result);
770 }
771
TEST_F(AssetManager2Test,GetLastPathWithMultipleApkAssets)772 TEST_F(AssetManager2Test, GetLastPathWithMultipleApkAssets) {
773 ResTable_config desired_config;
774 memset(&desired_config, 0, sizeof(desired_config));
775 desired_config.language[0] = 'd';
776 desired_config.language[1] = 'e';
777
778 AssetManager2 assetmanager;
779 assetmanager.SetResourceResolutionLoggingEnabled(true);
780 assetmanager.SetConfiguration(desired_config);
781 assetmanager.SetApkAssets({basic_assets_.get(), basic_de_fr_assets_.get()});
782
783 auto value = assetmanager.GetResource(basic::R::string::test1);
784 ASSERT_TRUE(value.has_value());
785
786 auto result = assetmanager.GetLastResourceResolution();
787 EXPECT_EQ("Resolution for 0x7f030000 com.android.basic:string/test1\n"
788 "\tFor config - de\n"
789 "\tFound initial: basic/basic.apk\n"
790 "\tFound better: basic/basic_de_fr.apk - de", result);
791 }
792
TEST_F(AssetManager2Test,GetLastPathAfterDisablingReturnsEmpty)793 TEST_F(AssetManager2Test, GetLastPathAfterDisablingReturnsEmpty) {
794 ResTable_config desired_config;
795 memset(&desired_config, 0, sizeof(desired_config));
796
797 AssetManager2 assetmanager;
798 assetmanager.SetResourceResolutionLoggingEnabled(true);
799 assetmanager.SetConfiguration(desired_config);
800 assetmanager.SetApkAssets({basic_assets_.get()});
801
802 auto value = assetmanager.GetResource(basic::R::string::test1);
803 ASSERT_TRUE(value.has_value());
804
805 auto resultEnabled = assetmanager.GetLastResourceResolution();
806 ASSERT_NE("", resultEnabled);
807
808 assetmanager.SetResourceResolutionLoggingEnabled(false);
809
810 auto resultDisabled = assetmanager.GetLastResourceResolution();
811 EXPECT_EQ("", resultDisabled);
812 }
813
TEST_F(AssetManager2Test,GetOverlayablesToString)814 TEST_F(AssetManager2Test, GetOverlayablesToString) {
815 ResTable_config desired_config;
816 memset(&desired_config, 0, sizeof(desired_config));
817
818 AssetManager2 assetmanager;
819 assetmanager.SetResourceResolutionLoggingEnabled(true);
820 assetmanager.SetConfiguration(desired_config);
821 assetmanager.SetApkAssets({overlayable_assets_.get()});
822
823 const auto map = assetmanager.GetOverlayableMapForPackage(0x7f);
824 ASSERT_NE(nullptr, map);
825 ASSERT_EQ(3, map->size());
826 ASSERT_EQ(map->at("OverlayableResources1"), "overlay://theme");
827 ASSERT_EQ(map->at("OverlayableResources2"), "overlay://com.android.overlayable");
828 ASSERT_EQ(map->at("OverlayableResources3"), "");
829
830 std::string api;
831 ASSERT_TRUE(assetmanager.GetOverlayablesToString("com.android.overlayable", &api));
832 ASSERT_EQ(api.find("not_overlayable"), std::string::npos);
833 ASSERT_NE(api.find("resource='com.android.overlayable:string/overlayable2' overlayable='OverlayableResources1' actor='overlay://theme' policy='0x0000000a'\n"),
834 std::string::npos);
835 }
836
837 } // namespace android
838