1 /*
2 * Copyright (C) 2015 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 "flatten/TableFlattener.h"
18
19 #include "android-base/stringprintf.h"
20
21 #include "ResourceUtils.h"
22 #include "SdkConstants.h"
23 #include "test/Test.h"
24 #include "unflatten/BinaryResourceParser.h"
25 #include "util/Util.h"
26
27 using namespace android;
28
29 namespace aapt {
30
31 class TableFlattenerTest : public ::testing::Test {
32 public:
SetUp()33 void SetUp() override {
34 context_ = test::ContextBuilder()
35 .SetCompilationPackage("com.app.test")
36 .SetPackageId(0x7f)
37 .Build();
38 }
39
Flatten(IAaptContext * context,const TableFlattenerOptions & options,ResourceTable * table,std::string * out_content)40 ::testing::AssertionResult Flatten(IAaptContext* context, const TableFlattenerOptions& options,
41 ResourceTable* table, std::string* out_content) {
42 BigBuffer buffer(1024);
43 TableFlattener flattener(options, &buffer);
44 if (!flattener.Consume(context, table)) {
45 return ::testing::AssertionFailure() << "failed to flatten ResourceTable";
46 }
47 *out_content = buffer.to_string();
48 return ::testing::AssertionSuccess();
49 }
50
Flatten(IAaptContext * context,const TableFlattenerOptions & options,ResourceTable * table,ResTable * out_table)51 ::testing::AssertionResult Flatten(IAaptContext* context, const TableFlattenerOptions& options,
52 ResourceTable* table, ResTable* out_table) {
53 std::string content;
54 auto result = Flatten(context, options, table, &content);
55 if (!result) {
56 return result;
57 }
58
59 if (out_table->add(content.data(), content.size(), 1, true) != NO_ERROR) {
60 return ::testing::AssertionFailure() << "flattened ResTable is corrupt";
61 }
62 return ::testing::AssertionSuccess();
63 }
64
Flatten(IAaptContext * context,const TableFlattenerOptions & options,ResourceTable * table,ResourceTable * out_table)65 ::testing::AssertionResult Flatten(IAaptContext* context, const TableFlattenerOptions& options,
66 ResourceTable* table, ResourceTable* out_table) {
67 std::string content;
68 auto result = Flatten(context, options, table, &content);
69 if (!result) {
70 return result;
71 }
72
73 BinaryResourceParser parser(context, out_table, {}, content.data(), content.size());
74 if (!parser.Parse()) {
75 return ::testing::AssertionFailure() << "flattened ResTable is corrupt";
76 }
77 return ::testing::AssertionSuccess();
78 }
79
Exists(ResTable * table,const StringPiece & expected_name,const ResourceId & expected_id,const ConfigDescription & expected_config,const uint8_t expected_data_type,const uint32_t expected_data,const uint32_t expected_spec_flags)80 ::testing::AssertionResult Exists(ResTable* table,
81 const StringPiece& expected_name,
82 const ResourceId& expected_id,
83 const ConfigDescription& expected_config,
84 const uint8_t expected_data_type,
85 const uint32_t expected_data,
86 const uint32_t expected_spec_flags) {
87 const ResourceName expected_res_name = test::ParseNameOrDie(expected_name);
88
89 table->setParameters(&expected_config);
90
91 ResTable_config config;
92 Res_value val;
93 uint32_t spec_flags;
94 if (table->getResource(expected_id.id, &val, false, 0, &spec_flags,
95 &config) < 0) {
96 return ::testing::AssertionFailure() << "could not find resource with";
97 }
98
99 if (expected_data_type != val.dataType) {
100 return ::testing::AssertionFailure()
101 << "expected data type " << std::hex << (int)expected_data_type
102 << " but got data type " << (int)val.dataType << std::dec
103 << " instead";
104 }
105
106 if (expected_data != val.data) {
107 return ::testing::AssertionFailure()
108 << "expected data " << std::hex << expected_data
109 << " but got data " << val.data << std::dec << " instead";
110 }
111
112 if (expected_spec_flags != spec_flags) {
113 return ::testing::AssertionFailure()
114 << "expected specFlags " << std::hex << expected_spec_flags
115 << " but got specFlags " << spec_flags << std::dec << " instead";
116 }
117
118 ResTable::resource_name actual_name;
119 if (!table->getResourceName(expected_id.id, false, &actual_name)) {
120 return ::testing::AssertionFailure() << "failed to find resource name";
121 }
122
123 Maybe<ResourceName> resName = ResourceUtils::ToResourceName(actual_name);
124 if (!resName) {
125 return ::testing::AssertionFailure()
126 << "expected name '" << expected_res_name << "' but got '"
127 << StringPiece16(actual_name.package, actual_name.packageLen)
128 << ":" << StringPiece16(actual_name.type, actual_name.typeLen)
129 << "/" << StringPiece16(actual_name.name, actual_name.nameLen)
130 << "'";
131 }
132
133 if (expected_config != config) {
134 return ::testing::AssertionFailure() << "expected config '"
135 << expected_config << "' but got '"
136 << ConfigDescription(config) << "'";
137 }
138 return ::testing::AssertionSuccess();
139 }
140
141 protected:
142 std::unique_ptr<IAaptContext> context_;
143 };
144
TEST_F(TableFlattenerTest,FlattenFullyLinkedTable)145 TEST_F(TableFlattenerTest, FlattenFullyLinkedTable) {
146 std::unique_ptr<ResourceTable> table =
147 test::ResourceTableBuilder()
148 .SetPackageId("com.app.test", 0x7f)
149 .AddSimple("com.app.test:id/one", ResourceId(0x7f020000))
150 .AddSimple("com.app.test:id/two", ResourceId(0x7f020001))
151 .AddValue("com.app.test:id/three", ResourceId(0x7f020002),
152 test::BuildReference("com.app.test:id/one",
153 ResourceId(0x7f020000)))
154 .AddValue("com.app.test:integer/one", ResourceId(0x7f030000),
155 util::make_unique<BinaryPrimitive>(
156 uint8_t(Res_value::TYPE_INT_DEC), 1u))
157 .AddValue("com.app.test:integer/one", test::ParseConfigOrDie("v1"),
158 ResourceId(0x7f030000),
159 util::make_unique<BinaryPrimitive>(
160 uint8_t(Res_value::TYPE_INT_DEC), 2u))
161 .AddString("com.app.test:string/test", ResourceId(0x7f040000), "foo")
162 .AddString("com.app.test:layout/bar", ResourceId(0x7f050000),
163 "res/layout/bar.xml")
164 .Build();
165
166 ResTable res_table;
167 ASSERT_TRUE(Flatten(context_.get(), {}, table.get(), &res_table));
168
169 EXPECT_TRUE(Exists(&res_table, "com.app.test:id/one", ResourceId(0x7f020000),
170 {}, Res_value::TYPE_INT_BOOLEAN, 0u, 0u));
171
172 EXPECT_TRUE(Exists(&res_table, "com.app.test:id/two", ResourceId(0x7f020001),
173 {}, Res_value::TYPE_INT_BOOLEAN, 0u, 0u));
174
175 EXPECT_TRUE(Exists(&res_table, "com.app.test:id/three",
176 ResourceId(0x7f020002), {}, Res_value::TYPE_REFERENCE,
177 0x7f020000u, 0u));
178
179 EXPECT_TRUE(Exists(&res_table, "com.app.test:integer/one",
180 ResourceId(0x7f030000), {}, Res_value::TYPE_INT_DEC, 1u,
181 ResTable_config::CONFIG_VERSION));
182
183 EXPECT_TRUE(Exists(&res_table, "com.app.test:integer/one",
184 ResourceId(0x7f030000), test::ParseConfigOrDie("v1"),
185 Res_value::TYPE_INT_DEC, 2u,
186 ResTable_config::CONFIG_VERSION));
187
188 std::u16string foo_str = u"foo";
189 ssize_t idx = res_table.getTableStringBlock(0)->indexOfString(foo_str.data(),
190 foo_str.size());
191 ASSERT_GE(idx, 0);
192 EXPECT_TRUE(Exists(&res_table, "com.app.test:string/test",
193 ResourceId(0x7f040000), {}, Res_value::TYPE_STRING,
194 (uint32_t)idx, 0u));
195
196 std::u16string bar_path = u"res/layout/bar.xml";
197 idx = res_table.getTableStringBlock(0)->indexOfString(bar_path.data(),
198 bar_path.size());
199 ASSERT_GE(idx, 0);
200 EXPECT_TRUE(Exists(&res_table, "com.app.test:layout/bar",
201 ResourceId(0x7f050000), {}, Res_value::TYPE_STRING,
202 (uint32_t)idx, 0u));
203 }
204
TEST_F(TableFlattenerTest,FlattenEntriesWithGapsInIds)205 TEST_F(TableFlattenerTest, FlattenEntriesWithGapsInIds) {
206 std::unique_ptr<ResourceTable> table =
207 test::ResourceTableBuilder()
208 .SetPackageId("com.app.test", 0x7f)
209 .AddSimple("com.app.test:id/one", ResourceId(0x7f020001))
210 .AddSimple("com.app.test:id/three", ResourceId(0x7f020003))
211 .Build();
212
213 ResTable res_table;
214 ASSERT_TRUE(Flatten(context_.get(), {}, table.get(), &res_table));
215
216 EXPECT_TRUE(Exists(&res_table, "com.app.test:id/one", ResourceId(0x7f020001),
217 {}, Res_value::TYPE_INT_BOOLEAN, 0u, 0u));
218 EXPECT_TRUE(Exists(&res_table, "com.app.test:id/three",
219 ResourceId(0x7f020003), {}, Res_value::TYPE_INT_BOOLEAN,
220 0u, 0u));
221 }
222
TEST_F(TableFlattenerTest,FlattenMinMaxAttributes)223 TEST_F(TableFlattenerTest, FlattenMinMaxAttributes) {
224 Attribute attr(false);
225 attr.type_mask = android::ResTable_map::TYPE_INTEGER;
226 attr.min_int = 10;
227 attr.max_int = 23;
228 std::unique_ptr<ResourceTable> table =
229 test::ResourceTableBuilder()
230 .SetPackageId("android", 0x01)
231 .AddValue("android:attr/foo", ResourceId(0x01010000),
232 util::make_unique<Attribute>(attr))
233 .Build();
234
235 ResourceTable result;
236 ASSERT_TRUE(Flatten(context_.get(), {}, table.get(), &result));
237
238 Attribute* actualAttr =
239 test::GetValue<Attribute>(&result, "android:attr/foo");
240 ASSERT_NE(nullptr, actualAttr);
241 EXPECT_EQ(attr.IsWeak(), actualAttr->IsWeak());
242 EXPECT_EQ(attr.type_mask, actualAttr->type_mask);
243 EXPECT_EQ(attr.min_int, actualAttr->min_int);
244 EXPECT_EQ(attr.max_int, actualAttr->max_int);
245 }
246
BuildTableWithSparseEntries(IAaptContext * context,const ConfigDescription & sparse_config,float load)247 static std::unique_ptr<ResourceTable> BuildTableWithSparseEntries(
248 IAaptContext* context, const ConfigDescription& sparse_config, float load) {
249 std::unique_ptr<ResourceTable> table =
250 test::ResourceTableBuilder()
251 .SetPackageId(context->GetCompilationPackage(), context->GetPackageId())
252 .Build();
253
254 // Add regular entries.
255 int stride = static_cast<int>(1.0f / load);
256 for (int i = 0; i < 100; i++) {
257 const ResourceName name = test::ParseNameOrDie(
258 base::StringPrintf("%s:string/foo_%d", context->GetCompilationPackage().data(), i));
259 const ResourceId resid(context->GetPackageId(), 0x02, static_cast<uint16_t>(i));
260 const auto value =
261 util::make_unique<BinaryPrimitive>(Res_value::TYPE_INT_DEC, static_cast<uint32_t>(i));
262 CHECK(table->AddResource(name, resid, ConfigDescription::DefaultConfig(), "",
263 std::unique_ptr<Value>(value->Clone(nullptr)),
264 context->GetDiagnostics()));
265
266 // Every few entries, write out a sparse_config value. This will give us the desired load.
267 if (i % stride == 0) {
268 CHECK(table->AddResource(name, resid, sparse_config, "",
269 std::unique_ptr<Value>(value->Clone(nullptr)),
270 context->GetDiagnostics()));
271 }
272 }
273 return table;
274 }
275
TEST_F(TableFlattenerTest,FlattenSparseEntryWithMinSdkO)276 TEST_F(TableFlattenerTest, FlattenSparseEntryWithMinSdkO) {
277 std::unique_ptr<IAaptContext> context = test::ContextBuilder()
278 .SetCompilationPackage("android")
279 .SetPackageId(0x01)
280 .SetMinSdkVersion(SDK_O)
281 .Build();
282
283 const ConfigDescription sparse_config = test::ParseConfigOrDie("en-rGB");
284 auto table_in = BuildTableWithSparseEntries(context.get(), sparse_config, 0.25f);
285
286 TableFlattenerOptions options;
287 options.use_sparse_entries = true;
288
289 std::string no_sparse_contents;
290 ASSERT_TRUE(Flatten(context.get(), {}, table_in.get(), &no_sparse_contents));
291
292 std::string sparse_contents;
293 ASSERT_TRUE(Flatten(context.get(), options, table_in.get(), &sparse_contents));
294
295 EXPECT_GT(no_sparse_contents.size(), sparse_contents.size());
296
297 // Attempt to parse the sparse contents.
298
299 ResourceTable sparse_table;
300 BinaryResourceParser parser(context.get(), &sparse_table, Source("test.arsc"),
301 sparse_contents.data(), sparse_contents.size());
302 ASSERT_TRUE(parser.Parse());
303
304 auto value = test::GetValueForConfig<BinaryPrimitive>(&sparse_table, "android:string/foo_0",
305 sparse_config);
306 ASSERT_NE(nullptr, value);
307 EXPECT_EQ(0u, value->value.data);
308
309 ASSERT_EQ(nullptr, test::GetValueForConfig<BinaryPrimitive>(&sparse_table, "android:string/foo_1",
310 sparse_config));
311
312 value = test::GetValueForConfig<BinaryPrimitive>(&sparse_table, "android:string/foo_4",
313 sparse_config);
314 ASSERT_NE(nullptr, value);
315 EXPECT_EQ(4u, value->value.data);
316 }
317
TEST_F(TableFlattenerTest,FlattenSparseEntryWithConfigSdkVersionO)318 TEST_F(TableFlattenerTest, FlattenSparseEntryWithConfigSdkVersionO) {
319 std::unique_ptr<IAaptContext> context = test::ContextBuilder()
320 .SetCompilationPackage("android")
321 .SetPackageId(0x01)
322 .SetMinSdkVersion(SDK_LOLLIPOP)
323 .Build();
324
325 const ConfigDescription sparse_config = test::ParseConfigOrDie("en-rGB-v26");
326 auto table_in = BuildTableWithSparseEntries(context.get(), sparse_config, 0.25f);
327
328 TableFlattenerOptions options;
329 options.use_sparse_entries = true;
330
331 std::string no_sparse_contents;
332 ASSERT_TRUE(Flatten(context.get(), {}, table_in.get(), &no_sparse_contents));
333
334 std::string sparse_contents;
335 ASSERT_TRUE(Flatten(context.get(), options, table_in.get(), &sparse_contents));
336
337 EXPECT_GT(no_sparse_contents.size(), sparse_contents.size());
338 }
339
TEST_F(TableFlattenerTest,DoNotUseSparseEntryForDenseConfig)340 TEST_F(TableFlattenerTest, DoNotUseSparseEntryForDenseConfig) {
341 std::unique_ptr<IAaptContext> context = test::ContextBuilder()
342 .SetCompilationPackage("android")
343 .SetPackageId(0x01)
344 .SetMinSdkVersion(SDK_O)
345 .Build();
346
347 const ConfigDescription sparse_config = test::ParseConfigOrDie("en-rGB");
348 auto table_in = BuildTableWithSparseEntries(context.get(), sparse_config, 0.80f);
349
350 TableFlattenerOptions options;
351 options.use_sparse_entries = true;
352
353 std::string no_sparse_contents;
354 ASSERT_TRUE(Flatten(context.get(), {}, table_in.get(), &no_sparse_contents));
355
356 std::string sparse_contents;
357 ASSERT_TRUE(Flatten(context.get(), options, table_in.get(), &sparse_contents));
358
359 EXPECT_EQ(no_sparse_contents.size(), sparse_contents.size());
360 }
361
TEST_F(TableFlattenerTest,FlattenSharedLibrary)362 TEST_F(TableFlattenerTest, FlattenSharedLibrary) {
363 std::unique_ptr<IAaptContext> context =
364 test::ContextBuilder().SetCompilationPackage("lib").SetPackageId(0x00).Build();
365 std::unique_ptr<ResourceTable> table =
366 test::ResourceTableBuilder()
367 .SetPackageId("lib", 0x00)
368 .AddValue("lib:id/foo", ResourceId(0x00010000), util::make_unique<Id>())
369 .Build();
370 ResourceTable result;
371 ASSERT_TRUE(Flatten(context.get(), {}, table.get(), &result));
372
373 Maybe<ResourceTable::SearchResult> search_result =
374 result.FindResource(test::ParseNameOrDie("lib:id/foo"));
375 AAPT_ASSERT_TRUE(search_result);
376 EXPECT_EQ(0x00u, search_result.value().package->id.value());
377
378 auto iter = result.included_packages_.find(0x00);
379 ASSERT_NE(result.included_packages_.end(), iter);
380 EXPECT_EQ("lib", iter->second);
381 }
382
TEST_F(TableFlattenerTest,FlattenTableReferencingSharedLibraries)383 TEST_F(TableFlattenerTest, FlattenTableReferencingSharedLibraries) {
384 std::unique_ptr<IAaptContext> context =
385 test::ContextBuilder().SetCompilationPackage("app").SetPackageId(0x7f).Build();
386 std::unique_ptr<ResourceTable> table =
387 test::ResourceTableBuilder()
388 .SetPackageId("app", 0x7f)
389 .AddValue("app:id/foo", ResourceId(0x7f010000),
390 test::BuildReference("lib_one:id/foo", ResourceId(0x02010000)))
391 .AddValue("app:id/bar", ResourceId(0x7f010001),
392 test::BuildReference("lib_two:id/bar", ResourceId(0x03010000)))
393 .Build();
394 table->included_packages_[0x02] = "lib_one";
395 table->included_packages_[0x03] = "lib_two";
396
397 ResTable result;
398 ASSERT_TRUE(Flatten(context.get(), {}, table.get(), &result));
399
400 const DynamicRefTable* dynamic_ref_table = result.getDynamicRefTableForCookie(1);
401 ASSERT_NE(nullptr, dynamic_ref_table);
402
403 const KeyedVector<String16, uint8_t>& entries = dynamic_ref_table->entries();
404
405 ssize_t idx = entries.indexOfKey(android::String16("lib_one"));
406 ASSERT_GE(idx, 0);
407 EXPECT_EQ(0x02u, entries.valueAt(idx));
408
409 idx = entries.indexOfKey(android::String16("lib_two"));
410 ASSERT_GE(idx, 0);
411 EXPECT_EQ(0x03u, entries.valueAt(idx));
412 }
413
TEST_F(TableFlattenerTest,PackageWithNonStandardIdHasDynamicRefTable)414 TEST_F(TableFlattenerTest, PackageWithNonStandardIdHasDynamicRefTable) {
415 std::unique_ptr<IAaptContext> context =
416 test::ContextBuilder().SetCompilationPackage("app").SetPackageId(0x80).Build();
417 std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
418 .SetPackageId("app", 0x80)
419 .AddSimple("app:id/foo", ResourceId(0x80010000))
420 .Build();
421
422 ResTable result;
423 ASSERT_TRUE(Flatten(context.get(), {}, table.get(), &result));
424
425 const DynamicRefTable* dynamic_ref_table = result.getDynamicRefTableForCookie(1);
426 ASSERT_NE(nullptr, dynamic_ref_table);
427
428 const KeyedVector<String16, uint8_t>& entries = dynamic_ref_table->entries();
429 ssize_t idx = entries.indexOfKey(android::String16("app"));
430 ASSERT_GE(idx, 0);
431 EXPECT_EQ(0x80u, entries.valueAt(idx));
432 }
433
TEST_F(TableFlattenerTest,LongPackageNameIsTruncated)434 TEST_F(TableFlattenerTest, LongPackageNameIsTruncated) {
435 std::string kPackageName(256, 'F');
436
437 std::unique_ptr<IAaptContext> context =
438 test::ContextBuilder().SetCompilationPackage(kPackageName).SetPackageId(0x7f).Build();
439 std::unique_ptr<ResourceTable> table =
440 test::ResourceTableBuilder()
441 .SetPackageId(kPackageName, 0x7f)
442 .AddSimple(kPackageName + ":id/foo", ResourceId(0x7f010000))
443 .Build();
444
445 ResTable result;
446 ASSERT_TRUE(Flatten(context.get(), {}, table.get(), &result));
447
448 ASSERT_EQ(1u, result.getBasePackageCount());
449 EXPECT_EQ(127u, result.getBasePackageName(0).size());
450 }
451
TEST_F(TableFlattenerTest,LongSharedLibraryPackageNameIsIllegal)452 TEST_F(TableFlattenerTest, LongSharedLibraryPackageNameIsIllegal) {
453 std::string kPackageName(256, 'F');
454
455 std::unique_ptr<IAaptContext> context = test::ContextBuilder()
456 .SetCompilationPackage(kPackageName)
457 .SetPackageId(0x7f)
458 .SetPackageType(PackageType::kSharedLib)
459 .Build();
460 std::unique_ptr<ResourceTable> table =
461 test::ResourceTableBuilder()
462 .SetPackageId(kPackageName, 0x7f)
463 .AddSimple(kPackageName + ":id/foo", ResourceId(0x7f010000))
464 .Build();
465
466 ResTable result;
467 ASSERT_FALSE(Flatten(context.get(), {}, table.get(), &result));
468 }
469
470 } // namespace aapt
471