Home | History | Annotate | Download | only in flatten 
      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:
     33   void SetUp() override {
     34     context_ = test::ContextBuilder()
     35                    .SetCompilationPackage("com.app.test")
     36                    .SetPackageId(0x7f)
     37                    .Build();
     38   }
     39 
     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 
     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 
     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 
     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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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