diff options
Diffstat (limited to 'tools')
42 files changed, 1587 insertions, 1156 deletions
diff --git a/tools/aapt2/Android.bp b/tools/aapt2/Android.bp index 1dc47f88ab92..d39a8a8237b7 100644 --- a/tools/aapt2/Android.bp +++ b/tools/aapt2/Android.bp @@ -85,6 +85,7 @@ cc_library_host_static { "compile/Pseudolocalizer.cpp", "compile/XmlIdCollector.cpp", "configuration/ConfigurationParser.cpp", + "filter/AbiFilter.cpp", "filter/ConfigFilter.cpp", "flatten/Archive.cpp", "flatten/TableFlattener.cpp", diff --git a/tools/aapt2/ConfigDescription.cpp b/tools/aapt2/ConfigDescription.cpp index 46098cbc3aa4..7ff0c7227c9c 100644 --- a/tools/aapt2/ConfigDescription.cpp +++ b/tools/aapt2/ConfigDescription.cpp @@ -877,7 +877,16 @@ ConfigDescription ConfigDescription::CopyWithoutSdkVersion() const { } bool ConfigDescription::Dominates(const ConfigDescription& o) const { - if (*this == DefaultConfig() || *this == o) { + if (*this == o) { + return true; + } + + // Locale de-duping is not-trivial, disable for now (b/62409213). + if (diff(o) & CONFIG_LOCALE) { + return false; + } + + if (*this == DefaultConfig()) { return true; } return MatchWithDensity(o) && !o.MatchWithDensity(*this) && diff --git a/tools/aapt2/DominatorTree_test.cpp b/tools/aapt2/DominatorTree_test.cpp index e89c6beb0c57..efc523fcf59b 100644 --- a/tools/aapt2/DominatorTree_test.cpp +++ b/tools/aapt2/DominatorTree_test.cpp @@ -69,14 +69,12 @@ class PrettyPrinter : public DominatorTree::Visitor { TEST(DominatorTreeTest, DefaultDominatesEverything) { const ConfigDescription default_config = {}; const ConfigDescription land_config = test::ParseConfigOrDie("land"); - const ConfigDescription sw600dp_land_config = - test::ParseConfigOrDie("sw600dp-land-v13"); + const ConfigDescription sw600dp_land_config = test::ParseConfigOrDie("sw600dp-land-v13"); std::vector<std::unique_ptr<ResourceConfigValue>> configs; configs.push_back(util::make_unique<ResourceConfigValue>(default_config, "")); configs.push_back(util::make_unique<ResourceConfigValue>(land_config, "")); - configs.push_back( - util::make_unique<ResourceConfigValue>(sw600dp_land_config, "")); + configs.push_back(util::make_unique<ResourceConfigValue>(sw600dp_land_config, "")); DominatorTree tree(configs); PrettyPrinter printer; @@ -91,16 +89,13 @@ TEST(DominatorTreeTest, DefaultDominatesEverything) { TEST(DominatorTreeTest, ProductsAreDominatedSeparately) { const ConfigDescription default_config = {}; const ConfigDescription land_config = test::ParseConfigOrDie("land"); - const ConfigDescription sw600dp_land_config = - test::ParseConfigOrDie("sw600dp-land-v13"); + const ConfigDescription sw600dp_land_config = test::ParseConfigOrDie("sw600dp-land-v13"); std::vector<std::unique_ptr<ResourceConfigValue>> configs; configs.push_back(util::make_unique<ResourceConfigValue>(default_config, "")); configs.push_back(util::make_unique<ResourceConfigValue>(land_config, "")); - configs.push_back( - util::make_unique<ResourceConfigValue>(default_config, "phablet")); - configs.push_back( - util::make_unique<ResourceConfigValue>(sw600dp_land_config, "phablet")); + configs.push_back(util::make_unique<ResourceConfigValue>(default_config, "phablet")); + configs.push_back(util::make_unique<ResourceConfigValue>(sw600dp_land_config, "phablet")); DominatorTree tree(configs); PrettyPrinter printer; @@ -118,16 +113,11 @@ TEST(DominatorTreeTest, MoreSpecificConfigurationsAreDominated) { const ConfigDescription en_config = test::ParseConfigOrDie("en"); const ConfigDescription en_v21_config = test::ParseConfigOrDie("en-v21"); const ConfigDescription ldrtl_config = test::ParseConfigOrDie("ldrtl-v4"); - const ConfigDescription ldrtl_xhdpi_config = - test::ParseConfigOrDie("ldrtl-xhdpi-v4"); - const ConfigDescription sw300dp_config = - test::ParseConfigOrDie("sw300dp-v13"); - const ConfigDescription sw540dp_config = - test::ParseConfigOrDie("sw540dp-v14"); - const ConfigDescription sw600dp_config = - test::ParseConfigOrDie("sw600dp-v14"); - const ConfigDescription sw720dp_config = - test::ParseConfigOrDie("sw720dp-v13"); + const ConfigDescription ldrtl_xhdpi_config = test::ParseConfigOrDie("ldrtl-xhdpi-v4"); + const ConfigDescription sw300dp_config = test::ParseConfigOrDie("sw300dp-v13"); + const ConfigDescription sw540dp_config = test::ParseConfigOrDie("sw540dp-v14"); + const ConfigDescription sw600dp_config = test::ParseConfigOrDie("sw600dp-v14"); + const ConfigDescription sw720dp_config = test::ParseConfigOrDie("sw720dp-v13"); const ConfigDescription v20_config = test::ParseConfigOrDie("v20"); std::vector<std::unique_ptr<ResourceConfigValue>> configs; @@ -135,8 +125,7 @@ TEST(DominatorTreeTest, MoreSpecificConfigurationsAreDominated) { configs.push_back(util::make_unique<ResourceConfigValue>(en_config, "")); configs.push_back(util::make_unique<ResourceConfigValue>(en_v21_config, "")); configs.push_back(util::make_unique<ResourceConfigValue>(ldrtl_config, "")); - configs.push_back( - util::make_unique<ResourceConfigValue>(ldrtl_xhdpi_config, "")); + configs.push_back(util::make_unique<ResourceConfigValue>(ldrtl_xhdpi_config, "")); configs.push_back(util::make_unique<ResourceConfigValue>(sw300dp_config, "")); configs.push_back(util::make_unique<ResourceConfigValue>(sw540dp_config, "")); configs.push_back(util::make_unique<ResourceConfigValue>(sw600dp_config, "")); @@ -148,15 +137,37 @@ TEST(DominatorTreeTest, MoreSpecificConfigurationsAreDominated) { std::string expected = "<default>\n" - " en\n" - " en-v21\n" " ldrtl-v4\n" " ldrtl-xhdpi-v4\n" " sw300dp-v13\n" " sw540dp-v14\n" " sw600dp-v14\n" " sw720dp-v13\n" - " v20\n"; + " v20\n" + "en\n" + " en-v21\n"; + EXPECT_EQ(expected, printer.ToString(&tree)); +} + +TEST(DominatorTreeTest, LocalesAreNeverDominated) { + const ConfigDescription fr_config = test::ParseConfigOrDie("fr"); + const ConfigDescription fr_rCA_config = test::ParseConfigOrDie("fr-rCA"); + const ConfigDescription fr_rFR_config = test::ParseConfigOrDie("fr-rFR"); + + std::vector<std::unique_ptr<ResourceConfigValue>> configs; + configs.push_back(util::make_unique<ResourceConfigValue>(ConfigDescription::DefaultConfig(), "")); + configs.push_back(util::make_unique<ResourceConfigValue>(fr_config, "")); + configs.push_back(util::make_unique<ResourceConfigValue>(fr_rCA_config, "")); + configs.push_back(util::make_unique<ResourceConfigValue>(fr_rFR_config, "")); + + DominatorTree tree(configs); + PrettyPrinter printer; + + std::string expected = + "<default>\n" + "fr\n" + "fr-rCA\n" + "fr-rFR\n"; EXPECT_EQ(expected, printer.ToString(&tree)); } diff --git a/tools/aapt2/LoadedApk.cpp b/tools/aapt2/LoadedApk.cpp index 8a8f8be205e7..7e5efa15f61b 100644 --- a/tools/aapt2/LoadedApk.cpp +++ b/tools/aapt2/LoadedApk.cpp @@ -57,6 +57,12 @@ std::unique_ptr<LoadedApk> LoadedApk::LoadApkFromPath(IAaptContext* context, bool LoadedApk::WriteToArchive(IAaptContext* context, const TableFlattenerOptions& options, IArchiveWriter* writer) { + FilterChain empty; + return WriteToArchive(context, options, &empty, writer); +} + +bool LoadedApk::WriteToArchive(IAaptContext* context, const TableFlattenerOptions& options, + FilterChain* filters, IArchiveWriter* writer) { std::set<std::string> referenced_resources; // List the files being referenced in the resource table. for (auto& pkg : table_->packages) { @@ -89,6 +95,13 @@ bool LoadedApk::WriteToArchive(IAaptContext* context, const TableFlattenerOption continue; } + if (!filters->Keep(path)) { + if (context->IsVerbose()) { + context->GetDiagnostics()->Note(DiagMessage() << "Filtered '" << path << "' from APK."); + } + continue; + } + // The resource table needs to be re-serialized since it might have changed. if (path == "resources.arsc") { BigBuffer buffer(4096); diff --git a/tools/aapt2/LoadedApk.h b/tools/aapt2/LoadedApk.h index 59eb8161a868..8aa9674aa2ed 100644 --- a/tools/aapt2/LoadedApk.h +++ b/tools/aapt2/LoadedApk.h @@ -20,6 +20,7 @@ #include "androidfw/StringPiece.h" #include "ResourceTable.h" +#include "filter/Filter.h" #include "flatten/Archive.h" #include "flatten/TableFlattener.h" #include "io/ZipArchive.h" @@ -49,6 +50,14 @@ class LoadedApk { bool WriteToArchive(IAaptContext* context, const TableFlattenerOptions& options, IArchiveWriter* writer); + /** + * Writes the APK on disk at the given path, while also removing the resource + * files that are not referenced in the resource table. The provided filter + * chain is applied to each entry in the APK file. + */ + bool WriteToArchive(IAaptContext* context, const TableFlattenerOptions& options, + FilterChain* filters, IArchiveWriter* writer); + static std::unique_ptr<LoadedApk> LoadApkFromPath(IAaptContext* context, const android::StringPiece& path); diff --git a/tools/aapt2/Main.cpp b/tools/aapt2/Main.cpp index 1d2e3a4f2df0..5978cdd154b9 100644 --- a/tools/aapt2/Main.cpp +++ b/tools/aapt2/Main.cpp @@ -27,7 +27,7 @@ namespace aapt { static const char* sMajorVersion = "2"; // Update minor version whenever a feature or flag is added. -static const char* sMinorVersion = "16"; +static const char* sMinorVersion = "17"; int PrintVersion() { std::cerr << "Android Asset Packaging Tool (aapt) " << sMajorVersion << "." diff --git a/tools/aapt2/ResourceParser_test.cpp b/tools/aapt2/ResourceParser_test.cpp index c6382b177f42..e18914410871 100644 --- a/tools/aapt2/ResourceParser_test.cpp +++ b/tools/aapt2/ResourceParser_test.cpp @@ -25,11 +25,17 @@ #include "test/Test.h" #include "xml/XmlPullParser.h" +using ::aapt::test::StrValueEq; using ::aapt::test::ValueEq; +using ::android::ResTable_map; +using ::android::Res_value; using ::android::StringPiece; using ::testing::Eq; +using ::testing::IsEmpty; +using ::testing::IsNull; using ::testing::NotNull; using ::testing::Pointee; +using ::testing::SizeIs; namespace aapt { @@ -74,31 +80,26 @@ class ResourceParserTest : public ::testing::Test { }; TEST_F(ResourceParserTest, ParseQuotedString) { - std::string input = "<string name=\"foo\"> \" hey there \" </string>"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<string name="foo"> " hey there " </string>)")); String* str = test::GetValue<String>(&table_, "string/foo"); - ASSERT_NE(nullptr, str); - EXPECT_EQ(std::string(" hey there "), *str->value); - EXPECT_TRUE(str->untranslatable_sections.empty()); + ASSERT_THAT(str, NotNull()); + EXPECT_THAT(*str, StrValueEq(" hey there ")); + EXPECT_THAT(str->untranslatable_sections, IsEmpty()); } TEST_F(ResourceParserTest, ParseEscapedString) { - std::string input = "<string name=\"foo\">\\?123</string>"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<string name="foo">\?123</string>)")); String* str = test::GetValue<String>(&table_, "string/foo"); - ASSERT_NE(nullptr, str); - EXPECT_EQ(std::string("?123"), *str->value); - EXPECT_TRUE(str->untranslatable_sections.empty()); + ASSERT_THAT(str, NotNull()); + EXPECT_THAT(*str, StrValueEq("?123")); + EXPECT_THAT(str->untranslatable_sections, IsEmpty()); } TEST_F(ResourceParserTest, ParseFormattedString) { - std::string input = "<string name=\"foo\">%d %s</string>"; - ASSERT_FALSE(TestParse(input)); - - input = "<string name=\"foo\">%1$d %2$s</string>"; - ASSERT_TRUE(TestParse(input)); + ASSERT_FALSE(TestParse(R"(<string name="foo">%d %s</string>)")); + ASSERT_TRUE(TestParse(R"(<string name="foo">%1$d %2$s</string>)")); } TEST_F(ResourceParserTest, ParseStyledString) { @@ -109,98 +110,93 @@ TEST_F(ResourceParserTest, ParseStyledString) { ASSERT_TRUE(TestParse(input)); StyledString* str = test::GetValue<StyledString>(&table_, "string/foo"); - ASSERT_NE(nullptr, str); + ASSERT_THAT(str, NotNull()); - const std::string expected_str = "This is my aunt\u2019s fickle string"; - EXPECT_EQ(expected_str, *str->value->str); - EXPECT_EQ(2u, str->value->spans.size()); - EXPECT_TRUE(str->untranslatable_sections.empty()); + EXPECT_THAT(*str->value->str, Eq("This is my aunt\u2019s fickle string")); + EXPECT_THAT(str->value->spans, SizeIs(2)); + EXPECT_THAT(str->untranslatable_sections, IsEmpty()); - EXPECT_EQ(std::string("b"), *str->value->spans[0].name); - EXPECT_EQ(17u, str->value->spans[0].first_char); - EXPECT_EQ(30u, str->value->spans[0].last_char); + EXPECT_THAT(*str->value->spans[0].name, Eq("b")); + EXPECT_THAT(str->value->spans[0].first_char, Eq(17u)); + EXPECT_THAT(str->value->spans[0].last_char, Eq(30u)); - EXPECT_EQ(std::string("small"), *str->value->spans[1].name); - EXPECT_EQ(24u, str->value->spans[1].first_char); - EXPECT_EQ(30u, str->value->spans[1].last_char); + EXPECT_THAT(*str->value->spans[1].name, Eq("small")); + EXPECT_THAT(str->value->spans[1].first_char, Eq(24u)); + EXPECT_THAT(str->value->spans[1].last_char, Eq(30u)); } TEST_F(ResourceParserTest, ParseStringWithWhitespace) { - std::string input = "<string name=\"foo\"> This is what I think </string>"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<string name="foo"> This is what I think </string>)")); String* str = test::GetValue<String>(&table_, "string/foo"); - ASSERT_NE(nullptr, str); - EXPECT_EQ(std::string("This is what I think"), *str->value); - EXPECT_TRUE(str->untranslatable_sections.empty()); + ASSERT_THAT(str, NotNull()); + EXPECT_THAT(*str->value, Eq("This is what I think")); + EXPECT_THAT(str->untranslatable_sections, IsEmpty()); - input = "<string name=\"foo2\">\" This is what I think \"</string>"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<string name="foo2">" This is what I think "</string>)")); str = test::GetValue<String>(&table_, "string/foo2"); - ASSERT_NE(nullptr, str); - EXPECT_EQ(std::string(" This is what I think "), *str->value); + ASSERT_THAT(str, NotNull()); + EXPECT_THAT(*str, StrValueEq(" This is what I think ")); } TEST_F(ResourceParserTest, IgnoreXliffTagsOtherThanG) { - std::string input = R"EOF( + std::string input = R"( <string name="foo" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"> - There are <xliff:source>no</xliff:source> apples</string>)EOF"; + There are <xliff:source>no</xliff:source> apples</string>)"; ASSERT_TRUE(TestParse(input)); String* str = test::GetValue<String>(&table_, "string/foo"); - ASSERT_NE(nullptr, str); - EXPECT_EQ(StringPiece("There are no apples"), StringPiece(*str->value)); - EXPECT_TRUE(str->untranslatable_sections.empty()); + ASSERT_THAT(str, NotNull()); + EXPECT_THAT(*str, StrValueEq("There are no apples")); + EXPECT_THAT(str->untranslatable_sections, IsEmpty()); } TEST_F(ResourceParserTest, NestedXliffGTagsAreIllegal) { - std::string input = R"EOF( + std::string input = R"( <string name="foo" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"> - Do not <xliff:g>translate <xliff:g>this</xliff:g></xliff:g></string>)EOF"; + Do not <xliff:g>translate <xliff:g>this</xliff:g></xliff:g></string>)"; EXPECT_FALSE(TestParse(input)); } TEST_F(ResourceParserTest, RecordUntranslateableXliffSectionsInString) { - std::string input = R"EOF( + std::string input = R"( <string name="foo" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"> - There are <xliff:g id="count">%1$d</xliff:g> apples</string>)EOF"; + There are <xliff:g id="count">%1$d</xliff:g> apples</string>)"; ASSERT_TRUE(TestParse(input)); String* str = test::GetValue<String>(&table_, "string/foo"); - ASSERT_NE(nullptr, str); - EXPECT_EQ(StringPiece("There are %1$d apples"), StringPiece(*str->value)); - - ASSERT_EQ(1u, str->untranslatable_sections.size()); + ASSERT_THAT(str, NotNull()); + EXPECT_THAT(*str, StrValueEq("There are %1$d apples")); + ASSERT_THAT(str->untranslatable_sections, SizeIs(1)); // We expect indices and lengths that span to include the whitespace // before %1$d. This is due to how the StringBuilder withholds whitespace unless // needed (to deal with line breaks, etc.). - EXPECT_EQ(9u, str->untranslatable_sections[0].start); - EXPECT_EQ(14u, str->untranslatable_sections[0].end); + EXPECT_THAT(str->untranslatable_sections[0].start, Eq(9u)); + EXPECT_THAT(str->untranslatable_sections[0].end, Eq(14u)); } TEST_F(ResourceParserTest, RecordUntranslateableXliffSectionsInStyledString) { - std::string input = R"EOF( + std::string input = R"( <string name="foo" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"> - There are <b><xliff:g id="count">%1$d</xliff:g></b> apples</string>)EOF"; + There are <b><xliff:g id="count">%1$d</xliff:g></b> apples</string>)"; ASSERT_TRUE(TestParse(input)); StyledString* str = test::GetValue<StyledString>(&table_, "string/foo"); - ASSERT_NE(nullptr, str); - EXPECT_EQ(StringPiece("There are %1$d apples"), StringPiece(*str->value->str)); - - ASSERT_EQ(1u, str->untranslatable_sections.size()); + ASSERT_THAT(str, NotNull()); + EXPECT_THAT(*str->value->str, Eq("There are %1$d apples")); + ASSERT_THAT(str->untranslatable_sections, SizeIs(1)); // We expect indices and lengths that span to include the whitespace // before %1$d. This is due to how the StringBuilder withholds whitespace unless // needed (to deal with line breaks, etc.). - EXPECT_EQ(9u, str->untranslatable_sections[0].start); - EXPECT_EQ(14u, str->untranslatable_sections[0].end); + EXPECT_THAT(str->untranslatable_sections[0].start, Eq(9u)); + EXPECT_THAT(str->untranslatable_sections[0].end, Eq(14u)); } TEST_F(ResourceParserTest, ParseNull) { - std::string input = "<integer name=\"foo\">@null</integer>"; + std::string input = R"(<integer name="foo">@null</integer>)"; ASSERT_TRUE(TestParse(input)); // The Android runtime treats a value of android::Res_value::TYPE_NULL as @@ -211,38 +207,36 @@ TEST_F(ResourceParserTest, ParseNull) { ASSERT_THAT(null_ref, NotNull()); EXPECT_FALSE(null_ref->name); EXPECT_FALSE(null_ref->id); - EXPECT_EQ(Reference::Type::kResource, null_ref->reference_type); + EXPECT_THAT(null_ref->reference_type, Eq(Reference::Type::kResource)); } TEST_F(ResourceParserTest, ParseEmpty) { - std::string input = "<integer name=\"foo\">@empty</integer>"; + std::string input = R"(<integer name="foo">@empty</integer>)"; ASSERT_TRUE(TestParse(input)); BinaryPrimitive* integer = test::GetValue<BinaryPrimitive>(&table_, "integer/foo"); - ASSERT_NE(nullptr, integer); - EXPECT_EQ(uint16_t(android::Res_value::TYPE_NULL), integer->value.dataType); - EXPECT_EQ(uint32_t(android::Res_value::DATA_NULL_EMPTY), integer->value.data); + ASSERT_THAT(integer, NotNull()); + EXPECT_THAT(integer->value.dataType, Eq(Res_value::TYPE_NULL)); + EXPECT_THAT(integer->value.data, Eq(Res_value::DATA_NULL_EMPTY)); } TEST_F(ResourceParserTest, ParseAttr) { - std::string input = - "<attr name=\"foo\" format=\"string\"/>\n" - "<attr name=\"bar\"/>"; + std::string input = R"( + <attr name="foo" format="string"/> + <attr name="bar"/>)"; ASSERT_TRUE(TestParse(input)); Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo"); - ASSERT_NE(nullptr, attr); - EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->type_mask); + ASSERT_THAT(attr, NotNull()); + EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_STRING)); attr = test::GetValue<Attribute>(&table_, "attr/bar"); - ASSERT_NE(nullptr, attr); - EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_ANY), attr->type_mask); + ASSERT_THAT(attr, NotNull()); + EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_ANY)); } -// Old AAPT allowed attributes to be defined under different configurations, but -// ultimately -// stored them with the default configuration. Check that we have the same -// behavior. +// Old AAPT allowed attributes to be defined under different configurations, but ultimately +// stored them with the default configuration. Check that we have the same behavior. TEST_F(ResourceParserTest, ParseAttrAndDeclareStyleableUnderConfigButRecordAsNoConfig) { const ConfigDescription watch_config = test::ParseConfigOrDie("watch"); std::string input = R"( @@ -252,583 +246,519 @@ TEST_F(ResourceParserTest, ParseAttrAndDeclareStyleableUnderConfigButRecordAsNoC </declare-styleable>)"; ASSERT_TRUE(TestParse(input, watch_config)); - EXPECT_EQ(nullptr, test::GetValueForConfig<Attribute>(&table_, "attr/foo", watch_config)); - EXPECT_EQ(nullptr, test::GetValueForConfig<Attribute>(&table_, "attr/baz", watch_config)); - EXPECT_EQ(nullptr, test::GetValueForConfig<Styleable>(&table_, "styleable/bar", watch_config)); + EXPECT_THAT(test::GetValueForConfig<Attribute>(&table_, "attr/foo", watch_config), IsNull()); + EXPECT_THAT(test::GetValueForConfig<Attribute>(&table_, "attr/baz", watch_config), IsNull()); + EXPECT_THAT(test::GetValueForConfig<Styleable>(&table_, "styleable/bar", watch_config), IsNull()); - EXPECT_NE(nullptr, test::GetValue<Attribute>(&table_, "attr/foo")); - EXPECT_NE(nullptr, test::GetValue<Attribute>(&table_, "attr/baz")); - EXPECT_NE(nullptr, test::GetValue<Styleable>(&table_, "styleable/bar")); + EXPECT_THAT(test::GetValue<Attribute>(&table_, "attr/foo"), NotNull()); + EXPECT_THAT(test::GetValue<Attribute>(&table_, "attr/baz"), NotNull()); + EXPECT_THAT(test::GetValue<Styleable>(&table_, "styleable/bar"), NotNull()); } TEST_F(ResourceParserTest, ParseAttrWithMinMax) { - std::string input = - "<attr name=\"foo\" min=\"10\" max=\"23\" format=\"integer\"/>"; + std::string input = R"(<attr name="foo" min="10" max="23" format="integer"/>)"; ASSERT_TRUE(TestParse(input)); Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo"); - ASSERT_NE(nullptr, attr); - EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_INTEGER), attr->type_mask); - EXPECT_EQ(10, attr->min_int); - EXPECT_EQ(23, attr->max_int); + ASSERT_THAT(attr, NotNull()); + EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_INTEGER)); + EXPECT_THAT(attr->min_int, Eq(10)); + EXPECT_THAT(attr->max_int, Eq(23)); } TEST_F(ResourceParserTest, FailParseAttrWithMinMaxButNotInteger) { - std::string input = - "<attr name=\"foo\" min=\"10\" max=\"23\" format=\"string\"/>"; - ASSERT_FALSE(TestParse(input)); + ASSERT_FALSE(TestParse(R"(<attr name="foo" min="10" max="23" format="string"/>)")); } TEST_F(ResourceParserTest, ParseUseAndDeclOfAttr) { - std::string input = - "<declare-styleable name=\"Styleable\">\n" - " <attr name=\"foo\" />\n" - "</declare-styleable>\n" - "<attr name=\"foo\" format=\"string\"/>"; + std::string input = R"( + <declare-styleable name="Styleable"> + <attr name="foo" /> + </declare-styleable> + <attr name="foo" format="string"/>)"; ASSERT_TRUE(TestParse(input)); Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo"); - ASSERT_NE(nullptr, attr); - EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->type_mask); + ASSERT_THAT(attr, NotNull()); + EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_STRING)); } TEST_F(ResourceParserTest, ParseDoubleUseOfAttr) { - std::string input = - "<declare-styleable name=\"Theme\">" - " <attr name=\"foo\" />\n" - "</declare-styleable>\n" - "<declare-styleable name=\"Window\">\n" - " <attr name=\"foo\" format=\"boolean\"/>\n" - "</declare-styleable>"; + std::string input = R"( + <declare-styleable name="Theme"> + <attr name="foo" /> + </declare-styleable> + <declare-styleable name="Window"> + <attr name="foo" format="boolean"/> + </declare-styleable>)"; ASSERT_TRUE(TestParse(input)); Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo"); - ASSERT_NE(nullptr, attr); - EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_BOOLEAN), attr->type_mask); + ASSERT_THAT(attr, NotNull()); + EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_BOOLEAN)); } TEST_F(ResourceParserTest, ParseEnumAttr) { - std::string input = - "<attr name=\"foo\">\n" - " <enum name=\"bar\" value=\"0\"/>\n" - " <enum name=\"bat\" value=\"1\"/>\n" - " <enum name=\"baz\" value=\"2\"/>\n" - "</attr>"; + std::string input = R"( + <attr name="foo"> + <enum name="bar" value="0"/> + <enum name="bat" value="1"/> + <enum name="baz" value="2"/> + </attr>)"; ASSERT_TRUE(TestParse(input)); Attribute* enum_attr = test::GetValue<Attribute>(&table_, "attr/foo"); - ASSERT_NE(enum_attr, nullptr); - EXPECT_EQ(enum_attr->type_mask, android::ResTable_map::TYPE_ENUM); - ASSERT_EQ(enum_attr->symbols.size(), 3u); + ASSERT_THAT(enum_attr, NotNull()); + EXPECT_THAT(enum_attr->type_mask, Eq(ResTable_map::TYPE_ENUM)); + ASSERT_THAT(enum_attr->symbols, SizeIs(3)); - AAPT_ASSERT_TRUE(enum_attr->symbols[0].symbol.name); - EXPECT_EQ(enum_attr->symbols[0].symbol.name.value().entry, "bar"); - EXPECT_EQ(enum_attr->symbols[0].value, 0u); + ASSERT_TRUE(enum_attr->symbols[0].symbol.name); + EXPECT_THAT(enum_attr->symbols[0].symbol.name.value().entry, Eq("bar")); + EXPECT_THAT(enum_attr->symbols[0].value, Eq(0u)); - AAPT_ASSERT_TRUE(enum_attr->symbols[1].symbol.name); - EXPECT_EQ(enum_attr->symbols[1].symbol.name.value().entry, "bat"); - EXPECT_EQ(enum_attr->symbols[1].value, 1u); + ASSERT_TRUE(enum_attr->symbols[1].symbol.name); + EXPECT_THAT(enum_attr->symbols[1].symbol.name.value().entry, Eq("bat")); + EXPECT_THAT(enum_attr->symbols[1].value, Eq(1u)); - AAPT_ASSERT_TRUE(enum_attr->symbols[2].symbol.name); - EXPECT_EQ(enum_attr->symbols[2].symbol.name.value().entry, "baz"); - EXPECT_EQ(enum_attr->symbols[2].value, 2u); + ASSERT_TRUE(enum_attr->symbols[2].symbol.name); + EXPECT_THAT(enum_attr->symbols[2].symbol.name.value().entry, Eq("baz")); + EXPECT_THAT(enum_attr->symbols[2].value, Eq(2u)); } TEST_F(ResourceParserTest, ParseFlagAttr) { - std::string input = - "<attr name=\"foo\">\n" - " <flag name=\"bar\" value=\"0\"/>\n" - " <flag name=\"bat\" value=\"1\"/>\n" - " <flag name=\"baz\" value=\"2\"/>\n" - "</attr>"; + std::string input = R"( + <attr name="foo"> + <flag name="bar" value="0"/> + <flag name="bat" value="1"/> + <flag name="baz" value="2"/> + </attr>)"; ASSERT_TRUE(TestParse(input)); Attribute* flag_attr = test::GetValue<Attribute>(&table_, "attr/foo"); - ASSERT_NE(nullptr, flag_attr); - EXPECT_EQ(flag_attr->type_mask, android::ResTable_map::TYPE_FLAGS); - ASSERT_EQ(flag_attr->symbols.size(), 3u); + ASSERT_THAT(flag_attr, NotNull()); + EXPECT_THAT(flag_attr->type_mask, Eq(ResTable_map::TYPE_FLAGS)); + ASSERT_THAT(flag_attr->symbols, SizeIs(3)); - AAPT_ASSERT_TRUE(flag_attr->symbols[0].symbol.name); - EXPECT_EQ(flag_attr->symbols[0].symbol.name.value().entry, "bar"); - EXPECT_EQ(flag_attr->symbols[0].value, 0u); + ASSERT_TRUE(flag_attr->symbols[0].symbol.name); + EXPECT_THAT(flag_attr->symbols[0].symbol.name.value().entry, Eq("bar")); + EXPECT_THAT(flag_attr->symbols[0].value, Eq(0u)); - AAPT_ASSERT_TRUE(flag_attr->symbols[1].symbol.name); - EXPECT_EQ(flag_attr->symbols[1].symbol.name.value().entry, "bat"); - EXPECT_EQ(flag_attr->symbols[1].value, 1u); + ASSERT_TRUE(flag_attr->symbols[1].symbol.name); + EXPECT_THAT(flag_attr->symbols[1].symbol.name.value().entry, Eq("bat")); + EXPECT_THAT(flag_attr->symbols[1].value, Eq(1u)); - AAPT_ASSERT_TRUE(flag_attr->symbols[2].symbol.name); - EXPECT_EQ(flag_attr->symbols[2].symbol.name.value().entry, "baz"); - EXPECT_EQ(flag_attr->symbols[2].value, 2u); + ASSERT_TRUE(flag_attr->symbols[2].symbol.name); + EXPECT_THAT(flag_attr->symbols[2].symbol.name.value().entry, Eq("baz")); + EXPECT_THAT(flag_attr->symbols[2].value, Eq(2u)); std::unique_ptr<BinaryPrimitive> flag_value = ResourceUtils::TryParseFlagSymbol(flag_attr, "baz|bat"); - ASSERT_NE(nullptr, flag_value); - EXPECT_EQ(flag_value->value.data, 1u | 2u); + ASSERT_THAT(flag_value, NotNull()); + EXPECT_THAT(flag_value->value.data, Eq(1u | 2u)); } TEST_F(ResourceParserTest, FailToParseEnumAttrWithNonUniqueKeys) { - std::string input = - "<attr name=\"foo\">\n" - " <enum name=\"bar\" value=\"0\"/>\n" - " <enum name=\"bat\" value=\"1\"/>\n" - " <enum name=\"bat\" value=\"2\"/>\n" - "</attr>"; + std::string input = R"( + <attr name="foo"> + <enum name="bar" value="0"/> + <enum name="bat" value="1"/> + <enum name="bat" value="2"/> + </attr>)"; ASSERT_FALSE(TestParse(input)); } TEST_F(ResourceParserTest, ParseStyle) { - std::string input = - "<style name=\"foo\" parent=\"@style/fu\">\n" - " <item name=\"bar\">#ffffffff</item>\n" - " <item name=\"bat\">@string/hey</item>\n" - " <item name=\"baz\"><b>hey</b></item>\n" - "</style>"; + std::string input = R"( + <style name="foo" parent="@style/fu"> + <item name="bar">#ffffffff</item> + <item name="bat">@string/hey</item> + <item name="baz"><b>hey</b></item> + </style>)"; ASSERT_TRUE(TestParse(input)); Style* style = test::GetValue<Style>(&table_, "style/foo"); - ASSERT_NE(nullptr, style); - AAPT_ASSERT_TRUE(style->parent); - AAPT_ASSERT_TRUE(style->parent.value().name); - EXPECT_EQ(test::ParseNameOrDie("style/fu"), - style->parent.value().name.value()); - ASSERT_EQ(3u, style->entries.size()); - - AAPT_ASSERT_TRUE(style->entries[0].key.name); - EXPECT_EQ(test::ParseNameOrDie("attr/bar"), - style->entries[0].key.name.value()); + ASSERT_THAT(style, NotNull()); + ASSERT_TRUE(style->parent); + EXPECT_THAT(style->parent.value().name, Eq(make_value(test::ParseNameOrDie("style/fu")))); + ASSERT_THAT(style->entries, SizeIs(3)); - AAPT_ASSERT_TRUE(style->entries[1].key.name); - EXPECT_EQ(test::ParseNameOrDie("attr/bat"), - style->entries[1].key.name.value()); - - AAPT_ASSERT_TRUE(style->entries[2].key.name); - EXPECT_EQ(test::ParseNameOrDie("attr/baz"), - style->entries[2].key.name.value()); + EXPECT_THAT(style->entries[0].key.name, Eq(make_value(test::ParseNameOrDie("attr/bar")))); + EXPECT_THAT(style->entries[1].key.name, Eq(make_value(test::ParseNameOrDie("attr/bat")))); + EXPECT_THAT(style->entries[2].key.name, Eq(make_value(test::ParseNameOrDie("attr/baz")))); } TEST_F(ResourceParserTest, ParseStyleWithShorthandParent) { - std::string input = "<style name=\"foo\" parent=\"com.app:Theme\"/>"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<style name="foo" parent="com.app:Theme"/>)")); Style* style = test::GetValue<Style>(&table_, "style/foo"); - ASSERT_NE(nullptr, style); - AAPT_ASSERT_TRUE(style->parent); - AAPT_ASSERT_TRUE(style->parent.value().name); - EXPECT_EQ(test::ParseNameOrDie("com.app:style/Theme"), - style->parent.value().name.value()); + ASSERT_THAT(style, NotNull()); + ASSERT_TRUE(style->parent); + EXPECT_THAT(style->parent.value().name, Eq(make_value(test::ParseNameOrDie("com.app:style/Theme")))); } TEST_F(ResourceParserTest, ParseStyleWithPackageAliasedParent) { - std::string input = - "<style xmlns:app=\"http://schemas.android.com/apk/res/android\"\n" - " name=\"foo\" parent=\"app:Theme\"/>"; + std::string input = R"( + <style xmlns:app="http://schemas.android.com/apk/res/android" + name="foo" parent="app:Theme"/>)"; ASSERT_TRUE(TestParse(input)); Style* style = test::GetValue<Style>(&table_, "style/foo"); - ASSERT_NE(nullptr, style); - AAPT_ASSERT_TRUE(style->parent); - AAPT_ASSERT_TRUE(style->parent.value().name); - EXPECT_EQ(test::ParseNameOrDie("android:style/Theme"), - style->parent.value().name.value()); + ASSERT_THAT(style, NotNull()); + ASSERT_TRUE(style->parent); + ASSERT_TRUE(style->parent.value().name); + EXPECT_THAT(style->parent.value().name, Eq(make_value(test::ParseNameOrDie("android:style/Theme")))); } TEST_F(ResourceParserTest, ParseStyleWithPackageAliasedItems) { - std::string input = - "<style xmlns:app=\"http://schemas.android.com/apk/res/android\" " - "name=\"foo\">\n" - " <item name=\"app:bar\">0</item>\n" - "</style>"; + std::string input = R"( + <style xmlns:app="http://schemas.android.com/apk/res/android" name="foo"> + <item name="app:bar">0</item> + </style>)"; ASSERT_TRUE(TestParse(input)); Style* style = test::GetValue<Style>(&table_, "style/foo"); - ASSERT_NE(nullptr, style); - ASSERT_EQ(1u, style->entries.size()); - EXPECT_EQ(test::ParseNameOrDie("android:attr/bar"), - style->entries[0].key.name.value()); + ASSERT_THAT(style, NotNull()); + ASSERT_THAT(style->entries, SizeIs(1)); + EXPECT_THAT(style->entries[0].key.name, Eq(make_value(test::ParseNameOrDie("android:attr/bar")))); } TEST_F(ResourceParserTest, ParseStyleWithInferredParent) { - std::string input = "<style name=\"foo.bar\"/>"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<style name="foo.bar"/>)")); Style* style = test::GetValue<Style>(&table_, "style/foo.bar"); - ASSERT_NE(nullptr, style); - AAPT_ASSERT_TRUE(style->parent); - AAPT_ASSERT_TRUE(style->parent.value().name); - EXPECT_EQ(style->parent.value().name.value(), - test::ParseNameOrDie("style/foo")); + ASSERT_THAT(style, NotNull()); + ASSERT_TRUE(style->parent); + EXPECT_THAT(style->parent.value().name, Eq(make_value(test::ParseNameOrDie("style/foo")))); EXPECT_TRUE(style->parent_inferred); } -TEST_F(ResourceParserTest, - ParseStyleWithInferredParentOverridenByEmptyParentAttribute) { - std::string input = "<style name=\"foo.bar\" parent=\"\"/>"; - ASSERT_TRUE(TestParse(input)); +TEST_F(ResourceParserTest, ParseStyleWithInferredParentOverridenByEmptyParentAttribute) { + ASSERT_TRUE(TestParse(R"(<style name="foo.bar" parent=""/>)")); Style* style = test::GetValue<Style>(&table_, "style/foo.bar"); - ASSERT_NE(nullptr, style); - AAPT_EXPECT_FALSE(style->parent); + ASSERT_THAT(style, NotNull()); + EXPECT_FALSE(style->parent); EXPECT_FALSE(style->parent_inferred); } TEST_F(ResourceParserTest, ParseStyleWithPrivateParentReference) { - std::string input = - R"EOF(<style name="foo" parent="*android:style/bar" />)EOF"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<style name="foo" parent="*android:style/bar" />)")); Style* style = test::GetValue<Style>(&table_, "style/foo"); - ASSERT_NE(nullptr, style); - AAPT_ASSERT_TRUE(style->parent); + ASSERT_THAT(style, NotNull()); + ASSERT_TRUE(style->parent); EXPECT_TRUE(style->parent.value().private_reference); } TEST_F(ResourceParserTest, ParseAutoGeneratedIdReference) { - std::string input = "<string name=\"foo\">@+id/bar</string>"; - ASSERT_TRUE(TestParse(input)); - - Id* id = test::GetValue<Id>(&table_, "id/bar"); - ASSERT_NE(id, nullptr); + ASSERT_TRUE(TestParse(R"(<string name="foo">@+id/bar</string>)")); + ASSERT_THAT(test::GetValue<Id>(&table_, "id/bar"), NotNull()); } TEST_F(ResourceParserTest, ParseAttributesDeclareStyleable) { - std::string input = - "<declare-styleable name=\"foo\">\n" - " <attr name=\"bar\" />\n" - " <attr name=\"bat\" format=\"string|reference\"/>\n" - " <attr name=\"baz\">\n" - " <enum name=\"foo\" value=\"1\"/>\n" - " </attr>\n" - "</declare-styleable>"; + std::string input = R"( + <declare-styleable name="foo"> + <attr name="bar" /> + <attr name="bat" format="string|reference"/> + <attr name="baz"> + <enum name="foo" value="1"/> + </attr> + </declare-styleable>)"; ASSERT_TRUE(TestParse(input)); Maybe<ResourceTable::SearchResult> result = table_.FindResource(test::ParseNameOrDie("styleable/foo")); - AAPT_ASSERT_TRUE(result); - EXPECT_EQ(SymbolState::kPublic, result.value().entry->symbol_status.state); + ASSERT_TRUE(result); + EXPECT_THAT(result.value().entry->symbol_status.state, Eq(SymbolState::kPublic)); Attribute* attr = test::GetValue<Attribute>(&table_, "attr/bar"); - ASSERT_NE(attr, nullptr); + ASSERT_THAT(attr, NotNull()); EXPECT_TRUE(attr->IsWeak()); attr = test::GetValue<Attribute>(&table_, "attr/bat"); - ASSERT_NE(attr, nullptr); + ASSERT_THAT(attr, NotNull()); EXPECT_TRUE(attr->IsWeak()); attr = test::GetValue<Attribute>(&table_, "attr/baz"); - ASSERT_NE(attr, nullptr); + ASSERT_THAT(attr, NotNull()); EXPECT_TRUE(attr->IsWeak()); - EXPECT_EQ(1u, attr->symbols.size()); + EXPECT_THAT(attr->symbols, SizeIs(1)); - EXPECT_NE(nullptr, test::GetValue<Id>(&table_, "id/foo")); + EXPECT_THAT(test::GetValue<Id>(&table_, "id/foo"), NotNull()); Styleable* styleable = test::GetValue<Styleable>(&table_, "styleable/foo"); - ASSERT_NE(styleable, nullptr); - ASSERT_EQ(3u, styleable->entries.size()); + ASSERT_THAT(styleable, NotNull()); + ASSERT_THAT(styleable->entries, SizeIs(3)); - EXPECT_EQ(test::ParseNameOrDie("attr/bar"), - styleable->entries[0].name.value()); - EXPECT_EQ(test::ParseNameOrDie("attr/bat"), - styleable->entries[1].name.value()); + EXPECT_THAT(styleable->entries[0].name, Eq(make_value(test::ParseNameOrDie("attr/bar")))); + EXPECT_THAT(styleable->entries[1].name, Eq(make_value(test::ParseNameOrDie("attr/bat")))); + EXPECT_THAT(styleable->entries[2].name, Eq(make_value(test::ParseNameOrDie("attr/baz")))); } TEST_F(ResourceParserTest, ParsePrivateAttributesDeclareStyleable) { - std::string input = - "<declare-styleable name=\"foo\" " - "xmlns:privAndroid=\"http://schemas.android.com/apk/prv/res/android\">\n" - " <attr name=\"*android:bar\" />\n" - " <attr name=\"privAndroid:bat\" />\n" - "</declare-styleable>"; + std::string input = R"( + <declare-styleable xmlns:privAndroid="http://schemas.android.com/apk/prv/res/android" + name="foo"> + <attr name="*android:bar" /> + <attr name="privAndroid:bat" /> + </declare-styleable>)"; ASSERT_TRUE(TestParse(input)); Styleable* styleable = test::GetValue<Styleable>(&table_, "styleable/foo"); - ASSERT_NE(nullptr, styleable); - ASSERT_EQ(2u, styleable->entries.size()); + ASSERT_THAT(styleable, NotNull()); + ASSERT_THAT(styleable->entries, SizeIs(2)); EXPECT_TRUE(styleable->entries[0].private_reference); - AAPT_ASSERT_TRUE(styleable->entries[0].name); - EXPECT_EQ(std::string("android"), styleable->entries[0].name.value().package); + ASSERT_TRUE(styleable->entries[0].name); + EXPECT_THAT(styleable->entries[0].name.value().package, Eq("android")); EXPECT_TRUE(styleable->entries[1].private_reference); - AAPT_ASSERT_TRUE(styleable->entries[1].name); - EXPECT_EQ(std::string("android"), styleable->entries[1].name.value().package); + ASSERT_TRUE(styleable->entries[1].name); + EXPECT_THAT(styleable->entries[1].name.value().package, Eq("android")); } TEST_F(ResourceParserTest, ParseArray) { - std::string input = - "<array name=\"foo\">\n" - " <item>@string/ref</item>\n" - " <item>hey</item>\n" - " <item>23</item>\n" - "</array>"; + std::string input = R"( + <array name="foo"> + <item>@string/ref</item> + <item>hey</item> + <item>23</item> + </array>)"; ASSERT_TRUE(TestParse(input)); Array* array = test::GetValue<Array>(&table_, "array/foo"); - ASSERT_NE(array, nullptr); - ASSERT_EQ(3u, array->items.size()); + ASSERT_THAT(array, NotNull()); + ASSERT_THAT(array->items, SizeIs(3)); - EXPECT_NE(nullptr, ValueCast<Reference>(array->items[0].get())); - EXPECT_NE(nullptr, ValueCast<String>(array->items[1].get())); - EXPECT_NE(nullptr, ValueCast<BinaryPrimitive>(array->items[2].get())); + EXPECT_THAT(ValueCast<Reference>(array->items[0].get()), NotNull()); + EXPECT_THAT(ValueCast<String>(array->items[1].get()), NotNull()); + EXPECT_THAT(ValueCast<BinaryPrimitive>(array->items[2].get()), NotNull()); } TEST_F(ResourceParserTest, ParseStringArray) { - std::string input = R"EOF( + std::string input = R"( <string-array name="foo"> <item>"Werk"</item>" - </string-array>)EOF"; + </string-array>)"; ASSERT_TRUE(TestParse(input)); - EXPECT_NE(nullptr, test::GetValue<Array>(&table_, "array/foo")); + EXPECT_THAT(test::GetValue<Array>(&table_, "array/foo"), NotNull()); } TEST_F(ResourceParserTest, ParseArrayWithFormat) { - std::string input = R"EOF( + std::string input = R"( <array name="foo" format="string"> <item>100</item> - </array>)EOF"; + </array>)"; ASSERT_TRUE(TestParse(input)); Array* array = test::GetValue<Array>(&table_, "array/foo"); - ASSERT_NE(nullptr, array); - - ASSERT_EQ(1u, array->items.size()); + ASSERT_THAT(array, NotNull()); + ASSERT_THAT(array->items, SizeIs(1)); String* str = ValueCast<String>(array->items[0].get()); - ASSERT_NE(nullptr, str); - EXPECT_EQ(std::string("100"), *str->value); + ASSERT_THAT(str, NotNull()); + EXPECT_THAT(*str, StrValueEq("100")); } TEST_F(ResourceParserTest, ParseArrayWithBadFormat) { - std::string input = R"EOF( + std::string input = R"( <array name="foo" format="integer"> <item>Hi</item> - </array>)EOF"; + </array>)"; ASSERT_FALSE(TestParse(input)); } TEST_F(ResourceParserTest, ParsePlural) { - std::string input = - "<plurals name=\"foo\">\n" - " <item quantity=\"other\">apples</item>\n" - " <item quantity=\"one\">apple</item>\n" - "</plurals>"; + std::string input = R"( + <plurals name="foo"> + <item quantity="other">apples</item> + <item quantity="one">apple</item> + </plurals>)"; ASSERT_TRUE(TestParse(input)); Plural* plural = test::GetValue<Plural>(&table_, "plurals/foo"); - ASSERT_NE(nullptr, plural); - EXPECT_EQ(nullptr, plural->values[Plural::Zero]); - EXPECT_EQ(nullptr, plural->values[Plural::Two]); - EXPECT_EQ(nullptr, plural->values[Plural::Few]); - EXPECT_EQ(nullptr, plural->values[Plural::Many]); + ASSERT_THAT(plural, NotNull()); + EXPECT_THAT(plural->values[Plural::Zero], IsNull()); + EXPECT_THAT(plural->values[Plural::Two], IsNull()); + EXPECT_THAT(plural->values[Plural::Few], IsNull()); + EXPECT_THAT(plural->values[Plural::Many], IsNull()); - EXPECT_NE(nullptr, plural->values[Plural::One]); - EXPECT_NE(nullptr, plural->values[Plural::Other]); + EXPECT_THAT(plural->values[Plural::One], NotNull()); + EXPECT_THAT(plural->values[Plural::Other], NotNull()); } TEST_F(ResourceParserTest, ParseCommentsWithResource) { - std::string input = - "<!--This is a comment-->\n" - "<string name=\"foo\">Hi</string>"; + std::string input = R"( + <!--This is a comment--> + <string name="foo">Hi</string>)"; ASSERT_TRUE(TestParse(input)); String* value = test::GetValue<String>(&table_, "string/foo"); - ASSERT_NE(nullptr, value); - EXPECT_EQ(value->GetComment(), "This is a comment"); + ASSERT_THAT(value, NotNull()); + EXPECT_THAT(value->GetComment(), Eq("This is a comment")); } TEST_F(ResourceParserTest, DoNotCombineMultipleComments) { - std::string input = - "<!--One-->\n" - "<!--Two-->\n" - "<string name=\"foo\">Hi</string>"; + std::string input = R"( + <!--One--> + <!--Two--> + <string name="foo">Hi</string>)"; ASSERT_TRUE(TestParse(input)); String* value = test::GetValue<String>(&table_, "string/foo"); - ASSERT_NE(nullptr, value); - EXPECT_EQ(value->GetComment(), "Two"); + ASSERT_THAT(value, NotNull()); + EXPECT_THAT(value->GetComment(), Eq("Two")); } TEST_F(ResourceParserTest, IgnoreCommentBeforeEndTag) { - std::string input = - "<!--One-->\n" - "<string name=\"foo\">\n" - " Hi\n" - "<!--Two-->\n" - "</string>"; - + std::string input = R"( + <!--One--> + <string name="foo"> + Hi + <!--Two--> + </string>)"; ASSERT_TRUE(TestParse(input)); String* value = test::GetValue<String>(&table_, "string/foo"); - ASSERT_NE(nullptr, value); - EXPECT_EQ(value->GetComment(), "One"); + ASSERT_THAT(value, NotNull()); + EXPECT_THAT(value->GetComment(), Eq("One")); } TEST_F(ResourceParserTest, ParseNestedComments) { // We only care about declare-styleable and enum/flag attributes because - // comments - // from those end up in R.java - std::string input = R"EOF( - <declare-styleable name="foo"> - <!-- The name of the bar --> - <attr name="barName" format="string|reference" /> - </declare-styleable> - - <attr name="foo"> - <!-- The very first --> - <enum name="one" value="1" /> - </attr>)EOF"; + // comments from those end up in R.java + std::string input = R"( + <declare-styleable name="foo"> + <!-- The name of the bar --> + <attr name="barName" format="string|reference" /> + </declare-styleable> + + <attr name="foo"> + <!-- The very first --> + <enum name="one" value="1" /> + </attr>)"; ASSERT_TRUE(TestParse(input)); Styleable* styleable = test::GetValue<Styleable>(&table_, "styleable/foo"); - ASSERT_NE(nullptr, styleable); - ASSERT_EQ(1u, styleable->entries.size()); - - EXPECT_EQ(StringPiece("The name of the bar"), - styleable->entries.front().GetComment()); + ASSERT_THAT(styleable, NotNull()); + ASSERT_THAT(styleable->entries, SizeIs(1)); + EXPECT_THAT(styleable->entries[0].GetComment(), Eq("The name of the bar")); Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo"); - ASSERT_NE(nullptr, attr); - ASSERT_EQ(1u, attr->symbols.size()); - - EXPECT_EQ(StringPiece("The very first"), - attr->symbols.front().symbol.GetComment()); + ASSERT_THAT(attr, NotNull()); + ASSERT_THAT(attr->symbols, SizeIs(1)); + EXPECT_THAT(attr->symbols[0].symbol.GetComment(), Eq("The very first")); } -/* - * Declaring an ID as public should not require a separate definition - * (as an ID has no value). - */ +// Declaring an ID as public should not require a separate definition (as an ID has no value). TEST_F(ResourceParserTest, ParsePublicIdAsDefinition) { - std::string input = "<public type=\"id\" name=\"foo\"/>"; - ASSERT_TRUE(TestParse(input)); - - Id* id = test::GetValue<Id>(&table_, "id/foo"); - ASSERT_NE(nullptr, id); + ASSERT_TRUE(TestParse(R"(<public type="id" name="foo"/>)")); + ASSERT_THAT(test::GetValue<Id>(&table_, "id/foo"), NotNull()); } TEST_F(ResourceParserTest, KeepAllProducts) { - std::string input = R"EOF( - <string name="foo" product="phone">hi</string> - <string name="foo" product="no-sdcard">ho</string> - <string name="bar" product="">wee</string> - <string name="baz">woo</string> - <string name="bit" product="phablet">hoot</string> - <string name="bot" product="default">yes</string> - )EOF"; + std::string input = R"( + <string name="foo" product="phone">hi</string> + <string name="foo" product="no-sdcard">ho</string> + <string name="bar" product="">wee</string> + <string name="baz">woo</string> + <string name="bit" product="phablet">hoot</string> + <string name="bot" product="default">yes</string>)"; ASSERT_TRUE(TestParse(input)); - EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<String>( - &table_, "string/foo", - ConfigDescription::DefaultConfig(), "phone")); - EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<String>( - &table_, "string/foo", - ConfigDescription::DefaultConfig(), "no-sdcard")); - EXPECT_NE(nullptr, - test::GetValueForConfigAndProduct<String>( - &table_, "string/bar", ConfigDescription::DefaultConfig(), "")); - EXPECT_NE(nullptr, - test::GetValueForConfigAndProduct<String>( - &table_, "string/baz", ConfigDescription::DefaultConfig(), "")); - EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<String>( - &table_, "string/bit", - ConfigDescription::DefaultConfig(), "phablet")); - EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<String>( - &table_, "string/bot", - ConfigDescription::DefaultConfig(), "default")); + ASSERT_THAT(test::GetValueForConfigAndProduct<String>(&table_, "string/foo", ConfigDescription::DefaultConfig(), "phone"), NotNull()); + ASSERT_THAT(test::GetValueForConfigAndProduct<String>(&table_, "string/foo",ConfigDescription::DefaultConfig(), "no-sdcard"), NotNull()); + ASSERT_THAT(test::GetValueForConfigAndProduct<String>(&table_, "string/bar", ConfigDescription::DefaultConfig(), ""), NotNull()); + ASSERT_THAT(test::GetValueForConfigAndProduct<String>(&table_, "string/baz", ConfigDescription::DefaultConfig(), ""), NotNull()); + ASSERT_THAT(test::GetValueForConfigAndProduct<String>(&table_, "string/bit", ConfigDescription::DefaultConfig(), "phablet"), NotNull()); + ASSERT_THAT(test::GetValueForConfigAndProduct<String>(&table_, "string/bot", ConfigDescription::DefaultConfig(), "default"), NotNull()); } TEST_F(ResourceParserTest, AutoIncrementIdsInPublicGroup) { - std::string input = R"EOF( - <public-group type="attr" first-id="0x01010040"> - <public name="foo" /> - <public name="bar" /> - </public-group>)EOF"; + std::string input = R"( + <public-group type="attr" first-id="0x01010040"> + <public name="foo" /> + <public name="bar" /> + </public-group>)"; ASSERT_TRUE(TestParse(input)); - Maybe<ResourceTable::SearchResult> result = - table_.FindResource(test::ParseNameOrDie("attr/foo")); - AAPT_ASSERT_TRUE(result); + Maybe<ResourceTable::SearchResult> result = table_.FindResource(test::ParseNameOrDie("attr/foo")); + ASSERT_TRUE(result); - AAPT_ASSERT_TRUE(result.value().package->id); - AAPT_ASSERT_TRUE(result.value().type->id); - AAPT_ASSERT_TRUE(result.value().entry->id); + ASSERT_TRUE(result.value().package->id); + ASSERT_TRUE(result.value().type->id); + ASSERT_TRUE(result.value().entry->id); ResourceId actual_id(result.value().package->id.value(), result.value().type->id.value(), result.value().entry->id.value()); - EXPECT_EQ(ResourceId(0x01010040), actual_id); + EXPECT_THAT(actual_id, Eq(ResourceId(0x01010040))); result = table_.FindResource(test::ParseNameOrDie("attr/bar")); - AAPT_ASSERT_TRUE(result); + ASSERT_TRUE(result); - AAPT_ASSERT_TRUE(result.value().package->id); - AAPT_ASSERT_TRUE(result.value().type->id); - AAPT_ASSERT_TRUE(result.value().entry->id); + ASSERT_TRUE(result.value().package->id); + ASSERT_TRUE(result.value().type->id); + ASSERT_TRUE(result.value().entry->id); actual_id = ResourceId(result.value().package->id.value(), result.value().type->id.value(), result.value().entry->id.value()); - EXPECT_EQ(ResourceId(0x01010041), actual_id); + EXPECT_THAT(actual_id, Eq(ResourceId(0x01010041))); } TEST_F(ResourceParserTest, ExternalTypesShouldOnlyBeReferences) { - std::string input = - R"EOF(<item type="layout" name="foo">@layout/bar</item>)EOF"; - ASSERT_TRUE(TestParse(input)); - - input = R"EOF(<item type="layout" name="bar">"this is a string"</item>)EOF"; - ASSERT_FALSE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<item type="layout" name="foo">@layout/bar</item>)")); + ASSERT_FALSE(TestParse(R"(<item type="layout" name="bar">"this is a string"</item>)")); } TEST_F(ResourceParserTest, AddResourcesElementShouldAddEntryWithUndefinedSymbol) { - std::string input = R"EOF(<add-resource name="bar" type="string" />)EOF"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<add-resource name="bar" type="string" />)")); Maybe<ResourceTable::SearchResult> result = table_.FindResource(test::ParseNameOrDie("string/bar")); - AAPT_ASSERT_TRUE(result); + ASSERT_TRUE(result); const ResourceEntry* entry = result.value().entry; - ASSERT_NE(nullptr, entry); - EXPECT_EQ(SymbolState::kUndefined, entry->symbol_status.state); + ASSERT_THAT(entry, NotNull()); + EXPECT_THAT(entry->symbol_status.state, Eq(SymbolState::kUndefined)); EXPECT_TRUE(entry->symbol_status.allow_new); } TEST_F(ResourceParserTest, ParseItemElementWithFormat) { - std::string input = R"(<item name="foo" type="integer" format="float">0.3</item>)"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<item name="foo" type="integer" format="float">0.3</item>)")); BinaryPrimitive* val = test::GetValue<BinaryPrimitive>(&table_, "integer/foo"); ASSERT_THAT(val, NotNull()); - EXPECT_THAT(val->value.dataType, Eq(android::Res_value::TYPE_FLOAT)); + EXPECT_THAT(val->value.dataType, Eq(Res_value::TYPE_FLOAT)); - input = R"(<item name="bar" type="integer" format="fraction">100</item>)"; - ASSERT_FALSE(TestParse(input)); + ASSERT_FALSE(TestParse(R"(<item name="bar" type="integer" format="fraction">100</item>)")); } // An <item> without a format specifier accepts all types of values. TEST_F(ResourceParserTest, ParseItemElementWithoutFormat) { - std::string input = R"(<item name="foo" type="integer">100%p</item>)"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<item name="foo" type="integer">100%p</item>)")); BinaryPrimitive* val = test::GetValue<BinaryPrimitive>(&table_, "integer/foo"); ASSERT_THAT(val, NotNull()); - EXPECT_THAT(val->value.dataType, Eq(android::Res_value::TYPE_FRACTION)); + EXPECT_THAT(val->value.dataType, Eq(Res_value::TYPE_FRACTION)); } TEST_F(ResourceParserTest, ParseConfigVaryingItem) { - std::string input = R"EOF(<item name="foo" type="configVarying">Hey</item>)EOF"; - ASSERT_TRUE(TestParse(input)); - ASSERT_NE(nullptr, test::GetValue<String>(&table_, "configVarying/foo")); + ASSERT_TRUE(TestParse(R"(<item name="foo" type="configVarying">Hey</item>)")); + ASSERT_THAT(test::GetValue<String>(&table_, "configVarying/foo"), NotNull()); } TEST_F(ResourceParserTest, ParseBagElement) { - std::string input = - R"EOF(<bag name="bag" type="configVarying"><item name="test">Hello!</item></bag>)EOF"; + std::string input = R"( + <bag name="bag" type="configVarying"> + <item name="test">Hello!</item> + </bag>)"; ASSERT_TRUE(TestParse(input)); Style* val = test::GetValue<Style>(&table_, "configVarying/bag"); - ASSERT_NE(nullptr, val); + ASSERT_THAT(val, NotNull()); + ASSERT_THAT(val->entries, SizeIs(1)); - ASSERT_EQ(1u, val->entries.size()); - EXPECT_EQ(Reference(test::ParseNameOrDie("attr/test")), val->entries[0].key); - EXPECT_NE(nullptr, ValueCast<RawString>(val->entries[0].value.get())); + EXPECT_THAT(val->entries[0].key, Eq(Reference(test::ParseNameOrDie("attr/test")))); + EXPECT_THAT(ValueCast<RawString>(val->entries[0].value.get()), NotNull()); } TEST_F(ResourceParserTest, ParseElementWithNoValue) { @@ -840,12 +770,11 @@ TEST_F(ResourceParserTest, ParseElementWithNoValue) { String* str = test::GetValue<String>(&table_, "string/foo"); ASSERT_THAT(str, NotNull()); - EXPECT_THAT(*str->value, Eq("")); + EXPECT_THAT(*str, StrValueEq("")); } TEST_F(ResourceParserTest, ParsePlatformIndependentNewline) { - std::string input = R"(<string name="foo">%1$s %n %2$s</string>)"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<string name="foo">%1$s %n %2$s</string>)")); } } // namespace aapt diff --git a/tools/aapt2/ResourceTable_test.cpp b/tools/aapt2/ResourceTable_test.cpp index e2b37be994ff..2a3c131f7b4b 100644 --- a/tools/aapt2/ResourceTable_test.cpp +++ b/tools/aapt2/ResourceTable_test.cpp @@ -24,6 +24,8 @@ #include <ostream> #include <string> +using ::testing::NotNull; + namespace aapt { TEST(ResourceTableTest, FailToAddResourceWithBadName) { @@ -56,7 +58,7 @@ TEST(ResourceTableTest, AddOneResource) { test::ValueBuilder<Id>().SetSource("test/path/file.xml", 23u).Build(), test::GetDiagnostics())); - ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:attr/id")); + EXPECT_THAT(test::GetValue<Id>(&table, "android:attr/id"), NotNull()); } TEST(ResourceTableTest, AddMultipleResources) { @@ -88,11 +90,10 @@ TEST(ResourceTableTest, AddMultipleResources) { .Build(), test::GetDiagnostics())); - ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:attr/layout_width")); - ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:attr/id")); - ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:string/ok")); - ASSERT_NE(nullptr, test::GetValueForConfig<BinaryPrimitive>( - &table, "android:string/ok", language_config)); + EXPECT_THAT(test::GetValue<Id>(&table, "android:attr/layout_width"), NotNull()); + EXPECT_THAT(test::GetValue<Id>(&table, "android:attr/id"), NotNull()); + EXPECT_THAT(test::GetValue<Id>(&table, "android:string/ok"), NotNull()); + EXPECT_THAT(test::GetValueForConfig<BinaryPrimitive>(&table, "android:string/ok", language_config), NotNull()); } TEST(ResourceTableTest, OverrideWeakResourceValue) { @@ -103,7 +104,7 @@ TEST(ResourceTableTest, OverrideWeakResourceValue) { util::make_unique<Attribute>(true), test::GetDiagnostics())); Attribute* attr = test::GetValue<Attribute>(&table, "android:attr/foo"); - ASSERT_NE(nullptr, attr); + ASSERT_THAT(attr, NotNull()); EXPECT_TRUE(attr->IsWeak()); ASSERT_TRUE(table.AddResource( @@ -111,7 +112,7 @@ TEST(ResourceTableTest, OverrideWeakResourceValue) { util::make_unique<Attribute>(false), test::GetDiagnostics())); attr = test::GetValue<Attribute>(&table, "android:attr/foo"); - ASSERT_NE(nullptr, attr); + ASSERT_THAT(attr, NotNull()); EXPECT_FALSE(attr->IsWeak()); } @@ -127,16 +128,12 @@ TEST(ResourceTableTest, ProductVaryingValues) { util::make_unique<Id>(), test::GetDiagnostics())); - EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<Id>( - &table, "android:string/foo", - test::ParseConfigOrDie("land"), "tablet")); - EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<Id>( - &table, "android:string/foo", - test::ParseConfigOrDie("land"), "phone")); + EXPECT_THAT(test::GetValueForConfigAndProduct<Id>(&table, "android:string/foo",test::ParseConfigOrDie("land"), "tablet"), NotNull()); + EXPECT_THAT(test::GetValueForConfigAndProduct<Id>(&table, "android:string/foo",test::ParseConfigOrDie("land"), "phone"), NotNull()); Maybe<ResourceTable::SearchResult> sr = table.FindResource(test::ParseNameOrDie("android:string/foo")); - AAPT_ASSERT_TRUE(sr); + ASSERT_TRUE(sr); std::vector<ResourceConfigValue*> values = sr.value().entry->FindAllValues(test::ParseConfigOrDie("land")); ASSERT_EQ(2u, values.size()); diff --git a/tools/aapt2/ResourceUtils_test.cpp b/tools/aapt2/ResourceUtils_test.cpp index cdc34f1ec752..3a5e685e6b94 100644 --- a/tools/aapt2/ResourceUtils_test.cpp +++ b/tools/aapt2/ResourceUtils_test.cpp @@ -20,96 +20,88 @@ #include "test/Test.h" using ::aapt::test::ValueEq; +using ::android::Res_value; +using ::android::ResTable_map; +using ::testing::Eq; +using ::testing::NotNull; using ::testing::Pointee; namespace aapt { TEST(ResourceUtilsTest, ParseBool) { - EXPECT_EQ(Maybe<bool>(true), ResourceUtils::ParseBool("true")); - EXPECT_EQ(Maybe<bool>(true), ResourceUtils::ParseBool("TRUE")); - EXPECT_EQ(Maybe<bool>(true), ResourceUtils::ParseBool("True")); - EXPECT_EQ(Maybe<bool>(false), ResourceUtils::ParseBool("false")); - EXPECT_EQ(Maybe<bool>(false), ResourceUtils::ParseBool("FALSE")); - EXPECT_EQ(Maybe<bool>(false), ResourceUtils::ParseBool("False")); + EXPECT_THAT(ResourceUtils::ParseBool("true"), Eq(Maybe<bool>(true))); + EXPECT_THAT(ResourceUtils::ParseBool("TRUE"), Eq(Maybe<bool>(true))); + EXPECT_THAT(ResourceUtils::ParseBool("True"), Eq(Maybe<bool>(true))); + + EXPECT_THAT(ResourceUtils::ParseBool("false"), Eq(Maybe<bool>(false))); + EXPECT_THAT(ResourceUtils::ParseBool("FALSE"), Eq(Maybe<bool>(false))); + EXPECT_THAT(ResourceUtils::ParseBool("False"), Eq(Maybe<bool>(false))); } TEST(ResourceUtilsTest, ParseResourceName) { ResourceNameRef actual; bool actual_priv = false; - EXPECT_TRUE(ResourceUtils::ParseResourceName("android:color/foo", &actual, - &actual_priv)); - EXPECT_EQ(ResourceNameRef("android", ResourceType::kColor, "foo"), actual); + EXPECT_TRUE(ResourceUtils::ParseResourceName("android:color/foo", &actual, &actual_priv)); + EXPECT_THAT(actual, Eq(ResourceNameRef("android", ResourceType::kColor, "foo"))); EXPECT_FALSE(actual_priv); - EXPECT_TRUE( - ResourceUtils::ParseResourceName("color/foo", &actual, &actual_priv)); - EXPECT_EQ(ResourceNameRef({}, ResourceType::kColor, "foo"), actual); + EXPECT_TRUE(ResourceUtils::ParseResourceName("color/foo", &actual, &actual_priv)); + EXPECT_THAT(actual, Eq(ResourceNameRef({}, ResourceType::kColor, "foo"))); EXPECT_FALSE(actual_priv); - EXPECT_TRUE(ResourceUtils::ParseResourceName("*android:color/foo", &actual, - &actual_priv)); - EXPECT_EQ(ResourceNameRef("android", ResourceType::kColor, "foo"), actual); + EXPECT_TRUE(ResourceUtils::ParseResourceName("*android:color/foo", &actual, &actual_priv)); + EXPECT_THAT(actual, Eq(ResourceNameRef("android", ResourceType::kColor, "foo"))); EXPECT_TRUE(actual_priv); EXPECT_FALSE(ResourceUtils::ParseResourceName(android::StringPiece(), &actual, &actual_priv)); } TEST(ResourceUtilsTest, ParseReferenceWithNoPackage) { - ResourceNameRef expected({}, ResourceType::kColor, "foo"); ResourceNameRef actual; bool create = false; bool private_ref = false; - EXPECT_TRUE(ResourceUtils::ParseReference("@color/foo", &actual, &create, - &private_ref)); - EXPECT_EQ(expected, actual); + EXPECT_TRUE(ResourceUtils::ParseReference("@color/foo", &actual, &create, &private_ref)); + EXPECT_THAT(actual, Eq(ResourceNameRef({}, ResourceType::kColor, "foo"))); EXPECT_FALSE(create); EXPECT_FALSE(private_ref); } TEST(ResourceUtilsTest, ParseReferenceWithPackage) { - ResourceNameRef expected("android", ResourceType::kColor, "foo"); ResourceNameRef actual; bool create = false; bool private_ref = false; - EXPECT_TRUE(ResourceUtils::ParseReference("@android:color/foo", &actual, - &create, &private_ref)); - EXPECT_EQ(expected, actual); + EXPECT_TRUE(ResourceUtils::ParseReference("@android:color/foo", &actual, &create, &private_ref)); + EXPECT_THAT(actual, Eq(ResourceNameRef("android", ResourceType::kColor, "foo"))); EXPECT_FALSE(create); EXPECT_FALSE(private_ref); } TEST(ResourceUtilsTest, ParseReferenceWithSurroundingWhitespace) { - ResourceNameRef expected("android", ResourceType::kColor, "foo"); ResourceNameRef actual; bool create = false; bool private_ref = false; - EXPECT_TRUE(ResourceUtils::ParseReference("\t @android:color/foo\n \n\t", - &actual, &create, &private_ref)); - EXPECT_EQ(expected, actual); + EXPECT_TRUE(ResourceUtils::ParseReference("\t @android:color/foo\n \n\t", &actual, &create, &private_ref)); + EXPECT_THAT(actual, Eq(ResourceNameRef("android", ResourceType::kColor, "foo"))); EXPECT_FALSE(create); EXPECT_FALSE(private_ref); } TEST(ResourceUtilsTest, ParseAutoCreateIdReference) { - ResourceNameRef expected("android", ResourceType::kId, "foo"); ResourceNameRef actual; bool create = false; bool private_ref = false; - EXPECT_TRUE(ResourceUtils::ParseReference("@+android:id/foo", &actual, - &create, &private_ref)); - EXPECT_EQ(expected, actual); + EXPECT_TRUE(ResourceUtils::ParseReference("@+android:id/foo", &actual, &create, &private_ref)); + EXPECT_THAT(actual, Eq(ResourceNameRef("android", ResourceType::kId, "foo"))); EXPECT_TRUE(create); EXPECT_FALSE(private_ref); } TEST(ResourceUtilsTest, ParsePrivateReference) { - ResourceNameRef expected("android", ResourceType::kId, "foo"); ResourceNameRef actual; bool create = false; bool private_ref = false; - EXPECT_TRUE(ResourceUtils::ParseReference("@*android:id/foo", &actual, - &create, &private_ref)); - EXPECT_EQ(expected, actual); + EXPECT_TRUE(ResourceUtils::ParseReference("@*android:id/foo", &actual, &create, &private_ref)); + EXPECT_THAT(actual, Eq(ResourceNameRef("android", ResourceType::kId, "foo"))); EXPECT_FALSE(create); EXPECT_TRUE(private_ref); } @@ -118,8 +110,7 @@ TEST(ResourceUtilsTest, FailToParseAutoCreateNonIdReference) { bool create = false; bool private_ref = false; ResourceNameRef actual; - EXPECT_FALSE(ResourceUtils::ParseReference("@+android:color/foo", &actual, - &create, &private_ref)); + EXPECT_FALSE(ResourceUtils::ParseReference("@+android:color/foo", &actual, &create, &private_ref)); } TEST(ResourceUtilsTest, ParseAttributeReferences) { @@ -143,82 +134,69 @@ TEST(ResourceUtilsTest, FailParseIncompleteReference) { } TEST(ResourceUtilsTest, ParseStyleParentReference) { - const ResourceName kAndroidStyleFooName("android", ResourceType::kStyle, - "foo"); + const ResourceName kAndroidStyleFooName("android", ResourceType::kStyle, "foo"); const ResourceName kStyleFooName({}, ResourceType::kStyle, "foo"); std::string err_str; - Maybe<Reference> ref = - ResourceUtils::ParseStyleParentReference("@android:style/foo", &err_str); - AAPT_ASSERT_TRUE(ref); - EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName); + Maybe<Reference> ref = ResourceUtils::ParseStyleParentReference("@android:style/foo", &err_str); + ASSERT_TRUE(ref); + EXPECT_THAT(ref.value().name, Eq(make_value(kAndroidStyleFooName))); ref = ResourceUtils::ParseStyleParentReference("@style/foo", &err_str); - AAPT_ASSERT_TRUE(ref); - EXPECT_EQ(ref.value().name.value(), kStyleFooName); + ASSERT_TRUE(ref); + EXPECT_THAT(ref.value().name, Eq(make_value(kStyleFooName))); - ref = - ResourceUtils::ParseStyleParentReference("?android:style/foo", &err_str); - AAPT_ASSERT_TRUE(ref); - EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName); + ref = ResourceUtils::ParseStyleParentReference("?android:style/foo", &err_str); + ASSERT_TRUE(ref); + EXPECT_THAT(ref.value().name, Eq(make_value(kAndroidStyleFooName))); ref = ResourceUtils::ParseStyleParentReference("?style/foo", &err_str); - AAPT_ASSERT_TRUE(ref); - EXPECT_EQ(ref.value().name.value(), kStyleFooName); + ASSERT_TRUE(ref); + EXPECT_THAT(ref.value().name, Eq(make_value(kStyleFooName))); ref = ResourceUtils::ParseStyleParentReference("android:style/foo", &err_str); - AAPT_ASSERT_TRUE(ref); - EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName); + ASSERT_TRUE(ref); + EXPECT_THAT(ref.value().name, Eq(make_value(kAndroidStyleFooName))); ref = ResourceUtils::ParseStyleParentReference("android:foo", &err_str); - AAPT_ASSERT_TRUE(ref); - EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName); + ASSERT_TRUE(ref); + EXPECT_THAT(ref.value().name, Eq(make_value(kAndroidStyleFooName))); ref = ResourceUtils::ParseStyleParentReference("@android:foo", &err_str); - AAPT_ASSERT_TRUE(ref); - EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName); + ASSERT_TRUE(ref); + EXPECT_THAT(ref.value().name, Eq(make_value(kAndroidStyleFooName))); ref = ResourceUtils::ParseStyleParentReference("foo", &err_str); - AAPT_ASSERT_TRUE(ref); - EXPECT_EQ(ref.value().name.value(), kStyleFooName); + ASSERT_TRUE(ref); + EXPECT_THAT(ref.value().name, Eq(make_value(kStyleFooName))); - ref = - ResourceUtils::ParseStyleParentReference("*android:style/foo", &err_str); - AAPT_ASSERT_TRUE(ref); - EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName); + ref = ResourceUtils::ParseStyleParentReference("*android:style/foo", &err_str); + ASSERT_TRUE(ref); + EXPECT_THAT(ref.value().name, Eq(make_value(kAndroidStyleFooName))); EXPECT_TRUE(ref.value().private_reference); } TEST(ResourceUtilsTest, ParseEmptyFlag) { std::unique_ptr<Attribute> attr = test::AttributeBuilder(false) - .SetTypeMask(android::ResTable_map::TYPE_FLAGS) + .SetTypeMask(ResTable_map::TYPE_FLAGS) .AddItem("one", 0x01) .AddItem("two", 0x02) .Build(); - std::unique_ptr<BinaryPrimitive> result = - ResourceUtils::TryParseFlagSymbol(attr.get(), ""); - ASSERT_NE(nullptr, result); - EXPECT_EQ(0u, result->value.data); + std::unique_ptr<BinaryPrimitive> result = ResourceUtils::TryParseFlagSymbol(attr.get(), ""); + ASSERT_THAT(result, NotNull()); + EXPECT_THAT(result->value.data, Eq(0u)); } TEST(ResourceUtilsTest, NullIsEmptyReference) { - auto null_value = ResourceUtils::MakeNull(); - ASSERT_THAT(null_value, Pointee(ValueEq(Reference()))); - - auto value = ResourceUtils::TryParseNullOrEmpty("@null"); - ASSERT_THAT(value, Pointee(ValueEq(Reference()))); + ASSERT_THAT(ResourceUtils::MakeNull(), Pointee(ValueEq(Reference()))); + ASSERT_THAT(ResourceUtils::TryParseNullOrEmpty("@null"), Pointee(ValueEq(Reference()))); } TEST(ResourceUtilsTest, EmptyIsBinaryPrimitive) { - auto empty_value = ResourceUtils::MakeEmpty(); - ASSERT_THAT(empty_value, Pointee(ValueEq(BinaryPrimitive(android::Res_value::TYPE_NULL, - android::Res_value::DATA_NULL_EMPTY)))); - - auto value = ResourceUtils::TryParseNullOrEmpty("@empty"); - ASSERT_THAT(value, Pointee(ValueEq(BinaryPrimitive(android::Res_value::TYPE_NULL, - android::Res_value::DATA_NULL_EMPTY)))); + ASSERT_THAT(ResourceUtils::MakeEmpty(), Pointee(ValueEq(BinaryPrimitive(Res_value::TYPE_NULL, Res_value::DATA_NULL_EMPTY)))); + ASSERT_THAT(ResourceUtils::TryParseNullOrEmpty("@empty"), Pointee(ValueEq(BinaryPrimitive(Res_value::TYPE_NULL, Res_value::DATA_NULL_EMPTY)))); } } // namespace aapt diff --git a/tools/aapt2/ResourceValues.cpp b/tools/aapt2/ResourceValues.cpp index e808984c75f5..947e091e2d48 100644 --- a/tools/aapt2/ResourceValues.cpp +++ b/tools/aapt2/ResourceValues.cpp @@ -533,75 +533,119 @@ void Attribute::Print(std::ostream* out) const { } } -static void BuildAttributeMismatchMessage(DiagMessage* msg, - const Attribute* attr, - const Item* value) { - *msg << "expected"; - if (attr->type_mask & android::ResTable_map::TYPE_BOOLEAN) { - *msg << " boolean"; +static void BuildAttributeMismatchMessage(const Attribute& attr, const Item& value, + DiagMessage* out_msg) { + *out_msg << "expected"; + if (attr.type_mask & android::ResTable_map::TYPE_BOOLEAN) { + *out_msg << " boolean"; } - if (attr->type_mask & android::ResTable_map::TYPE_COLOR) { - *msg << " color"; + if (attr.type_mask & android::ResTable_map::TYPE_COLOR) { + *out_msg << " color"; } - if (attr->type_mask & android::ResTable_map::TYPE_DIMENSION) { - *msg << " dimension"; + if (attr.type_mask & android::ResTable_map::TYPE_DIMENSION) { + *out_msg << " dimension"; } - if (attr->type_mask & android::ResTable_map::TYPE_ENUM) { - *msg << " enum"; + if (attr.type_mask & android::ResTable_map::TYPE_ENUM) { + *out_msg << " enum"; } - if (attr->type_mask & android::ResTable_map::TYPE_FLAGS) { - *msg << " flags"; + if (attr.type_mask & android::ResTable_map::TYPE_FLAGS) { + *out_msg << " flags"; } - if (attr->type_mask & android::ResTable_map::TYPE_FLOAT) { - *msg << " float"; + if (attr.type_mask & android::ResTable_map::TYPE_FLOAT) { + *out_msg << " float"; } - if (attr->type_mask & android::ResTable_map::TYPE_FRACTION) { - *msg << " fraction"; + if (attr.type_mask & android::ResTable_map::TYPE_FRACTION) { + *out_msg << " fraction"; } - if (attr->type_mask & android::ResTable_map::TYPE_INTEGER) { - *msg << " integer"; + if (attr.type_mask & android::ResTable_map::TYPE_INTEGER) { + *out_msg << " integer"; } - if (attr->type_mask & android::ResTable_map::TYPE_REFERENCE) { - *msg << " reference"; + if (attr.type_mask & android::ResTable_map::TYPE_REFERENCE) { + *out_msg << " reference"; } - if (attr->type_mask & android::ResTable_map::TYPE_STRING) { - *msg << " string"; + if (attr.type_mask & android::ResTable_map::TYPE_STRING) { + *out_msg << " string"; } - *msg << " but got " << *value; + *out_msg << " but got " << value; } -bool Attribute::Matches(const Item* item, DiagMessage* out_msg) const { +bool Attribute::Matches(const Item& item, DiagMessage* out_msg) const { + constexpr const uint32_t TYPE_ENUM = android::ResTable_map::TYPE_ENUM; + constexpr const uint32_t TYPE_FLAGS = android::ResTable_map::TYPE_FLAGS; + constexpr const uint32_t TYPE_INTEGER = android::ResTable_map::TYPE_INTEGER; + constexpr const uint32_t TYPE_REFERENCE = android::ResTable_map::TYPE_REFERENCE; + android::Res_value val = {}; - item->Flatten(&val); + item.Flatten(&val); + + const uint32_t flattened_data = util::DeviceToHost32(val.data); // Always allow references. - const uint32_t mask = type_mask | android::ResTable_map::TYPE_REFERENCE; - if (!(mask & ResourceUtils::AndroidTypeToAttributeTypeMask(val.dataType))) { + const uint32_t actual_type = ResourceUtils::AndroidTypeToAttributeTypeMask(val.dataType); + + // Only one type must match between the actual and expected. + if ((actual_type & (type_mask | TYPE_REFERENCE)) == 0) { if (out_msg) { - BuildAttributeMismatchMessage(out_msg, this, item); + BuildAttributeMismatchMessage(*this, item, out_msg); } return false; + } + + // Enums and flags are encoded as integers, so check them first before doing any range checks. + if ((type_mask & TYPE_ENUM) != 0 && (actual_type & TYPE_ENUM) != 0) { + for (const Symbol& s : symbols) { + if (flattened_data == s.value) { + return true; + } + } + + // If the attribute accepts integers, we can't fail here. + if ((type_mask & TYPE_INTEGER) == 0) { + if (out_msg) { + *out_msg << item << " is not a valid enum"; + } + return false; + } + } + + if ((type_mask & TYPE_FLAGS) != 0 && (actual_type & TYPE_FLAGS) != 0) { + uint32_t mask = 0u; + for (const Symbol& s : symbols) { + mask |= s.value; + } + + // Check if the flattened data is covered by the flag bit mask. + // If the attribute accepts integers, we can't fail here. + if ((mask & flattened_data) == flattened_data) { + return true; + } else if ((type_mask & TYPE_INTEGER) == 0) { + if (out_msg) { + *out_msg << item << " is not a valid flag"; + } + return false; + } + } - } else if (ResourceUtils::AndroidTypeToAttributeTypeMask(val.dataType) & - android::ResTable_map::TYPE_INTEGER) { - if (static_cast<int32_t>(util::DeviceToHost32(val.data)) < min_int) { + // Finally check the integer range of the value. + if ((type_mask & TYPE_INTEGER) != 0 && (actual_type & TYPE_INTEGER) != 0) { + if (static_cast<int32_t>(flattened_data) < min_int) { if (out_msg) { - *out_msg << *item << " is less than minimum integer " << min_int; + *out_msg << item << " is less than minimum integer " << min_int; } return false; - } else if (static_cast<int32_t>(util::DeviceToHost32(val.data)) > max_int) { + } else if (static_cast<int32_t>(flattened_data) > max_int) { if (out_msg) { - *out_msg << *item << " is greater than maximum integer " << max_int; + *out_msg << item << " is greater than maximum integer " << max_int; } return false; } diff --git a/tools/aapt2/ResourceValues.h b/tools/aapt2/ResourceValues.h index ac5795fb9774..7e7547fc1b94 100644 --- a/tools/aapt2/ResourceValues.h +++ b/tools/aapt2/ResourceValues.h @@ -264,7 +264,7 @@ struct Attribute : public BaseValue<Attribute> { Attribute* Clone(StringPool* new_pool) const override; void PrintMask(std::ostream* out) const; void Print(std::ostream* out) const override; - bool Matches(const Item* item, DiagMessage* out_msg) const; + bool Matches(const Item& item, DiagMessage* out_msg = nullptr) const; }; struct Style : public BaseValue<Style> { diff --git a/tools/aapt2/ResourceValues_test.cpp b/tools/aapt2/ResourceValues_test.cpp index 69f8e67530f6..06c3404561de 100644 --- a/tools/aapt2/ResourceValues_test.cpp +++ b/tools/aapt2/ResourceValues_test.cpp @@ -190,4 +190,52 @@ TEST(ResourcesValuesTest, EmptyReferenceFlattens) { EXPECT_EQ(0x0u, value.data); } +TEST(ResourcesValuesTest, AttributeMatches) { + constexpr const uint32_t TYPE_DIMENSION = android::ResTable_map::TYPE_DIMENSION; + constexpr const uint32_t TYPE_ENUM = android::ResTable_map::TYPE_ENUM; + constexpr const uint32_t TYPE_FLAGS = android::ResTable_map::TYPE_FLAGS; + constexpr const uint32_t TYPE_INTEGER = android::ResTable_map::TYPE_INTEGER; + constexpr const uint8_t TYPE_INT_DEC = android::Res_value::TYPE_INT_DEC; + + Attribute attr1(false /*weak*/, TYPE_DIMENSION); + EXPECT_FALSE(attr1.Matches(*ResourceUtils::TryParseColor("#7fff00"))); + EXPECT_TRUE(attr1.Matches(*ResourceUtils::TryParseFloat("23dp"))); + EXPECT_TRUE(attr1.Matches(*ResourceUtils::TryParseReference("@android:string/foo"))); + + Attribute attr2(false /*weak*/, TYPE_INTEGER | TYPE_ENUM); + attr2.min_int = 0; + attr2.symbols.push_back(Attribute::Symbol{Reference(test::ParseNameOrDie("android:id/foo")), + static_cast<uint32_t>(-1)}); + EXPECT_FALSE(attr2.Matches(*ResourceUtils::TryParseColor("#7fff00"))); + EXPECT_TRUE(attr2.Matches(BinaryPrimitive(TYPE_INT_DEC, static_cast<uint32_t>(-1)))); + EXPECT_TRUE(attr2.Matches(BinaryPrimitive(TYPE_INT_DEC, 1u))); + EXPECT_FALSE(attr2.Matches(BinaryPrimitive(TYPE_INT_DEC, static_cast<uint32_t>(-2)))); + + Attribute attr3(false /*weak*/, TYPE_INTEGER | TYPE_FLAGS); + attr3.max_int = 100; + attr3.symbols.push_back( + Attribute::Symbol{Reference(test::ParseNameOrDie("android:id/foo")), 0x01u}); + attr3.symbols.push_back( + Attribute::Symbol{Reference(test::ParseNameOrDie("android:id/bar")), 0x02u}); + attr3.symbols.push_back( + Attribute::Symbol{Reference(test::ParseNameOrDie("android:id/baz")), 0x04u}); + attr3.symbols.push_back( + Attribute::Symbol{Reference(test::ParseNameOrDie("android:id/bat")), 0x80u}); + EXPECT_FALSE(attr3.Matches(*ResourceUtils::TryParseColor("#7fff00"))); + EXPECT_TRUE(attr3.Matches(BinaryPrimitive(TYPE_INT_DEC, 0x01u | 0x02u))); + EXPECT_TRUE(attr3.Matches(BinaryPrimitive(TYPE_INT_DEC, 0x01u | 0x02u | 0x80u))); + + // Not a flag, but a value less than max_int. + EXPECT_TRUE(attr3.Matches(BinaryPrimitive(TYPE_INT_DEC, 0x08u))); + + // Not a flag and greater than max_int. + EXPECT_FALSE(attr3.Matches(BinaryPrimitive(TYPE_INT_DEC, 127u))); + + Attribute attr4(false /*weak*/, TYPE_ENUM); + attr4.symbols.push_back( + Attribute::Symbol{Reference(test::ParseNameOrDie("android:id/foo")), 0x01u}); + EXPECT_TRUE(attr4.Matches(BinaryPrimitive(TYPE_INT_DEC, 0x01u))); + EXPECT_FALSE(attr4.Matches(BinaryPrimitive(TYPE_INT_DEC, 0x02u))); +} + } // namespace aapt diff --git a/tools/aapt2/cmd/Optimize.cpp b/tools/aapt2/cmd/Optimize.cpp index 194c0c80c2b2..9d71775889d4 100644 --- a/tools/aapt2/cmd/Optimize.cpp +++ b/tools/aapt2/cmd/Optimize.cpp @@ -17,6 +17,7 @@ #include <memory> #include <vector> +#include "android-base/stringprintf.h" #include "androidfw/StringPiece.h" #include "Diagnostics.h" @@ -26,6 +27,8 @@ #include "SdkConstants.h" #include "ValueVisitor.h" #include "cmd/Util.h" +#include "configuration/ConfigurationParser.h" +#include "filter/AbiFilter.h" #include "flatten/TableFlattener.h" #include "flatten/XmlFlattener.h" #include "io/BigBufferInputStream.h" @@ -33,14 +36,21 @@ #include "optimize/ResourceDeduper.h" #include "optimize/VersionCollapser.h" #include "split/TableSplitter.h" +#include "util/Files.h" -using android::StringPiece; +using ::aapt::configuration::Abi; +using ::aapt::configuration::Artifact; +using ::aapt::configuration::PostProcessingConfiguration; +using ::android::StringPiece; +using ::android::base::StringPrintf; namespace aapt { struct OptimizeOptions { // Path to the output APK. - std::string output_path; + Maybe<std::string> output_path; + // Path to the output APK directory for splits. + Maybe<std::string> output_dir; // Details of the app extracted from the AndroidManifest.xml AppInfo app_info; @@ -55,6 +65,8 @@ struct OptimizeOptions { std::vector<SplitConstraints> split_constraints; TableFlattenerOptions table_flattener_options; + + Maybe<PostProcessingConfiguration> configuration; }; class OptimizeContext : public IAaptContext { @@ -175,10 +187,52 @@ class OptimizeCommand { ++split_constraints_iter; } - std::unique_ptr<IArchiveWriter> writer = - CreateZipFileArchiveWriter(context_->GetDiagnostics(), options_.output_path); - if (!apk->WriteToArchive(context_, options_.table_flattener_options, writer.get())) { - return 1; + if (options_.configuration && options_.output_dir) { + PostProcessingConfiguration& config = options_.configuration.value(); + + // For now, just write out the stripped APK since ABI splitting doesn't modify anything else. + for (const Artifact& artifact : config.artifacts) { + if (artifact.abi_group) { + const std::string& group = artifact.abi_group.value(); + + auto abi_group = config.abi_groups.find(group); + // TODO: Remove validation when configuration parser ensures referential integrity. + if (abi_group == config.abi_groups.end()) { + context_->GetDiagnostics()->Note( + DiagMessage() << "could not find referenced ABI group '" << group << "'"); + return 1; + } + FilterChain filters; + filters.AddFilter(AbiFilter::FromAbiList(abi_group->second)); + + const std::string& path = apk->GetSource().path; + const StringPiece ext = file::GetExtension(path); + const std::string name = path.substr(0, path.rfind(ext.to_string())); + + // Name is hard coded for now since only one split dimension is supported. + // TODO: Incorporate name generation into the configuration objects. + const std::string file_name = + StringPrintf("%s.%s%s", name.c_str(), group.c_str(), ext.data()); + std::string out = options_.output_dir.value(); + file::AppendPath(&out, file_name); + + std::unique_ptr<IArchiveWriter> writer = + CreateZipFileArchiveWriter(context_->GetDiagnostics(), out); + + if (!apk->WriteToArchive(context_, options_.table_flattener_options, &filters, + writer.get())) { + return 1; + } + } + } + } + + if (options_.output_path) { + std::unique_ptr<IArchiveWriter> writer = + CreateZipFileArchiveWriter(context_->GetDiagnostics(), options_.output_path.value()); + if (!apk->WriteToArchive(context_, options_.table_flattener_options, writer.get())) { + return 1; + } } return 0; @@ -214,8 +268,8 @@ class OptimizeCommand { if (file_ref->file == nullptr) { ResourceNameRef name(pkg->name, type->type, entry->name); context_->GetDiagnostics()->Warn(DiagMessage(file_ref->GetSource()) - << "file for resource " << name << " with config '" - << config_value->config << "' not found"); + << "file for resource " << name << " with config '" + << config_value->config << "' not found"); continue; } @@ -293,13 +347,16 @@ bool ExtractAppDataFromManifest(OptimizeContext* context, LoadedApk* apk, int Optimize(const std::vector<StringPiece>& args) { OptimizeContext context; OptimizeOptions options; + Maybe<std::string> config_path; Maybe<std::string> target_densities; std::vector<std::string> configs; std::vector<std::string> split_args; bool verbose = false; Flags flags = Flags() - .RequiredFlag("-o", "Path to the output APK.", &options.output_path) + .OptionalFlag("-o", "Path to the output APK.", &options.output_path) + .OptionalFlag("-d", "Path to the output directory (for splits).", &options.output_dir) + .OptionalFlag("-x", "Path to XML configuration file.", &config_path) .OptionalFlag( "--target-densities", "Comma separated list of the screen densities that the APK will be optimized for.\n" @@ -369,6 +426,22 @@ int Optimize(const std::vector<StringPiece>& args) { } } + if (config_path) { + if (!options.output_dir) { + context.GetDiagnostics()->Error( + DiagMessage() << "Output directory is required when using a configuration file"); + return 1; + } + std::string& path = config_path.value(); + Maybe<ConfigurationParser> for_path = ConfigurationParser::ForPath(path); + if (for_path) { + options.configuration = for_path.value().WithDiagnostics(context.GetDiagnostics()).Parse(); + } else { + context.GetDiagnostics()->Error(DiagMessage() << "Could not parse config file " << path); + return 1; + } + } + if (!ExtractAppDataFromManifest(&context, apk.get(), &options)) { return 1; } diff --git a/tools/aapt2/compile/IdAssigner_test.cpp b/tools/aapt2/compile/IdAssigner_test.cpp index d465091d224e..5cff0048c062 100644 --- a/tools/aapt2/compile/IdAssigner_test.cpp +++ b/tools/aapt2/compile/IdAssigner_test.cpp @@ -64,12 +64,12 @@ TEST(IdAssignerTest, AssignIdsWithReservedIds) { // Expect to fill in the gaps between 0x0101XXXX and 0x0104XXXX. maybe_result = table->FindResource(test::ParseNameOrDie("android:dimen/two")); - AAPT_ASSERT_TRUE(maybe_result); + ASSERT_TRUE(maybe_result); EXPECT_EQ(make_value<uint8_t>(2), maybe_result.value().type->id); maybe_result = table->FindResource(test::ParseNameOrDie("android:integer/three")); - AAPT_ASSERT_TRUE(maybe_result); + ASSERT_TRUE(maybe_result); EXPECT_EQ(make_value<uint8_t>(3), maybe_result.value().type->id); // Expect to bypass the reserved 0x0104XXXX IDs and use the next 0x0105XXXX @@ -77,17 +77,17 @@ TEST(IdAssignerTest, AssignIdsWithReservedIds) { maybe_result = table->FindResource(test::ParseNameOrDie("android:string/five")); - AAPT_ASSERT_TRUE(maybe_result); + ASSERT_TRUE(maybe_result); EXPECT_EQ(make_value<uint8_t>(5), maybe_result.value().type->id); // Expect to fill in the gaps between 0x01040000 and 0x01040006. maybe_result = table->FindResource(test::ParseNameOrDie("android:attr/bar")); - AAPT_ASSERT_TRUE(maybe_result); + ASSERT_TRUE(maybe_result); EXPECT_EQ(make_value<uint16_t>(1), maybe_result.value().entry->id); maybe_result = table->FindResource(test::ParseNameOrDie("android:attr/baz")); - AAPT_ASSERT_TRUE(maybe_result); + ASSERT_TRUE(maybe_result); EXPECT_EQ(make_value<uint16_t>(2), maybe_result.value().entry->id); } @@ -121,7 +121,7 @@ TEST(IdAssignerTest, AssignIdsWithIdMap) { ASSERT_TRUE(VerifyIds(table.get())); Maybe<ResourceTable::SearchResult> result = table->FindResource(test::ParseNameOrDie("android:attr/foo")); - AAPT_ASSERT_TRUE(result); + ASSERT_TRUE(result); const ResourceTable::SearchResult& search_result = result.value(); EXPECT_EQ(make_value<uint8_t>(0x01), search_result.package->id); diff --git a/tools/aapt2/configuration/ConfigurationParser.cpp b/tools/aapt2/configuration/ConfigurationParser.cpp index 89618d3a4676..0b6743c4c3b6 100644 --- a/tools/aapt2/configuration/ConfigurationParser.cpp +++ b/tools/aapt2/configuration/ConfigurationParser.cpp @@ -18,13 +18,17 @@ #include <algorithm> #include <functional> +#include <map> #include <memory> #include <utility> +#include <android-base/file.h> #include <android-base/logging.h> #include "ConfigDescription.h" #include "Diagnostics.h" +#include "io/File.h" +#include "io/FileSystem.h" #include "util/Util.h" #include "xml/XmlActionExecutor.h" #include "xml/XmlDom.h" @@ -38,10 +42,12 @@ using ::aapt::configuration::Abi; using ::aapt::configuration::AndroidManifest; using ::aapt::configuration::AndroidSdk; using ::aapt::configuration::Artifact; -using ::aapt::configuration::Configuration; +using ::aapt::configuration::PostProcessingConfiguration; using ::aapt::configuration::GlTexture; using ::aapt::configuration::Group; using ::aapt::configuration::Locale; +using ::aapt::io::IFile; +using ::aapt::io::RegularFile; using ::aapt::util::TrimWhitespace; using ::aapt::xml::Element; using ::aapt::xml::FindRootElement; @@ -49,16 +55,17 @@ using ::aapt::xml::NodeCast; using ::aapt::xml::XmlActionExecutor; using ::aapt::xml::XmlActionExecutorPolicy; using ::aapt::xml::XmlNodeAction; +using ::android::base::ReadFileToString; -const std::unordered_map<std::string, Abi> kAbiMap = { - {"armeabi", Abi::kArmeV6}, - {"armeabi-v7a", Abi::kArmV7a}, - {"arm64-v8a", Abi::kArm64V8a}, - {"x86", Abi::kX86}, - {"x86_64", Abi::kX86_64}, - {"mips", Abi::kMips}, - {"mips64", Abi::kMips64}, - {"universal", Abi::kUniversal}, +const std::unordered_map<std::string, Abi> kStringToAbiMap = { + {"armeabi", Abi::kArmeV6}, {"armeabi-v7a", Abi::kArmV7a}, {"arm64-v8a", Abi::kArm64V8a}, + {"x86", Abi::kX86}, {"x86_64", Abi::kX86_64}, {"mips", Abi::kMips}, + {"mips64", Abi::kMips64}, {"universal", Abi::kUniversal}, +}; +const std::map<Abi, std::string> kAbiToStringMap = { + {Abi::kArmeV6, "armeabi"}, {Abi::kArmV7a, "armeabi-v7a"}, {Abi::kArm64V8a, "arm64-v8a"}, + {Abi::kX86, "x86"}, {Abi::kX86_64, "x86_64"}, {Abi::kMips, "mips"}, + {Abi::kMips64, "mips64"}, {Abi::kUniversal, "universal"}, }; constexpr const char* kAaptXmlNs = "http://schemas.android.com/tools/aapt"; @@ -96,12 +103,29 @@ class NamespaceVisitor : public xml::Visitor { } // namespace +namespace configuration { + +const std::string& AbiToString(Abi abi) { + return kAbiToStringMap.find(abi)->second; +} + +} // namespace configuration + +/** Returns a ConfigurationParser for the file located at the provided path. */ +Maybe<ConfigurationParser> ConfigurationParser::ForPath(const std::string& path) { + std::string contents; + if (!ReadFileToString(path, &contents, true)) { + return {}; + } + return ConfigurationParser(contents); +} + ConfigurationParser::ConfigurationParser(std::string contents) : contents_(std::move(contents)), diag_(&noop_) { } -Maybe<Configuration> ConfigurationParser::Parse() { +Maybe<PostProcessingConfiguration> ConfigurationParser::Parse() { std::istringstream in(contents_); auto doc = xml::Inflate(&in, diag_, Source("config.xml")); @@ -133,10 +157,11 @@ Maybe<Configuration> ConfigurationParser::Parse() { XmlNodeAction& artifacts_action = root_action["artifacts"]; XmlNodeAction& groups_action = root_action["groups"]; - Configuration config; + PostProcessingConfiguration config; // Helper to bind a static method to an action handler in the DOM executor. - auto bind_handler = [&config](std::function<bool(Configuration*, Element*, IDiagnostics*)> h) + auto bind_handler = + [&config](std::function<bool(PostProcessingConfiguration*, Element*, IDiagnostics*)> h) -> XmlNodeAction::ActionFuncWithDiag { return std::bind(h, &config, std::placeholders::_1, std::placeholders::_2); }; @@ -158,275 +183,266 @@ Maybe<Configuration> ConfigurationParser::Parse() { return {}; } + // TODO: Validate all references in the configuration are valid. It should be safe to assume from + // this point on that any references from one section to another will be present. + return {config}; } ConfigurationParser::ActionHandler ConfigurationParser::artifact_handler_ = - [](Configuration* config, Element* root_element, IDiagnostics* diag) -> bool { - Artifact artifact{}; - for (const auto& attr : root_element->attributes) { - if (attr.name == "name") { - artifact.name = attr.value; - } else if (attr.name == "abi-group") { - artifact.abi_group = {attr.value}; - } else if (attr.name == "screen-density-group") { - artifact.screen_density_group = {attr.value}; - } else if (attr.name == "locale-group") { - artifact.locale_group = {attr.value}; - } else if (attr.name == "android-sdk-group") { - artifact.android_sdk_group = {attr.value}; - } else if (attr.name == "gl-texture-group") { - artifact.gl_texture_group = {attr.value}; - } else if (attr.name == "device-feature-group") { - artifact.device_feature_group = {attr.value}; - } else { - diag->Note( - DiagMessage() << "Unknown artifact attribute: " << attr.name << " = " << attr.value); - } - } - config->artifacts[artifact.name] = artifact; - return true; - }; + [](PostProcessingConfiguration* config, Element* root_element, IDiagnostics* diag) -> bool { + Artifact artifact{}; + for (const auto& attr : root_element->attributes) { + if (attr.name == "name") { + artifact.name = attr.value; + } else if (attr.name == "abi-group") { + artifact.abi_group = {attr.value}; + } else if (attr.name == "screen-density-group") { + artifact.screen_density_group = {attr.value}; + } else if (attr.name == "locale-group") { + artifact.locale_group = {attr.value}; + } else if (attr.name == "android-sdk-group") { + artifact.android_sdk_group = {attr.value}; + } else if (attr.name == "gl-texture-group") { + artifact.gl_texture_group = {attr.value}; + } else if (attr.name == "device-feature-group") { + artifact.device_feature_group = {attr.value}; + } else { + diag->Note(DiagMessage() << "Unknown artifact attribute: " << attr.name << " = " + << attr.value); + } + } + config->artifacts.push_back(artifact); + return true; +}; ConfigurationParser::ActionHandler ConfigurationParser::artifact_format_handler_ = - [](Configuration* config, Element* root_element, IDiagnostics* diag) -> bool { - for (auto& node : root_element->children) { - xml::Text* t; - if ((t = NodeCast<xml::Text>(node.get())) != nullptr) { - config->artifact_format = TrimWhitespace(t->text).to_string(); - break; - } - } - return true; - }; + [](PostProcessingConfiguration* config, Element* root_element, IDiagnostics* diag) -> bool { + for (auto& node : root_element->children) { + xml::Text* t; + if ((t = NodeCast<xml::Text>(node.get())) != nullptr) { + config->artifact_format = TrimWhitespace(t->text).to_string(); + break; + } + } + return true; +}; ConfigurationParser::ActionHandler ConfigurationParser::abi_group_handler_ = - [](Configuration* config, Element* root_element, IDiagnostics* diag) -> bool { - std::string label = GetLabel(root_element, diag); - if (label.empty()) { - return false; - } + [](PostProcessingConfiguration* config, Element* root_element, IDiagnostics* diag) -> bool { + std::string label = GetLabel(root_element, diag); + if (label.empty()) { + return false; + } - auto& group = config->abi_groups[label]; - bool valid = true; + auto& group = config->abi_groups[label]; + bool valid = true; - for (auto* child : root_element->GetChildElements()) { - if (child->name != "abi") { - diag->Error( - DiagMessage() << "Unexpected element in ABI group: " << child->name); - valid = false; - } else { - for (auto& node : child->children) { - xml::Text* t; - if ((t = NodeCast<xml::Text>(node.get())) != nullptr) { - group.push_back(kAbiMap.at(TrimWhitespace(t->text).to_string())); - break; - } - } + for (auto* child : root_element->GetChildElements()) { + if (child->name != "abi") { + diag->Error(DiagMessage() << "Unexpected element in ABI group: " << child->name); + valid = false; + } else { + for (auto& node : child->children) { + xml::Text* t; + if ((t = NodeCast<xml::Text>(node.get())) != nullptr) { + group.push_back(kStringToAbiMap.at(TrimWhitespace(t->text).to_string())); + break; } } + } + } - return valid; - }; + return valid; +}; ConfigurationParser::ActionHandler ConfigurationParser::screen_density_group_handler_ = - [](Configuration* config, Element* root_element, IDiagnostics* diag) -> bool { - std::string label = GetLabel(root_element, diag); - if (label.empty()) { - return false; - } + [](PostProcessingConfiguration* config, Element* root_element, IDiagnostics* diag) -> bool { + std::string label = GetLabel(root_element, diag); + if (label.empty()) { + return false; + } - auto& group = config->screen_density_groups[label]; - bool valid = true; + auto& group = config->screen_density_groups[label]; + bool valid = true; - for (auto* child : root_element->GetChildElements()) { - if (child->name != "screen-density") { - diag->Error( - DiagMessage() << "Unexpected root_element in screen density group: " - << child->name); - valid = false; - } else { - for (auto& node : child->children) { - xml::Text* t; - if ((t = NodeCast<xml::Text>(node.get())) != nullptr) { - ConfigDescription config_descriptor; - const android::StringPiece& text = TrimWhitespace(t->text); - if (ConfigDescription::Parse(text, &config_descriptor)) { - // Copy the density with the minimum SDK version stripped out. - group.push_back(config_descriptor.CopyWithoutSdkVersion()); - } else { - diag->Error( - DiagMessage() << "Could not parse config descriptor for screen-density: " - << text); - valid = false; - } - break; - } + for (auto* child : root_element->GetChildElements()) { + if (child->name != "screen-density") { + diag->Error(DiagMessage() << "Unexpected root_element in screen density group: " + << child->name); + valid = false; + } else { + for (auto& node : child->children) { + xml::Text* t; + if ((t = NodeCast<xml::Text>(node.get())) != nullptr) { + ConfigDescription config_descriptor; + const android::StringPiece& text = TrimWhitespace(t->text); + if (ConfigDescription::Parse(text, &config_descriptor)) { + // Copy the density with the minimum SDK version stripped out. + group.push_back(config_descriptor.CopyWithoutSdkVersion()); + } else { + diag->Error(DiagMessage() + << "Could not parse config descriptor for screen-density: " << text); + valid = false; } + break; } } + } + } - return valid; - }; + return valid; +}; ConfigurationParser::ActionHandler ConfigurationParser::locale_group_handler_ = - [](Configuration* config, Element* root_element, IDiagnostics* diag) -> bool { - std::string label = GetLabel(root_element, diag); - if (label.empty()) { - return false; - } + [](PostProcessingConfiguration* config, Element* root_element, IDiagnostics* diag) -> bool { + std::string label = GetLabel(root_element, diag); + if (label.empty()) { + return false; + } - auto& group = config->locale_groups[label]; - bool valid = true; + auto& group = config->locale_groups[label]; + bool valid = true; - for (auto* child : root_element->GetChildElements()) { - if (child->name != "locale") { - diag->Error( - DiagMessage() << "Unexpected root_element in screen density group: " - << child->name); - valid = false; + for (auto* child : root_element->GetChildElements()) { + if (child->name != "locale") { + diag->Error(DiagMessage() << "Unexpected root_element in screen density group: " + << child->name); + valid = false; + } else { + Locale entry; + for (const auto& attr : child->attributes) { + if (attr.name == "lang") { + entry.lang = {attr.value}; + } else if (attr.name == "region") { + entry.region = {attr.value}; } else { - Locale entry; - for (const auto& attr : child->attributes) { - if (attr.name == "lang") { - entry.lang = {attr.value}; - } else if (attr.name == "region") { - entry.region = {attr.value}; - } else { - diag->Warn(DiagMessage() << "Unknown attribute: " << attr.name - << " = " << attr.value); - } - } - group.push_back(entry); + diag->Warn(DiagMessage() << "Unknown attribute: " << attr.name << " = " << attr.value); } } + group.push_back(entry); + } + } - return valid; - }; + return valid; +}; ConfigurationParser::ActionHandler ConfigurationParser::android_sdk_group_handler_ = - [](Configuration* config, Element* root_element, IDiagnostics* diag) -> bool { - std::string label = GetLabel(root_element, diag); - if (label.empty()) { - return false; - } - - auto& group = config->android_sdk_groups[label]; - bool valid = true; + [](PostProcessingConfiguration* config, Element* root_element, IDiagnostics* diag) -> bool { + std::string label = GetLabel(root_element, diag); + if (label.empty()) { + return false; + } - for (auto* child : root_element->GetChildElements()) { - if (child->name != "android-sdk") { - diag->Error( - DiagMessage() << "Unexpected root_element in ABI group: " << child->name); - valid = false; + auto& group = config->android_sdk_groups[label]; + bool valid = true; + + for (auto* child : root_element->GetChildElements()) { + if (child->name != "android-sdk") { + diag->Error(DiagMessage() << "Unexpected root_element in ABI group: " << child->name); + valid = false; + } else { + AndroidSdk entry; + for (const auto& attr : child->attributes) { + if (attr.name == "minSdkVersion") { + entry.min_sdk_version = {attr.value}; + } else if (attr.name == "targetSdkVersion") { + entry.target_sdk_version = {attr.value}; + } else if (attr.name == "maxSdkVersion") { + entry.max_sdk_version = {attr.value}; } else { - AndroidSdk entry; - for (const auto& attr : child->attributes) { - if (attr.name == "minSdkVersion") { - entry.min_sdk_version = {attr.value}; - } else if (attr.name == "targetSdkVersion") { - entry.target_sdk_version = {attr.value}; - } else if (attr.name == "maxSdkVersion") { - entry.max_sdk_version = {attr.value}; - } else { - diag->Warn(DiagMessage() << "Unknown attribute: " << attr.name - << " = " << attr.value); - } - } + diag->Warn(DiagMessage() << "Unknown attribute: " << attr.name << " = " << attr.value); + } + } - // TODO: Fill in the manifest details when they are finalised. - for (auto node : child->GetChildElements()) { - if (node->name == "manifest") { - if (entry.manifest) { - diag->Warn(DiagMessage() << "Found multiple manifest tags. Ignoring duplicates."); - continue; - } - entry.manifest = {AndroidManifest()}; - } + // TODO: Fill in the manifest details when they are finalised. + for (auto node : child->GetChildElements()) { + if (node->name == "manifest") { + if (entry.manifest) { + diag->Warn(DiagMessage() << "Found multiple manifest tags. Ignoring duplicates."); + continue; } - - group.push_back(entry); + entry.manifest = {AndroidManifest()}; } } - return valid; - }; + group.push_back(entry); + } + } + + return valid; +}; ConfigurationParser::ActionHandler ConfigurationParser::gl_texture_group_handler_ = - [](Configuration* config, Element* root_element, IDiagnostics* diag) -> bool { - std::string label = GetLabel(root_element, diag); - if (label.empty()) { - return false; - } + [](PostProcessingConfiguration* config, Element* root_element, IDiagnostics* diag) -> bool { + std::string label = GetLabel(root_element, diag); + if (label.empty()) { + return false; + } - auto& group = config->gl_texture_groups[label]; - bool valid = true; + auto& group = config->gl_texture_groups[label]; + bool valid = true; - GlTexture result; - for (auto* child : root_element->GetChildElements()) { - if (child->name != "gl-texture") { - diag->Error( - DiagMessage() << "Unexpected element in GL texture group: " - << child->name); - valid = false; - } else { - for (const auto& attr : child->attributes) { - if (attr.name == "name") { - result.name = attr.value; - break; - } - } + GlTexture result; + for (auto* child : root_element->GetChildElements()) { + if (child->name != "gl-texture") { + diag->Error(DiagMessage() << "Unexpected element in GL texture group: " << child->name); + valid = false; + } else { + for (const auto& attr : child->attributes) { + if (attr.name == "name") { + result.name = attr.value; + break; + } + } - for (auto* element : child->GetChildElements()) { - if (element->name != "texture-path") { - diag->Error( - DiagMessage() << "Unexpected element in gl-texture element: " - << child->name); - valid = false; - continue; - } - for (auto& node : element->children) { - xml::Text* t; - if ((t = NodeCast<xml::Text>(node.get())) != nullptr) { - result.texture_paths.push_back(TrimWhitespace(t->text).to_string()); - } - } + for (auto* element : child->GetChildElements()) { + if (element->name != "texture-path") { + diag->Error(DiagMessage() << "Unexpected element in gl-texture element: " << child->name); + valid = false; + continue; + } + for (auto& node : element->children) { + xml::Text* t; + if ((t = NodeCast<xml::Text>(node.get())) != nullptr) { + result.texture_paths.push_back(TrimWhitespace(t->text).to_string()); } } - group.push_back(result); } + } + group.push_back(result); + } - return valid; - }; + return valid; +}; ConfigurationParser::ActionHandler ConfigurationParser::device_feature_group_handler_ = - [](Configuration* config, Element* root_element, IDiagnostics* diag) -> bool { - std::string label = GetLabel(root_element, diag); - if (label.empty()) { - return false; - } + [](PostProcessingConfiguration* config, Element* root_element, IDiagnostics* diag) -> bool { + std::string label = GetLabel(root_element, diag); + if (label.empty()) { + return false; + } - auto& group = config->device_feature_groups[label]; - bool valid = true; + auto& group = config->device_feature_groups[label]; + bool valid = true; - for (auto* child : root_element->GetChildElements()) { - if (child->name != "supports-feature") { - diag->Error( - DiagMessage() << "Unexpected root_element in device feature group: " - << child->name); - valid = false; - } else { - for (auto& node : child->children) { - xml::Text* t; - if ((t = NodeCast<xml::Text>(node.get())) != nullptr) { - group.push_back(TrimWhitespace(t->text).to_string()); - break; - } - } + for (auto* child : root_element->GetChildElements()) { + if (child->name != "supports-feature") { + diag->Error(DiagMessage() << "Unexpected root_element in device feature group: " + << child->name); + valid = false; + } else { + for (auto& node : child->children) { + xml::Text* t; + if ((t = NodeCast<xml::Text>(node.get())) != nullptr) { + group.push_back(TrimWhitespace(t->text).to_string()); + break; } } + } + } - return valid; - }; + return valid; +}; } // namespace aapt diff --git a/tools/aapt2/configuration/ConfigurationParser.h b/tools/aapt2/configuration/ConfigurationParser.h index 0fb2f714a76c..3fae5dd0a990 100644 --- a/tools/aapt2/configuration/ConfigurationParser.h +++ b/tools/aapt2/configuration/ConfigurationParser.h @@ -62,6 +62,9 @@ enum class Abi { kUniversal }; +/** Helper method to convert an ABI to a string representing the path within the APK. */ +const std::string& AbiToString(Abi abi); + /** * Represents an individual locale. When a locale is included, it must be * declared from least specific to most specific, as a region does not make @@ -114,11 +117,10 @@ struct GlTexture { } }; -/** - * AAPT2 XML configuration binary representation. - */ -struct Configuration { - std::unordered_map<std::string, Artifact> artifacts; +/** AAPT2 XML configuration file binary representation. */ +struct PostProcessingConfiguration { + // TODO: Support named artifacts? + std::vector<Artifact> artifacts; Maybe<std::string> artifact_format; Group<Abi> abi_groups; @@ -142,18 +144,16 @@ class Element; */ class ConfigurationParser { public: + + /** Returns a ConfigurationParser for the file located at the provided path. */ + static Maybe<ConfigurationParser> ForPath(const std::string& path); + /** Returns a ConfigurationParser for the configuration in the provided file contents. */ static ConfigurationParser ForContents(const std::string& contents) { ConfigurationParser parser{contents}; return parser; } - /** Returns a ConfigurationParser for the file located at the provided path. */ - static ConfigurationParser ForPath(const std::string& path) { - // TODO: Read XML file into memory. - return ForContents(path); - } - /** Sets the diagnostics context to use when parsing. */ ConfigurationParser& WithDiagnostics(IDiagnostics* diagnostics) { diag_ = diagnostics; @@ -164,7 +164,7 @@ class ConfigurationParser { * Parses the configuration file and returns the results. If the configuration could not be parsed * the result is empty and any errors will be displayed with the provided diagnostics context. */ - Maybe<configuration::Configuration> Parse(); + Maybe<configuration::PostProcessingConfiguration> Parse(); protected: /** @@ -183,9 +183,8 @@ class ConfigurationParser { * An ActionHandler for processing XML elements in the XmlActionExecutor. Returns true if the * element was successfully processed, otherwise returns false. */ - using ActionHandler = std::function<bool(configuration::Configuration* config, - xml::Element* element, - IDiagnostics* diag)>; + using ActionHandler = std::function<bool(configuration::PostProcessingConfiguration* config, + xml::Element* element, IDiagnostics* diag)>; /** Handler for <artifact> tags. */ static ActionHandler artifact_handler_; diff --git a/tools/aapt2/configuration/ConfigurationParser_test.cpp b/tools/aapt2/configuration/ConfigurationParser_test.cpp index 72a97b273cb0..a4fa1344cb3b 100644 --- a/tools/aapt2/configuration/ConfigurationParser_test.cpp +++ b/tools/aapt2/configuration/ConfigurationParser_test.cpp @@ -32,7 +32,7 @@ namespace { using android::ResTable_config; using configuration::Abi; using configuration::AndroidSdk; -using configuration::Configuration; +using configuration::PostProcessingConfiguration; using configuration::DeviceFeature; using configuration::GlTexture; using configuration::Locale; @@ -130,11 +130,16 @@ class ConfigurationParserTest : public ConfigurationParser, public ::testing::Te StdErrDiagnostics diag_; }; +TEST_F(ConfigurationParserTest, ForPath_NoFile) { + auto result = ConfigurationParser::ForPath("./does_not_exist.xml"); + EXPECT_FALSE(result); +} + TEST_F(ConfigurationParserTest, ValidateFile) { auto parser = ConfigurationParser::ForContents(kValidConfig).WithDiagnostics(&diag_); auto result = parser.Parse(); ASSERT_TRUE(result); - Configuration& value = result.value(); + PostProcessingConfiguration& value = result.value(); EXPECT_EQ(2ul, value.artifacts.size()); ASSERT_TRUE(value.artifact_format); EXPECT_EQ( @@ -185,13 +190,13 @@ TEST_F(ConfigurationParserTest, ArtifactAction) { auto doc = test::BuildXmlDom(xml); - Configuration config; + PostProcessingConfiguration config; bool ok = artifact_handler_(&config, NodeCast<Element>(doc.get()->root.get()), &diag_); ASSERT_TRUE(ok); EXPECT_EQ(1ul, config.artifacts.size()); - auto& artifact = config.artifacts.begin()->second; + auto& artifact = config.artifacts.front(); EXPECT_EQ("", artifact.name); // TODO: make this fail. EXPECT_EQ("arm", artifact.abi_group.value()); EXPECT_EQ("large", artifact.screen_density_group.value()); @@ -199,6 +204,21 @@ TEST_F(ConfigurationParserTest, ArtifactAction) { EXPECT_EQ("19", artifact.android_sdk_group.value()); EXPECT_EQ("dxt1", artifact.gl_texture_group.value()); EXPECT_EQ("low-latency", artifact.device_feature_group.value()); + + // Perform a second action to ensure we get 2 artifacts. + static constexpr const char* second = R"xml( + <artifact + abi-group="other" + screen-density-group="large" + locale-group="europe" + android-sdk-group="19" + gl-texture-group="dxt1" + device-feature-group="low-latency"/>)xml"; + doc = test::BuildXmlDom(second); + + ok = artifact_handler_(&config, NodeCast<Element>(doc.get()->root.get()), &diag_); + ASSERT_TRUE(ok); + EXPECT_EQ(2ul, config.artifacts.size()); } TEST_F(ConfigurationParserTest, ArtifactFormatAction) { @@ -209,7 +229,7 @@ TEST_F(ConfigurationParserTest, ArtifactFormatAction) { auto doc = test::BuildXmlDom(xml); - Configuration config; + PostProcessingConfiguration config; bool ok = artifact_format_handler_(&config, NodeCast<Element>(doc.get()->root.get()), &diag_); ASSERT_TRUE(ok); ASSERT_TRUE(config.artifact_format); @@ -232,7 +252,7 @@ TEST_F(ConfigurationParserTest, AbiGroupAction) { auto doc = test::BuildXmlDom(xml); - Configuration config; + PostProcessingConfiguration config; bool ok = abi_group_handler_(&config, NodeCast<Element>(doc.get()->root.get()), &diag_); ASSERT_TRUE(ok); @@ -255,7 +275,7 @@ TEST_F(ConfigurationParserTest, ScreenDensityGroupAction) { auto doc = test::BuildXmlDom(xml); - Configuration config; + PostProcessingConfiguration config; bool ok = screen_density_group_handler_(&config, NodeCast<Element>(doc.get()->root.get()), &diag_); ASSERT_TRUE(ok); @@ -285,7 +305,7 @@ TEST_F(ConfigurationParserTest, LocaleGroupAction) { auto doc = test::BuildXmlDom(xml); - Configuration config; + PostProcessingConfiguration config; bool ok = locale_group_handler_(&config, NodeCast<Element>(doc.get()->root.get()), &diag_); ASSERT_TRUE(ok); @@ -321,7 +341,7 @@ TEST_F(ConfigurationParserTest, AndroidSdkGroupAction) { auto doc = test::BuildXmlDom(xml); - Configuration config; + PostProcessingConfiguration config; bool ok = android_sdk_group_handler_(&config, NodeCast<Element>(doc.get()->root.get()), &diag_); ASSERT_TRUE(ok); @@ -353,7 +373,7 @@ TEST_F(ConfigurationParserTest, GlTextureGroupAction) { auto doc = test::BuildXmlDom(xml); - Configuration config; + PostProcessingConfiguration config; bool ok = gl_texture_group_handler_(&config, NodeCast<Element>(doc.get()->root.get()), &diag_); ASSERT_TRUE(ok); @@ -382,7 +402,7 @@ TEST_F(ConfigurationParserTest, DeviceFeatureGroupAction) { auto doc = test::BuildXmlDom(xml); - Configuration config; + PostProcessingConfiguration config; bool ok = device_feature_group_handler_(&config, NodeCast<Element>(doc.get()->root.get()), &diag_); ASSERT_TRUE(ok); diff --git a/tools/aapt2/configuration/example/config.xml b/tools/aapt2/configuration/example/config.xml index a8360f870b71..ce31e61b2d62 100644 --- a/tools/aapt2/configuration/example/config.xml +++ b/tools/aapt2/configuration/example/config.xml @@ -1,5 +1,5 @@ <?xml version="1.0" encoding="utf-8" ?> -<post-process xmlns="http://schemas.android.com/tools/aapt2"> +<post-process xmlns="http://schemas.android.com/tools/aapt"> <groups> <abi-group label="arm"> <abi>armeabi-v7a</abi> diff --git a/tools/aapt2/filter/AbiFilter.cpp b/tools/aapt2/filter/AbiFilter.cpp new file mode 100644 index 000000000000..cb96235f98f9 --- /dev/null +++ b/tools/aapt2/filter/AbiFilter.cpp @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "AbiFilter.h" + +#include <memory> + +#include "io/Util.h" + +namespace aapt { + +std::unique_ptr<AbiFilter> AbiFilter::FromAbiList(const std::vector<configuration::Abi>& abi_list) { + std::unordered_set<std::string> abi_set; + for (auto& abi : abi_list) { + abi_set.insert(configuration::AbiToString(abi)); + } + // Make unique by hand as the constructor is private. + return std::unique_ptr<AbiFilter>(new AbiFilter(abi_set)); +} + +bool AbiFilter::Keep(const std::string& path) { + // We only care about libraries. + if (!util::StartsWith(path, kLibPrefix)) { + return true; + } + + auto abi_end = path.find('/', kLibPrefixLen); + if (abi_end == std::string::npos) { + // Ignore any files in the top level lib directory. + return true; + } + + // Strip the lib/ prefix. + const std::string& path_abi = path.substr(kLibPrefixLen, abi_end - kLibPrefixLen); + return (abis_.find(path_abi) != abis_.end()); +} + +} // namespace aapt diff --git a/tools/aapt2/filter/AbiFilter.h b/tools/aapt2/filter/AbiFilter.h new file mode 100644 index 000000000000..d875cb2b127b --- /dev/null +++ b/tools/aapt2/filter/AbiFilter.h @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AAPT2_ABISPLITTER_H +#define AAPT2_ABISPLITTER_H + +#include <memory> +#include <string> +#include <unordered_set> +#include <vector> + +#include "configuration/ConfigurationParser.h" +#include "filter/Filter.h" + +namespace aapt { + +/** + * Filters native library paths by ABI. ABIs present in the filter list are kept and all over + * libraries are removed. The filter is only applied to native library paths (this under lib/). + */ +class AbiFilter : public IPathFilter { + public: + /** Factory method to create a filter from a list of configuration::Abi. */ + static std::unique_ptr<AbiFilter> FromAbiList(const std::vector<configuration::Abi>& abi_list); + + /** Returns true if the path is for a native library in the list of desired ABIs. */ + bool Keep(const std::string& path) override; + + private: + explicit AbiFilter(std::unordered_set<std::string> abis) : abis_(std::move(abis)) { + } + + /** The path prefix to where all native libs end up inside an APK file. */ + static constexpr const char* kLibPrefix = "lib/"; + static constexpr size_t kLibPrefixLen = 4; + const std::unordered_set<std::string> abis_; +}; + +} // namespace aapt + +#endif // AAPT2_ABISPLITTER_H diff --git a/tools/aapt2/filter/AbiFilter_test.cpp b/tools/aapt2/filter/AbiFilter_test.cpp new file mode 100644 index 000000000000..0c8ea3575a29 --- /dev/null +++ b/tools/aapt2/filter/AbiFilter_test.cpp @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "filter/AbiFilter.h" + +#include <string> + +#include "gtest/gtest.h" + +namespace aapt { +namespace { + +using ::aapt::configuration::Abi; + +struct TestData { + std::string path; + bool kept; +}; + +const TestData kTestData[] = { + /* Keep. */ + {"lib/mips/libnative.so", true}, + {"not/native/file.txt", true}, + // Not sure if this is a valid use case. + {"lib/listing.txt", true}, + {"lib/mips/foo/bar/baz.so", true}, + {"lib/mips/x86/foo.so", true}, + /* Discard. */ + {"lib/mips_horse/foo.so", false}, + {"lib/horse_mips/foo.so", false}, + {"lib/mips64/armeabi-v7a/foo.so", false}, + {"lib/mips64/x86_64/x86.so", false}, + {"lib/x86/libnative.so", false}, + {"lib/x86/foo/bar/baz.so", false}, + {"lib/x86/x86/foo.so", false}, + {"lib/x86_horse/foo.so", false}, + {"lib/horse_x86/foo.so", false}, + {"lib/x86/armeabi-v7a/foo.so", false}, + {"lib/x86_64/x86_64/x86.so", false}, +}; + +class AbiFilterTest : public ::testing::TestWithParam<TestData> {}; + +TEST_P(AbiFilterTest, Keep) { + auto mips = AbiFilter::FromAbiList({Abi::kMips}); + const TestData& data = GetParam(); + EXPECT_EQ(mips->Keep(data.path), data.kept); +} + +INSTANTIATE_TEST_CASE_P(NativePaths, AbiFilterTest, ::testing::ValuesIn(kTestData)); + +} // namespace +} // namespace aapt diff --git a/tools/aapt2/filter/Filter.h b/tools/aapt2/filter/Filter.h new file mode 100644 index 000000000000..d737dc92e87b --- /dev/null +++ b/tools/aapt2/filter/Filter.h @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AAPT2_FILTER_H +#define AAPT2_FILTER_H + +#include <string> +#include <vector> + +#include "util/Util.h" + +namespace aapt { + +/** A filter to be applied to a path segment. */ +class IPathFilter { + public: + ~IPathFilter() = default; + + /** Returns true if the path should be kept. */ + virtual bool Keep(const std::string& path) = 0; +}; + +/** + * Path filter that keeps anything that matches the provided prefix. + */ +class PrefixFilter : public IPathFilter { + public: + explicit PrefixFilter(std::string prefix) : prefix_(std::move(prefix)) { + } + + /** Returns true if the provided path matches the prefix. */ + bool Keep(const std::string& path) override { + return util::StartsWith(path, prefix_); + } + + private: + const std::string prefix_; +}; + +/** Applies a set of IPathFilters to a path and returns true iif all filters keep the path. */ +class FilterChain : public IPathFilter { + public: + /** Adds a filter to the list to be applied to each path. */ + void AddFilter(std::unique_ptr<IPathFilter> filter) { + filters_.push_back(std::move(filter)); + } + + /** Returns true if all filters keep the path. */ + bool Keep(const std::string& path) override { + for (auto& filter : filters_) { + if (!filter->Keep(path)) { + return false; + } + } + return true; + } + + private: + std::vector<std::unique_ptr<IPathFilter>> filters_; +}; + +} // namespace aapt + +#endif // AAPT2_FILTER_H diff --git a/tools/aapt2/filter/Filter_test.cpp b/tools/aapt2/filter/Filter_test.cpp new file mode 100644 index 000000000000..fb75a4b4d7c1 --- /dev/null +++ b/tools/aapt2/filter/Filter_test.cpp @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "filter/Filter.h" + +#include <string> + +#include "io/Util.h" + +#include "gtest/gtest.h" + +namespace aapt { +namespace { + +TEST(FilterChainTest, EmptyChain) { + FilterChain chain; + ASSERT_TRUE(chain.Keep("some/random/path")); +} + +TEST(FilterChainTest, SingleFilter) { + FilterChain chain; + chain.AddFilter(util::make_unique<PrefixFilter>("keep/")); + + ASSERT_FALSE(chain.Keep("removed/path")); + ASSERT_TRUE(chain.Keep("keep/path/1")); + ASSERT_TRUE(chain.Keep("keep/path/2")); +} + +TEST(FilterChainTest, MultipleFilters) { + FilterChain chain; + chain.AddFilter(util::make_unique<PrefixFilter>("keep/")); + chain.AddFilter(util::make_unique<PrefixFilter>("keep/really/")); + + ASSERT_FALSE(chain.Keep("removed/path")); + ASSERT_FALSE(chain.Keep("/keep/really/wrong/prefix")); + ASSERT_FALSE(chain.Keep("keep/maybe/1")); + ASSERT_TRUE(chain.Keep("keep/really/1")); +} + +} // namespace +} // namespace aapt diff --git a/tools/aapt2/flatten/TableFlattener_test.cpp b/tools/aapt2/flatten/TableFlattener_test.cpp index 6d1350d433a4..4fdb2eced59b 100644 --- a/tools/aapt2/flatten/TableFlattener_test.cpp +++ b/tools/aapt2/flatten/TableFlattener_test.cpp @@ -26,6 +26,9 @@ using namespace android; +using ::testing::IsNull; +using ::testing::NotNull; + namespace aapt { class TableFlattenerTest : public ::testing::Test { @@ -235,13 +238,12 @@ TEST_F(TableFlattenerTest, FlattenMinMaxAttributes) { ResourceTable result; ASSERT_TRUE(Flatten(context_.get(), {}, table.get(), &result)); - Attribute* actualAttr = - test::GetValue<Attribute>(&result, "android:attr/foo"); - ASSERT_NE(nullptr, actualAttr); - EXPECT_EQ(attr.IsWeak(), actualAttr->IsWeak()); - EXPECT_EQ(attr.type_mask, actualAttr->type_mask); - EXPECT_EQ(attr.min_int, actualAttr->min_int); - EXPECT_EQ(attr.max_int, actualAttr->max_int); + Attribute* actual_attr = test::GetValue<Attribute>(&result, "android:attr/foo"); + ASSERT_THAT(actual_attr, NotNull()); + EXPECT_EQ(attr.IsWeak(), actual_attr->IsWeak()); + EXPECT_EQ(attr.type_mask, actual_attr->type_mask); + EXPECT_EQ(attr.min_int, actual_attr->min_int); + EXPECT_EQ(attr.max_int, actual_attr->max_int); } static std::unique_ptr<ResourceTable> BuildTableWithSparseEntries( @@ -303,15 +305,13 @@ TEST_F(TableFlattenerTest, FlattenSparseEntryWithMinSdkO) { auto value = test::GetValueForConfig<BinaryPrimitive>(&sparse_table, "android:string/foo_0", sparse_config); - ASSERT_NE(nullptr, value); + ASSERT_THAT(value, NotNull()); EXPECT_EQ(0u, value->value.data); - ASSERT_EQ(nullptr, test::GetValueForConfig<BinaryPrimitive>(&sparse_table, "android:string/foo_1", - sparse_config)); + ASSERT_THAT(test::GetValueForConfig<BinaryPrimitive>(&sparse_table, "android:string/foo_1", sparse_config), IsNull()); - value = test::GetValueForConfig<BinaryPrimitive>(&sparse_table, "android:string/foo_4", - sparse_config); - ASSERT_NE(nullptr, value); + value = test::GetValueForConfig<BinaryPrimitive>(&sparse_table, "android:string/foo_4", sparse_config); + ASSERT_THAT(value, NotNull()); EXPECT_EQ(4u, value->value.data); } @@ -372,7 +372,7 @@ TEST_F(TableFlattenerTest, FlattenSharedLibrary) { Maybe<ResourceTable::SearchResult> search_result = result.FindResource(test::ParseNameOrDie("lib:id/foo")); - AAPT_ASSERT_TRUE(search_result); + ASSERT_TRUE(search_result); EXPECT_EQ(0x00u, search_result.value().package->id.value()); auto iter = result.included_packages_.find(0x00); @@ -398,7 +398,7 @@ TEST_F(TableFlattenerTest, FlattenTableReferencingSharedLibraries) { ASSERT_TRUE(Flatten(context.get(), {}, table.get(), &result)); const DynamicRefTable* dynamic_ref_table = result.getDynamicRefTableForCookie(1); - ASSERT_NE(nullptr, dynamic_ref_table); + ASSERT_THAT(dynamic_ref_table, NotNull()); const KeyedVector<String16, uint8_t>& entries = dynamic_ref_table->entries(); @@ -423,7 +423,7 @@ TEST_F(TableFlattenerTest, PackageWithNonStandardIdHasDynamicRefTable) { ASSERT_TRUE(Flatten(context.get(), {}, table.get(), &result)); const DynamicRefTable* dynamic_ref_table = result.getDynamicRefTableForCookie(1); - ASSERT_NE(nullptr, dynamic_ref_table); + ASSERT_THAT(dynamic_ref_table, NotNull()); const KeyedVector<String16, uint8_t>& entries = dynamic_ref_table->entries(); ssize_t idx = entries.indexOfKey(android::String16("app")); diff --git a/tools/aapt2/integration-tests/AppOne/res/values/styles.xml b/tools/aapt2/integration-tests/AppOne/res/values/styles.xml index f05845cfab28..19d96c0809db 100644 --- a/tools/aapt2/integration-tests/AppOne/res/values/styles.xml +++ b/tools/aapt2/integration-tests/AppOne/res/values/styles.xml @@ -25,6 +25,7 @@ <style name="Pop"> <item name="custom">@android:drawable/btn_default</item> <item name="android:focusable">true</item> + <item name="android:numColumns">auto_fit</item> </style> <string name="yo">@string/wow</string> diff --git a/tools/aapt2/link/AutoVersioner_test.cpp b/tools/aapt2/link/AutoVersioner_test.cpp index 755af0a1c6cc..49639f8ad549 100644 --- a/tools/aapt2/link/AutoVersioner_test.cpp +++ b/tools/aapt2/link/AutoVersioner_test.cpp @@ -19,43 +19,34 @@ #include "ConfigDescription.h" #include "test/Test.h" +using ::testing::NotNull; + namespace aapt { TEST(AutoVersionerTest, GenerateVersionedResources) { const ConfigDescription land_config = test::ParseConfigOrDie("land"); - const ConfigDescription sw600dp_land_config = - test::ParseConfigOrDie("sw600dp-land"); + const ConfigDescription sw600dp_land_config = test::ParseConfigOrDie("sw600dp-land"); ResourceEntry entry("foo"); - entry.values.push_back(util::make_unique<ResourceConfigValue>( - ConfigDescription::DefaultConfig(), "")); - entry.values.push_back( - util::make_unique<ResourceConfigValue>(land_config, "")); - entry.values.push_back( - util::make_unique<ResourceConfigValue>(sw600dp_land_config, "")); - - EXPECT_TRUE(ShouldGenerateVersionedResource( - &entry, ConfigDescription::DefaultConfig(), 17)); + entry.values.push_back(util::make_unique<ResourceConfigValue>(ConfigDescription::DefaultConfig(), "")); + entry.values.push_back(util::make_unique<ResourceConfigValue>(land_config, "")); + entry.values.push_back(util::make_unique<ResourceConfigValue>(sw600dp_land_config, "")); + + EXPECT_TRUE(ShouldGenerateVersionedResource(&entry, ConfigDescription::DefaultConfig(), 17)); EXPECT_TRUE(ShouldGenerateVersionedResource(&entry, land_config, 17)); } TEST(AutoVersionerTest, GenerateVersionedResourceWhenHigherVersionExists) { - const ConfigDescription sw600dp_v13_config = - test::ParseConfigOrDie("sw600dp-v13"); + const ConfigDescription sw600dp_v13_config = test::ParseConfigOrDie("sw600dp-v13"); const ConfigDescription v21_config = test::ParseConfigOrDie("v21"); ResourceEntry entry("foo"); - entry.values.push_back(util::make_unique<ResourceConfigValue>( - ConfigDescription::DefaultConfig(), "")); - entry.values.push_back( - util::make_unique<ResourceConfigValue>(sw600dp_v13_config, "")); - entry.values.push_back( - util::make_unique<ResourceConfigValue>(v21_config, "")); - - EXPECT_TRUE(ShouldGenerateVersionedResource( - &entry, ConfigDescription::DefaultConfig(), 17)); - EXPECT_FALSE(ShouldGenerateVersionedResource( - &entry, ConfigDescription::DefaultConfig(), 22)); + entry.values.push_back(util::make_unique<ResourceConfigValue>(ConfigDescription::DefaultConfig(), "")); + entry.values.push_back(util::make_unique<ResourceConfigValue>(sw600dp_v13_config, "")); + entry.values.push_back(util::make_unique<ResourceConfigValue>(v21_config, "")); + + EXPECT_TRUE(ShouldGenerateVersionedResource(&entry, ConfigDescription::DefaultConfig(), 17)); + EXPECT_FALSE(ShouldGenerateVersionedResource(&entry, ConfigDescription::DefaultConfig(), 22)); } TEST(AutoVersionerTest, VersionStylesForTable) { @@ -92,46 +83,28 @@ TEST(AutoVersionerTest, VersionStylesForTable) { AutoVersioner versioner; ASSERT_TRUE(versioner.Consume(context.get(), table.get())); - Style* style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo", - test::ParseConfigOrDie("v4")); - ASSERT_NE(style, nullptr); + Style* style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo", test::ParseConfigOrDie("v4")); + ASSERT_THAT(style, NotNull()); ASSERT_EQ(style->entries.size(), 1u); - AAPT_ASSERT_TRUE(style->entries.front().key.name); - EXPECT_EQ(style->entries.front().key.name.value(), - test::ParseNameOrDie("android:attr/onClick")); + EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/onClick")), style->entries.front().key.name); - style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo", - test::ParseConfigOrDie("v13")); - ASSERT_NE(style, nullptr); + style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo", test::ParseConfigOrDie("v13")); + ASSERT_THAT(style, NotNull()); ASSERT_EQ(style->entries.size(), 2u); - AAPT_ASSERT_TRUE(style->entries[0].key.name); - EXPECT_EQ(style->entries[0].key.name.value(), - test::ParseNameOrDie("android:attr/onClick")); - AAPT_ASSERT_TRUE(style->entries[1].key.name); - EXPECT_EQ(style->entries[1].key.name.value(), - test::ParseNameOrDie("android:attr/requiresSmallestWidthDp")); - - style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo", - test::ParseConfigOrDie("v17")); - ASSERT_NE(style, nullptr); + EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/onClick")),style->entries[0].key.name); + EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/requiresSmallestWidthDp")), style->entries[1].key.name); + + style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo", test::ParseConfigOrDie("v17")); + ASSERT_THAT(style, NotNull()); ASSERT_EQ(style->entries.size(), 3u); - AAPT_ASSERT_TRUE(style->entries[0].key.name); - EXPECT_EQ(style->entries[0].key.name.value(), - test::ParseNameOrDie("android:attr/onClick")); - AAPT_ASSERT_TRUE(style->entries[1].key.name); - EXPECT_EQ(style->entries[1].key.name.value(), - test::ParseNameOrDie("android:attr/requiresSmallestWidthDp")); - AAPT_ASSERT_TRUE(style->entries[2].key.name); - EXPECT_EQ(style->entries[2].key.name.value(), - test::ParseNameOrDie("android:attr/paddingStart")); - - style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo", - test::ParseConfigOrDie("v21")); - ASSERT_NE(style, nullptr); - ASSERT_EQ(style->entries.size(), 1u); - AAPT_ASSERT_TRUE(style->entries.front().key.name); - EXPECT_EQ(style->entries.front().key.name.value(), - test::ParseNameOrDie("android:attr/paddingEnd")); + EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/onClick")), style->entries[0].key.name); + EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/requiresSmallestWidthDp")), style->entries[1].key.name); + EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/paddingStart")), style->entries[2].key.name); + + style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo", test::ParseConfigOrDie("v21")); + ASSERT_THAT(style, NotNull()); + ASSERT_EQ(1u, style->entries.size()); + EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/paddingEnd")), style->entries.front().key.name); } } // namespace aapt diff --git a/tools/aapt2/link/ReferenceLinker.cpp b/tools/aapt2/link/ReferenceLinker.cpp index a8e510cd6140..414e56eb5dcc 100644 --- a/tools/aapt2/link/ReferenceLinker.cpp +++ b/tools/aapt2/link/ReferenceLinker.cpp @@ -109,18 +109,15 @@ class ReferenceLinkerVisitor : public ValueVisitor { entry.value->Accept(this); // Now verify that the type of this item is compatible with the - // attribute it - // is defined for. We pass `nullptr` as the DiagMessage so that this - // check is - // fast and we avoid creating a DiagMessage when the match is - // successful. - if (!symbol->attribute->Matches(entry.value.get(), nullptr)) { + // attribute it is defined for. We pass `nullptr` as the DiagMessage so that this + // check is fast and we avoid creating a DiagMessage when the match is successful. + if (!symbol->attribute->Matches(*entry.value, nullptr)) { // The actual type of this item is incompatible with the attribute. DiagMessage msg(entry.key.GetSource()); // Call the matches method again, this time with a DiagMessage so we // fill in the actual error message. - symbol->attribute->Matches(entry.value.get(), &msg); + symbol->attribute->Matches(*entry.value, &msg); context_->GetDiagnostics()->Error(msg); error_ = true; } diff --git a/tools/aapt2/link/ReferenceLinker_test.cpp b/tools/aapt2/link/ReferenceLinker_test.cpp index d8e33a42711a..72a91689e392 100644 --- a/tools/aapt2/link/ReferenceLinker_test.cpp +++ b/tools/aapt2/link/ReferenceLinker_test.cpp @@ -19,6 +19,7 @@ #include "test/Test.h" using android::ResTable_map; +using ::testing::NotNull; namespace aapt { @@ -54,18 +55,18 @@ TEST(ReferenceLinkerTest, LinkSimpleReferences) { ASSERT_TRUE(linker.Consume(context.get(), table.get())); Reference* ref = test::GetValue<Reference>(table.get(), "com.app.test:string/foo"); - ASSERT_NE(nullptr, ref); - AAPT_ASSERT_TRUE(ref->id); + ASSERT_THAT(ref, NotNull()); + ASSERT_TRUE(ref->id); EXPECT_EQ(ResourceId(0x7f020001), ref->id.value()); ref = test::GetValue<Reference>(table.get(), "com.app.test:string/bar"); - ASSERT_NE(nullptr, ref); - AAPT_ASSERT_TRUE(ref->id); + ASSERT_THAT(ref, NotNull()); + ASSERT_TRUE(ref->id); EXPECT_EQ(ResourceId(0x7f020002), ref->id.value()); ref = test::GetValue<Reference>(table.get(), "com.app.test:string/baz"); - ASSERT_NE(nullptr, ref); - AAPT_ASSERT_TRUE(ref->id); + ASSERT_THAT(ref, NotNull()); + ASSERT_TRUE(ref->id); EXPECT_EQ(ResourceId(0x01040034), ref->id.value()); } @@ -84,10 +85,9 @@ TEST(ReferenceLinkerTest, LinkStyleAttributes) { { // We need to fill in the value for the attribute android:attr/bar after we - // build the - // table, because we need access to the string pool. + // build the table, because we need access to the string pool. Style* style = test::GetValue<Style>(table.get(), "com.app.test:style/Theme"); - ASSERT_NE(nullptr, style); + ASSERT_THAT(style, NotNull()); style->entries.back().value = util::make_unique<RawString>(table->string_pool.MakeRef("one|two")); } @@ -118,20 +118,20 @@ TEST(ReferenceLinkerTest, LinkStyleAttributes) { ASSERT_TRUE(linker.Consume(context.get(), table.get())); Style* style = test::GetValue<Style>(table.get(), "com.app.test:style/Theme"); - ASSERT_NE(nullptr, style); - AAPT_ASSERT_TRUE(style->parent); - AAPT_ASSERT_TRUE(style->parent.value().id); + ASSERT_THAT(style, NotNull()); + ASSERT_TRUE(style->parent); + ASSERT_TRUE(style->parent.value().id); EXPECT_EQ(ResourceId(0x01060000), style->parent.value().id.value()); ASSERT_EQ(2u, style->entries.size()); - AAPT_ASSERT_TRUE(style->entries[0].key.id); + ASSERT_TRUE(style->entries[0].key.id); EXPECT_EQ(ResourceId(0x01010001), style->entries[0].key.id.value()); - ASSERT_NE(nullptr, ValueCast<BinaryPrimitive>(style->entries[0].value.get())); + ASSERT_THAT(ValueCast<BinaryPrimitive>(style->entries[0].value.get()), NotNull()); - AAPT_ASSERT_TRUE(style->entries[1].key.id); + ASSERT_TRUE(style->entries[1].key.id); EXPECT_EQ(ResourceId(0x01010002), style->entries[1].key.id.value()); - ASSERT_NE(nullptr, ValueCast<BinaryPrimitive>(style->entries[1].value.get())); + ASSERT_THAT(ValueCast<BinaryPrimitive>(style->entries[1].value.get()), NotNull()); } TEST(ReferenceLinkerTest, LinkMangledReferencesAndAttributes) { @@ -165,9 +165,9 @@ TEST(ReferenceLinkerTest, LinkMangledReferencesAndAttributes) { ASSERT_TRUE(linker.Consume(context.get(), table.get())); Style* style = test::GetValue<Style>(table.get(), "com.app.test:style/Theme"); - ASSERT_NE(nullptr, style); + ASSERT_THAT(style, NotNull()); ASSERT_EQ(1u, style->entries.size()); - AAPT_ASSERT_TRUE(style->entries.front().key.id); + ASSERT_TRUE(style->entries.front().key.id); EXPECT_EQ(ResourceId(0x7f010000), style->entries.front().key.id.value()); } @@ -266,7 +266,7 @@ TEST(ReferenceLinkerTest, AppsWithSamePackageButDifferentIdAreVisibleNonPublic) const CallSite call_site{ResourceNameRef("com.app.test", ResourceType::kString, "foo")}; const SymbolTable::Symbol* symbol = ReferenceLinker::ResolveSymbolCheckVisibility( *test::BuildReference("com.app.test:string/foo"), call_site, &table, &error); - ASSERT_NE(nullptr, symbol); + ASSERT_THAT(symbol, NotNull()); EXPECT_TRUE(error.empty()); } @@ -283,12 +283,12 @@ TEST(ReferenceLinkerTest, AppsWithDifferentPackageCanNotUseEachOthersAttribute) std::string error; const CallSite call_site{ResourceNameRef("com.app.ext", ResourceType::kLayout, "foo")}; - AAPT_EXPECT_FALSE(ReferenceLinker::CompileXmlAttribute( + EXPECT_FALSE(ReferenceLinker::CompileXmlAttribute( *test::BuildReference("com.app.test:attr/foo"), call_site, &table, &error)); EXPECT_FALSE(error.empty()); error = ""; - AAPT_ASSERT_TRUE(ReferenceLinker::CompileXmlAttribute( + ASSERT_TRUE(ReferenceLinker::CompileXmlAttribute( *test::BuildReference("com.app.test:attr/public_foo"), call_site, &table, &error)); EXPECT_TRUE(error.empty()); } diff --git a/tools/aapt2/link/XmlReferenceLinker_test.cpp b/tools/aapt2/link/XmlReferenceLinker_test.cpp index de81e73f613e..228cfb9e3d66 100644 --- a/tools/aapt2/link/XmlReferenceLinker_test.cpp +++ b/tools/aapt2/link/XmlReferenceLinker_test.cpp @@ -18,6 +18,9 @@ #include "test/Test.h" +using ::testing::IsNull; +using ::testing::NotNull; + namespace aapt { class XmlReferenceLinkerTest : public ::testing::Test { @@ -90,56 +93,48 @@ TEST_F(XmlReferenceLinkerTest, LinkBasicAttributes) { ASSERT_TRUE(linker.Consume(context_.get(), doc.get())); xml::Element* view_el = xml::FindRootElement(doc.get()); - ASSERT_NE(nullptr, view_el); + ASSERT_THAT(view_el, NotNull()); xml::Attribute* xml_attr = view_el->FindAttribute(xml::kSchemaAndroid, "layout_width"); - ASSERT_NE(nullptr, xml_attr); - AAPT_ASSERT_TRUE(xml_attr->compiled_attribute); - AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id); - EXPECT_EQ(ResourceId(0x01010000), xml_attr->compiled_attribute.value().id.value()); - ASSERT_NE(nullptr, xml_attr->compiled_value); - ASSERT_NE(nullptr, ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get())); + ASSERT_THAT(xml_attr, NotNull()); + ASSERT_TRUE(xml_attr->compiled_attribute); + EXPECT_EQ(make_value(ResourceId(0x01010000)), xml_attr->compiled_attribute.value().id); + EXPECT_THAT(ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()), NotNull()); xml_attr = view_el->FindAttribute(xml::kSchemaAndroid, "background"); - ASSERT_NE(nullptr, xml_attr); - AAPT_ASSERT_TRUE(xml_attr->compiled_attribute); - AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id); - EXPECT_EQ(ResourceId(0x01010001), xml_attr->compiled_attribute.value().id.value()); - ASSERT_NE(nullptr, xml_attr->compiled_value); + ASSERT_THAT(xml_attr, NotNull()); + ASSERT_TRUE(xml_attr->compiled_attribute); + EXPECT_EQ(make_value(ResourceId(0x01010001)), xml_attr->compiled_attribute.value().id); Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get()); - ASSERT_NE(nullptr, ref); - AAPT_ASSERT_TRUE(ref->name); - EXPECT_EQ(test::ParseNameOrDie("color/green"), ref->name.value()); // Make sure the name - // didn't change. - AAPT_ASSERT_TRUE(ref->id); - EXPECT_EQ(ResourceId(0x7f020000), ref->id.value()); + ASSERT_THAT(ref, NotNull()); + EXPECT_EQ(make_value(test::ParseNameOrDie("color/green")), ref->name); // Make sure the name + // didn't change. + EXPECT_EQ(make_value(ResourceId(0x7f020000)), ref->id); xml_attr = view_el->FindAttribute(xml::kSchemaAndroid, "text"); - ASSERT_NE(nullptr, xml_attr); - AAPT_ASSERT_TRUE(xml_attr->compiled_attribute); - ASSERT_FALSE(xml_attr->compiled_value); // Strings don't get compiled for memory sake. + ASSERT_THAT(xml_attr, NotNull()); + EXPECT_TRUE(xml_attr->compiled_attribute); + EXPECT_THAT(xml_attr->compiled_value, IsNull()); // Strings don't get compiled for memory sake. xml_attr = view_el->FindAttribute(xml::kSchemaAndroid, "attr"); - ASSERT_NE(nullptr, xml_attr); - AAPT_ASSERT_TRUE(xml_attr->compiled_attribute); - ASSERT_FALSE(xml_attr->compiled_value); // Should be a plain string. + ASSERT_THAT(xml_attr, NotNull()); + EXPECT_TRUE(xml_attr->compiled_attribute); + EXPECT_THAT(xml_attr->compiled_value, IsNull()); // Should be a plain string. xml_attr = view_el->FindAttribute("", "nonAaptAttr"); - ASSERT_NE(nullptr, xml_attr); - AAPT_ASSERT_FALSE(xml_attr->compiled_attribute); - ASSERT_NE(nullptr, xml_attr->compiled_value); - ASSERT_NE(nullptr, ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get())); + ASSERT_THAT(xml_attr, NotNull()); + EXPECT_FALSE(xml_attr->compiled_attribute); + EXPECT_THAT(ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()), NotNull()); xml_attr = view_el->FindAttribute("", "nonAaptAttrRef"); - ASSERT_NE(nullptr, xml_attr); - AAPT_ASSERT_FALSE(xml_attr->compiled_attribute); - ASSERT_NE(nullptr, xml_attr->compiled_value); - ASSERT_NE(nullptr, ValueCast<Reference>(xml_attr->compiled_value.get())); + ASSERT_THAT(xml_attr, NotNull()); + EXPECT_FALSE(xml_attr->compiled_attribute); + EXPECT_THAT(ValueCast<Reference>(xml_attr->compiled_value.get()), NotNull()); xml_attr = view_el->FindAttribute("", "class"); - ASSERT_NE(nullptr, xml_attr); - AAPT_ASSERT_FALSE(xml_attr->compiled_attribute); - ASSERT_EQ(nullptr, xml_attr->compiled_value); + ASSERT_THAT(xml_attr, NotNull()); + EXPECT_FALSE(xml_attr->compiled_attribute); + EXPECT_THAT(xml_attr->compiled_value, IsNull()); } TEST_F(XmlReferenceLinkerTest, PrivateSymbolsAreNotLinked) { @@ -169,15 +164,14 @@ TEST_F(XmlReferenceLinkerTest, LinkMangledAttributes) { ASSERT_TRUE(linker.Consume(context_.get(), doc.get())); xml::Element* view_el = xml::FindRootElement(doc.get()); - ASSERT_NE(view_el, nullptr); + ASSERT_THAT(view_el, NotNull()); xml::Attribute* xml_attr = view_el->FindAttribute(xml::BuildPackageNamespace("com.android.support"), "colorAccent"); - ASSERT_NE(xml_attr, nullptr); - AAPT_ASSERT_TRUE(xml_attr->compiled_attribute); - AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id); - EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(), ResourceId(0x7f010001)); - ASSERT_NE(ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()), nullptr); + ASSERT_THAT(xml_attr, NotNull()); + ASSERT_TRUE(xml_attr->compiled_attribute); + EXPECT_EQ(make_value(ResourceId(0x7f010001)), xml_attr->compiled_attribute.value().id); + EXPECT_THAT(ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()), NotNull()); } TEST_F(XmlReferenceLinkerTest, LinkAutoResReference) { @@ -189,18 +183,16 @@ TEST_F(XmlReferenceLinkerTest, LinkAutoResReference) { ASSERT_TRUE(linker.Consume(context_.get(), doc.get())); xml::Element* view_el = xml::FindRootElement(doc.get()); - ASSERT_NE(view_el, nullptr); + ASSERT_THAT(view_el, NotNull()); xml::Attribute* xml_attr = view_el->FindAttribute(xml::kSchemaAuto, "colorAccent"); - ASSERT_NE(xml_attr, nullptr); - AAPT_ASSERT_TRUE(xml_attr->compiled_attribute); - AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id); - EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(), ResourceId(0x7f010000)); + ASSERT_THAT(xml_attr, NotNull()); + ASSERT_TRUE(xml_attr->compiled_attribute); + EXPECT_EQ(make_value(ResourceId(0x7f010000)), xml_attr->compiled_attribute.value().id); Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get()); - ASSERT_NE(ref, nullptr); - AAPT_ASSERT_TRUE(ref->name); - AAPT_ASSERT_TRUE(ref->id); - EXPECT_EQ(ref->id.value(), ResourceId(0x7f020001)); + ASSERT_THAT(ref, NotNull()); + ASSERT_TRUE(ref->name); + EXPECT_EQ(make_value(ResourceId(0x7f020001)), ref->id); } TEST_F(XmlReferenceLinkerTest, LinkViewWithShadowedPackageAlias) { @@ -215,35 +207,31 @@ TEST_F(XmlReferenceLinkerTest, LinkViewWithShadowedPackageAlias) { ASSERT_TRUE(linker.Consume(context_.get(), doc.get())); xml::Element* view_el = xml::FindRootElement(doc.get()); - ASSERT_NE(view_el, nullptr); + ASSERT_THAT(view_el, NotNull()); // All attributes and references in this element should be referring to // "android" (0x01). xml::Attribute* xml_attr = view_el->FindAttribute(xml::kSchemaAndroid, "attr"); - ASSERT_NE(xml_attr, nullptr); - AAPT_ASSERT_TRUE(xml_attr->compiled_attribute); - AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id); - EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(), ResourceId(0x01010002)); + ASSERT_THAT(xml_attr, NotNull()); + ASSERT_TRUE(xml_attr->compiled_attribute); + EXPECT_EQ(make_value(ResourceId(0x01010002)), xml_attr->compiled_attribute.value().id); Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get()); - ASSERT_NE(ref, nullptr); - AAPT_ASSERT_TRUE(ref->id); - EXPECT_EQ(ref->id.value(), ResourceId(0x01030000)); + ASSERT_THAT(ref, NotNull()); + EXPECT_EQ(make_value(ResourceId(0x01030000)), ref->id); ASSERT_FALSE(view_el->GetChildElements().empty()); view_el = view_el->GetChildElements().front(); - ASSERT_NE(view_el, nullptr); + ASSERT_THAT(view_el, NotNull()); // All attributes and references in this element should be referring to // "com.app.test" (0x7f). xml_attr = view_el->FindAttribute(xml::BuildPackageNamespace("com.app.test"), "attr"); - ASSERT_NE(xml_attr, nullptr); - AAPT_ASSERT_TRUE(xml_attr->compiled_attribute); - AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id); - EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(), ResourceId(0x7f010002)); + ASSERT_THAT(xml_attr, NotNull()); + ASSERT_TRUE(xml_attr->compiled_attribute); + EXPECT_EQ(make_value(ResourceId(0x7f010002)), xml_attr->compiled_attribute.value().id); ref = ValueCast<Reference>(xml_attr->compiled_value.get()); - ASSERT_NE(ref, nullptr); - AAPT_ASSERT_TRUE(ref->id); - EXPECT_EQ(ref->id.value(), ResourceId(0x7f030000)); + ASSERT_THAT(ref, NotNull()); + EXPECT_EQ(make_value(ResourceId(0x7f030000)), ref->id); } TEST_F(XmlReferenceLinkerTest, LinkViewWithLocalPackageAndAliasOfTheSameName) { @@ -255,20 +243,17 @@ TEST_F(XmlReferenceLinkerTest, LinkViewWithLocalPackageAndAliasOfTheSameName) { ASSERT_TRUE(linker.Consume(context_.get(), doc.get())); xml::Element* view_el = xml::FindRootElement(doc.get()); - ASSERT_NE(view_el, nullptr); + ASSERT_THAT(view_el, NotNull()); // All attributes and references in this element should be referring to // "com.app.test" (0x7f). - xml::Attribute* xml_attr = - view_el->FindAttribute(xml::BuildPackageNamespace("com.app.test"), "attr"); - ASSERT_NE(xml_attr, nullptr); - AAPT_ASSERT_TRUE(xml_attr->compiled_attribute); - AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id); - EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(), ResourceId(0x7f010002)); + xml::Attribute* xml_attr = view_el->FindAttribute(xml::BuildPackageNamespace("com.app.test"), "attr"); + ASSERT_THAT(xml_attr, NotNull()); + ASSERT_TRUE(xml_attr->compiled_attribute); + EXPECT_EQ(make_value(ResourceId(0x7f010002)), xml_attr->compiled_attribute.value().id); Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get()); - ASSERT_NE(ref, nullptr); - AAPT_ASSERT_TRUE(ref->id); - EXPECT_EQ(ref->id.value(), ResourceId(0x7f030000)); + ASSERT_THAT(ref, NotNull()); + EXPECT_EQ(make_value(ResourceId(0x7f030000)), ref->id); } } // namespace aapt diff --git a/tools/aapt2/optimize/ResourceDeduper_test.cpp b/tools/aapt2/optimize/ResourceDeduper_test.cpp index 4d00fa6efe37..d9f384c095ca 100644 --- a/tools/aapt2/optimize/ResourceDeduper_test.cpp +++ b/tools/aapt2/optimize/ResourceDeduper_test.cpp @@ -19,69 +19,88 @@ #include "ResourceTable.h" #include "test/Test.h" +using ::aapt::test::HasValue; +using ::testing::Not; + namespace aapt { TEST(ResourceDeduperTest, SameValuesAreDeduped) { std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build(); const ConfigDescription default_config = {}; + const ConfigDescription ldrtl_config = test::ParseConfigOrDie("ldrtl"); + const ConfigDescription ldrtl_v21_config = test::ParseConfigOrDie("ldrtl-v21"); const ConfigDescription en_config = test::ParseConfigOrDie("en"); const ConfigDescription en_v21_config = test::ParseConfigOrDie("en-v21"); - // Chosen because this configuration is compatible with en. + // Chosen because this configuration is compatible with ldrtl/en. const ConfigDescription land_config = test::ParseConfigOrDie("land"); std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder() - .AddString("android:string/dedupe", ResourceId{}, default_config, - "dedupe") - .AddString("android:string/dedupe", ResourceId{}, en_config, "dedupe") - .AddString("android:string/dedupe", ResourceId{}, land_config, - "dedupe") - .AddString("android:string/dedupe2", ResourceId{}, default_config, - "dedupe") - .AddString("android:string/dedupe2", ResourceId{}, en_config, - "dedupe") - .AddString("android:string/dedupe2", ResourceId{}, en_v21_config, - "keep") - .AddString("android:string/dedupe2", ResourceId{}, land_config, - "dedupe") + .AddString("android:string/dedupe", ResourceId{}, default_config, "dedupe") + .AddString("android:string/dedupe", ResourceId{}, ldrtl_config, "dedupe") + .AddString("android:string/dedupe", ResourceId{}, land_config, "dedupe") + + .AddString("android:string/dedupe2", ResourceId{}, default_config, "dedupe") + .AddString("android:string/dedupe2", ResourceId{}, ldrtl_config, "dedupe") + .AddString("android:string/dedupe2", ResourceId{}, ldrtl_v21_config, "keep") + .AddString("android:string/dedupe2", ResourceId{}, land_config, "dedupe") + + .AddString("android:string/dedupe3", ResourceId{}, default_config, "dedupe") + .AddString("android:string/dedupe3", ResourceId{}, en_config, "dedupe") + .AddString("android:string/dedupe3", ResourceId{}, en_v21_config, "dedupe") .Build(); ASSERT_TRUE(ResourceDeduper().Consume(context.get(), table.get())); - EXPECT_EQ(nullptr, test::GetValueForConfig<String>( - table.get(), "android:string/dedupe", en_config)); - EXPECT_EQ(nullptr, test::GetValueForConfig<String>( - table.get(), "android:string/dedupe", land_config)); - EXPECT_EQ(nullptr, test::GetValueForConfig<String>( - table.get(), "android:string/dedupe2", en_config)); - EXPECT_NE(nullptr, test::GetValueForConfig<String>( - table.get(), "android:string/dedupe2", en_v21_config)); + EXPECT_THAT(table, Not(HasValue("android:string/dedupe", ldrtl_config))); + EXPECT_THAT(table, Not(HasValue("android:string/dedupe", land_config))); + + EXPECT_THAT(table, HasValue("android:string/dedupe2", ldrtl_v21_config)); + EXPECT_THAT(table, Not(HasValue("android:string/dedupe2", ldrtl_config))); + + EXPECT_THAT(table, HasValue("android:string/dedupe3", default_config)); + EXPECT_THAT(table, HasValue("android:string/dedupe3", en_config)); + EXPECT_THAT(table, Not(HasValue("android:string/dedupe3", en_v21_config))); } TEST(ResourceDeduperTest, DifferentValuesAreKept) { std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build(); const ConfigDescription default_config = {}; - const ConfigDescription en_config = test::ParseConfigOrDie("en"); - const ConfigDescription en_v21_config = test::ParseConfigOrDie("en-v21"); - // Chosen because this configuration is compatible with en. + const ConfigDescription ldrtl_config = test::ParseConfigOrDie("ldrtl"); + const ConfigDescription ldrtl_v21_config = test::ParseConfigOrDie("ldrtl-v21"); + // Chosen because this configuration is compatible with ldrtl. const ConfigDescription land_config = test::ParseConfigOrDie("land"); std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder() - .AddString("android:string/keep", ResourceId{}, default_config, - "keep") - .AddString("android:string/keep", ResourceId{}, en_config, "keep") - .AddString("android:string/keep", ResourceId{}, en_v21_config, - "keep2") + .AddString("android:string/keep", ResourceId{}, default_config, "keep") + .AddString("android:string/keep", ResourceId{}, ldrtl_config, "keep") + .AddString("android:string/keep", ResourceId{}, ldrtl_v21_config, "keep2") .AddString("android:string/keep", ResourceId{}, land_config, "keep2") .Build(); ASSERT_TRUE(ResourceDeduper().Consume(context.get(), table.get())); - EXPECT_NE(nullptr, test::GetValueForConfig<String>( - table.get(), "android:string/keep", en_config)); - EXPECT_NE(nullptr, test::GetValueForConfig<String>( - table.get(), "android:string/keep", en_v21_config)); - EXPECT_NE(nullptr, test::GetValueForConfig<String>( - table.get(), "android:string/keep", land_config)); + EXPECT_THAT(table, HasValue("android:string/keep", ldrtl_config)); + EXPECT_THAT(table, HasValue("android:string/keep", ldrtl_v21_config)); + EXPECT_THAT(table, HasValue("android:string/keep", land_config)); +} + +TEST(ResourceDeduperTest, LocalesValuesAreKept) { + std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build(); + const ConfigDescription default_config = {}; + const ConfigDescription fr_config = test::ParseConfigOrDie("fr"); + const ConfigDescription fr_rCA_config = test::ParseConfigOrDie("fr-rCA"); + + std::unique_ptr<ResourceTable> table = + test::ResourceTableBuilder() + .AddString("android:string/keep", ResourceId{}, default_config, "keep") + .AddString("android:string/keep", ResourceId{}, fr_config, "keep") + .AddString("android:string/keep", ResourceId{}, fr_rCA_config, "keep") + .Build(); + + ASSERT_TRUE(ResourceDeduper().Consume(context.get(), table.get())); + EXPECT_THAT(table, HasValue("android:string/keep", default_config)); + EXPECT_THAT(table, HasValue("android:string/keep", fr_config)); + EXPECT_THAT(table, HasValue("android:string/keep", fr_rCA_config)); } } // namespace aapt diff --git a/tools/aapt2/proto/TableProtoSerializer_test.cpp b/tools/aapt2/proto/TableProtoSerializer_test.cpp index e6ce6d37b879..3ebb08eb791e 100644 --- a/tools/aapt2/proto/TableProtoSerializer_test.cpp +++ b/tools/aapt2/proto/TableProtoSerializer_test.cpp @@ -20,6 +20,7 @@ #include "test/Test.h" using ::google::protobuf::io::StringOutputStream; +using ::testing::NotNull; namespace aapt { @@ -46,8 +47,7 @@ TEST(TableProtoSerializer, SerializeSinglePackage) { // Make a plural. std::unique_ptr<Plural> plural = util::make_unique<Plural>(); - plural->values[Plural::One] = - util::make_unique<String>(table->string_pool.MakeRef("one")); + plural->values[Plural::One] = util::make_unique<String>(table->string_pool.MakeRef("one")); ASSERT_TRUE(table->AddResource(test::ParseNameOrDie("com.app.a:plurals/hey"), ConfigDescription{}, {}, std::move(plural), context->GetDiagnostics())); @@ -77,19 +77,19 @@ TEST(TableProtoSerializer, SerializeSinglePackage) { context->GetDiagnostics())); std::unique_ptr<pb::ResourceTable> pb_table = SerializeTableToPb(table.get()); - ASSERT_NE(nullptr, pb_table); + ASSERT_THAT(pb_table, NotNull()); std::unique_ptr<ResourceTable> new_table = DeserializeTableFromPb( *pb_table, Source{"test"}, context->GetDiagnostics()); - ASSERT_NE(nullptr, new_table); + ASSERT_THAT(new_table, NotNull()); Id* new_id = test::GetValue<Id>(new_table.get(), "com.app.a:id/foo"); - ASSERT_NE(nullptr, new_id); + ASSERT_THAT(new_id, NotNull()); EXPECT_EQ(id->IsWeak(), new_id->IsWeak()); Maybe<ResourceTable::SearchResult> result = new_table->FindResource(test::ParseNameOrDie("com.app.a:layout/main")); - AAPT_ASSERT_TRUE(result); + ASSERT_TRUE(result); EXPECT_EQ(SymbolState::kPublic, result.value().type->symbol_status.state); EXPECT_EQ(SymbolState::kPublic, result.value().entry->symbol_status.state); @@ -101,18 +101,18 @@ TEST(TableProtoSerializer, SerializeSinglePackage) { // Find the product-dependent values BinaryPrimitive* prim = test::GetValueForConfigAndProduct<BinaryPrimitive>( new_table.get(), "com.app.a:integer/one", test::ParseConfigOrDie("land"), ""); - ASSERT_NE(nullptr, prim); + ASSERT_THAT(prim, NotNull()); EXPECT_EQ(123u, prim->value.data); prim = test::GetValueForConfigAndProduct<BinaryPrimitive>( new_table.get(), "com.app.a:integer/one", test::ParseConfigOrDie("land"), "tablet"); - ASSERT_NE(nullptr, prim); + ASSERT_THAT(prim, NotNull()); EXPECT_EQ(321u, prim->value.data); Reference* actual_ref = test::GetValue<Reference>(new_table.get(), "com.app.a:layout/abc"); - ASSERT_NE(nullptr, actual_ref); - AAPT_ASSERT_TRUE(actual_ref->name); - AAPT_ASSERT_TRUE(actual_ref->id); + ASSERT_THAT(actual_ref, NotNull()); + ASSERT_TRUE(actual_ref->name); + ASSERT_TRUE(actual_ref->id); EXPECT_EQ(expected_ref.name.value(), actual_ref->name.value()); EXPECT_EQ(expected_ref.id.value(), actual_ref->id.value()); } @@ -159,7 +159,7 @@ TEST(TableProtoSerializer, SerializeFileHeader) { std::unique_ptr<ResourceFile> file = DeserializeCompiledFileFromPb( new_pb_file, Source("test"), context->GetDiagnostics()); - ASSERT_NE(nullptr, file); + ASSERT_THAT(file, NotNull()); uint64_t offset, len; ASSERT_TRUE(in_file_stream.ReadDataMetaData(&offset, &len)); @@ -171,16 +171,14 @@ TEST(TableProtoSerializer, SerializeFileHeader) { EXPECT_EQ(0u, offset & 0x03); ASSERT_EQ(1u, file->exported_symbols.size()); - EXPECT_EQ(test::ParseNameOrDie("id/unchecked"), - file->exported_symbols[0].name); + EXPECT_EQ(test::ParseNameOrDie("id/unchecked"), file->exported_symbols[0].name); // Read the second compiled file. ASSERT_TRUE(in_file_stream.ReadCompiledFile(&new_pb_file)); - file = DeserializeCompiledFileFromPb(new_pb_file, Source("test"), - context->GetDiagnostics()); - ASSERT_NE(nullptr, file); + file = DeserializeCompiledFileFromPb(new_pb_file, Source("test"), context->GetDiagnostics()); + ASSERT_THAT(file, NotNull()); ASSERT_TRUE(in_file_stream.ReadDataMetaData(&offset, &len)); diff --git a/tools/aapt2/readme.md b/tools/aapt2/readme.md index 0290e30dfced..62945b1aea8d 100644 --- a/tools/aapt2/readme.md +++ b/tools/aapt2/readme.md @@ -1,9 +1,23 @@ # Android Asset Packaging Tool 2.0 (AAPT2) release notes +## Version 2.18 +### `aapt2 ...` +- Fixed issue where enum values were interpreted as integers and range checked. (bug 62358540) + ## Version 2.17 -### `aapt2 compile ...` -- Fixed an issue where symlinks would not be followed when compiling PNGs. (bug 62144459) +### `aapt2 ...` +- Fixed issue where symlinks would not be followed when compiling PNGs. (bug 62144459) - Fixed issue where overlays that declared `<add-resource>` did not compile. (bug 38355988) +- Fixed issue where `%n` in a string resource was interpreted as a format argument. (bug 37132275) +- Allow empty resources to compile, giving them a value of `""` or `@null`, depending on the + accepted formats. (bug 38425050) +- Resources declared via `<item>` with no format attribute were changed to accept all + resource types. (bug 62260121) +- Allow `<layout>` element under `<activity>` in AndroidManifest.xml. (bug 62189611) +- Fix issue where `--no-version-vector` did not apply to `pathInterpolator` and `objectAnimator`. + (bug 62211148) +- Fix issue where overlaid `<style>` would not be merged, and would replace the original resource + instead. This fix brings behavior in-line with AAPT. (bug 38355988) ## Version 2.16 ### `aapt2 link ...` diff --git a/tools/aapt2/test/Builders.h b/tools/aapt2/test/Builders.h index f3da780cacbd..6b8207647471 100644 --- a/tools/aapt2/test/Builders.h +++ b/tools/aapt2/test/Builders.h @@ -212,8 +212,7 @@ class StyleBuilder { } StyleBuilder& AddItem(const android::StringPiece& str, std::unique_ptr<Item> value) { - style_->entries.push_back( - Style::Entry{Reference(ParseNameOrDie(str)), std::move(value)}); + style_->entries.push_back(Style::Entry{Reference(ParseNameOrDie(str)), std::move(value)}); return *this; } @@ -224,7 +223,9 @@ class StyleBuilder { return *this; } - std::unique_ptr<Style> Build() { return std::move(style_); } + std::unique_ptr<Style> Build() { + return std::move(style_); + } private: DISALLOW_COPY_AND_ASSIGN(StyleBuilder); diff --git a/tools/aapt2/test/Common.h b/tools/aapt2/test/Common.h index 05851485e216..11821031b131 100644 --- a/tools/aapt2/test/Common.h +++ b/tools/aapt2/test/Common.h @@ -34,15 +34,6 @@ #include "io/File.h" #include "process/IResourceTableConsumer.h" -// -// GTEST 1.7 doesn't explicitly cast to bool, which causes explicit operators to -// fail to compile. -// -#define AAPT_ASSERT_TRUE(v) ASSERT_TRUE(bool(v)) -#define AAPT_ASSERT_FALSE(v) ASSERT_FALSE(bool(v)) -#define AAPT_EXPECT_TRUE(v) EXPECT_TRUE(bool(v)) -#define AAPT_EXPECT_FALSE(v) EXPECT_FALSE(bool(v)) - namespace aapt { namespace test { @@ -150,6 +141,23 @@ MATCHER_P(ValueEq, a, return arg.Equals(&a); } +MATCHER_P(StrValueEq, a, + std::string(negation ? "isn't" : "is") + " equal to " + ::testing::PrintToString(a)) { + return *(arg.value) == a; +} + +MATCHER_P(HasValue, name, + std::string(negation ? "does not have" : "has") + " value " + + ::testing::PrintToString(name)) { + return GetValueForConfig<Value>(&(*arg), name, {}) != nullptr; +} + +MATCHER_P2(HasValue, name, config, + std::string(negation ? "does not have" : "has") + " value " + + ::testing::PrintToString(name) + " for config " + ::testing::PrintToString(config)) { + return GetValueForConfig<Value>(&(*arg), name, config) != nullptr; +} + } // namespace test } // namespace aapt diff --git a/tools/aapt2/util/BigBuffer_test.cpp b/tools/aapt2/util/BigBuffer_test.cpp index 12c0b3ee3214..a7776e33ae74 100644 --- a/tools/aapt2/util/BigBuffer_test.cpp +++ b/tools/aapt2/util/BigBuffer_test.cpp @@ -18,12 +18,14 @@ #include "test/Test.h" +using ::testing::NotNull; + namespace aapt { TEST(BigBufferTest, AllocateSingleBlock) { BigBuffer buffer(4); - EXPECT_NE(nullptr, buffer.NextBlock<char>(2)); + EXPECT_THAT(buffer.NextBlock<char>(2), NotNull()); EXPECT_EQ(2u, buffer.size()); } @@ -31,10 +33,10 @@ TEST(BigBufferTest, ReturnSameBlockIfNextAllocationFits) { BigBuffer buffer(16); char* b1 = buffer.NextBlock<char>(8); - EXPECT_NE(nullptr, b1); + EXPECT_THAT(b1, NotNull()); char* b2 = buffer.NextBlock<char>(4); - EXPECT_NE(nullptr, b2); + EXPECT_THAT(b2, NotNull()); EXPECT_EQ(b1 + 8, b2); } @@ -42,7 +44,7 @@ TEST(BigBufferTest, ReturnSameBlockIfNextAllocationFits) { TEST(BigBufferTest, AllocateExactSizeBlockIfLargerThanBlockSize) { BigBuffer buffer(16); - EXPECT_NE(nullptr, buffer.NextBlock<char>(32)); + EXPECT_THAT(buffer.NextBlock<char>(32), NotNull()); EXPECT_EQ(32u, buffer.size()); } @@ -50,13 +52,13 @@ TEST(BigBufferTest, AppendAndMoveBlock) { BigBuffer buffer(16); uint32_t* b1 = buffer.NextBlock<uint32_t>(); - ASSERT_NE(nullptr, b1); + ASSERT_THAT(b1, NotNull()); *b1 = 33; { BigBuffer buffer2(16); b1 = buffer2.NextBlock<uint32_t>(); - ASSERT_NE(nullptr, b1); + ASSERT_THAT(b1, NotNull()); *b1 = 44; buffer.AppendBuffer(std::move(buffer2)); @@ -83,7 +85,7 @@ TEST(BigBufferTest, AppendAndMoveBlock) { TEST(BigBufferTest, PadAndAlignProperly) { BigBuffer buffer(16); - ASSERT_NE(buffer.NextBlock<char>(2), nullptr); + ASSERT_THAT(buffer.NextBlock<char>(2), NotNull()); ASSERT_EQ(2u, buffer.size()); buffer.Pad(2); ASSERT_EQ(4u, buffer.size()); diff --git a/tools/aapt2/util/Maybe_test.cpp b/tools/aapt2/util/Maybe_test.cpp index ca14793dd5c3..2057ddcc9e45 100644 --- a/tools/aapt2/util/Maybe_test.cpp +++ b/tools/aapt2/util/Maybe_test.cpp @@ -80,22 +80,22 @@ struct Dummy { TEST(MaybeTest, MakeNothing) { Maybe<int> val = make_nothing<int>(); - AAPT_EXPECT_FALSE(val); + EXPECT_FALSE(val); Maybe<std::string> val2 = make_nothing<std::string>(); - AAPT_EXPECT_FALSE(val2); + EXPECT_FALSE(val2); val2 = make_nothing<std::string>(); - AAPT_EXPECT_FALSE(val2); + EXPECT_FALSE(val2); } TEST(MaybeTest, MakeSomething) { Maybe<int> val = make_value(23); - AAPT_ASSERT_TRUE(val); + ASSERT_TRUE(val); EXPECT_EQ(23, val.value()); Maybe<std::string> val2 = make_value(std::string("hey")); - AAPT_ASSERT_TRUE(val2); + ASSERT_TRUE(val2); EXPECT_EQ(std::string("hey"), val2.value()); } diff --git a/tools/aapt2/util/Util_test.cpp b/tools/aapt2/util/Util_test.cpp index e49aee5d50ed..a09001a71efc 100644 --- a/tools/aapt2/util/Util_test.cpp +++ b/tools/aapt2/util/Util_test.cpp @@ -147,54 +147,48 @@ TEST(UtilTest, IsJavaPackageName) { TEST(UtilTest, FullyQualifiedClassName) { Maybe<std::string> res = util::GetFullyQualifiedClassName("android", ".asdf"); - AAPT_ASSERT_TRUE(res); + ASSERT_TRUE(res); EXPECT_EQ(res.value(), "android.asdf"); res = util::GetFullyQualifiedClassName("android", ".a.b"); - AAPT_ASSERT_TRUE(res); + ASSERT_TRUE(res); EXPECT_EQ(res.value(), "android.a.b"); res = util::GetFullyQualifiedClassName("android", "a.b"); - AAPT_ASSERT_TRUE(res); + ASSERT_TRUE(res); EXPECT_EQ(res.value(), "a.b"); res = util::GetFullyQualifiedClassName("", "a.b"); - AAPT_ASSERT_TRUE(res); + ASSERT_TRUE(res); EXPECT_EQ(res.value(), "a.b"); res = util::GetFullyQualifiedClassName("android", "Class"); - AAPT_ASSERT_TRUE(res); + ASSERT_TRUE(res); EXPECT_EQ(res.value(), "android.Class"); res = util::GetFullyQualifiedClassName("", ""); - AAPT_ASSERT_FALSE(res); + ASSERT_FALSE(res); res = util::GetFullyQualifiedClassName("android", "./Apple"); - AAPT_ASSERT_FALSE(res); + ASSERT_FALSE(res); } TEST(UtilTest, ExtractResourcePathComponents) { StringPiece prefix, entry, suffix; - ASSERT_TRUE(util::ExtractResFilePathParts("res/xml-sw600dp/entry.xml", - &prefix, &entry, &suffix)); + ASSERT_TRUE(util::ExtractResFilePathParts("res/xml-sw600dp/entry.xml", &prefix, &entry, &suffix)); EXPECT_EQ(prefix, "res/xml-sw600dp/"); EXPECT_EQ(entry, "entry"); EXPECT_EQ(suffix, ".xml"); - ASSERT_TRUE(util::ExtractResFilePathParts("res/xml-sw600dp/entry.9.png", - &prefix, &entry, &suffix)); - + ASSERT_TRUE(util::ExtractResFilePathParts("res/xml-sw600dp/entry.9.png", &prefix, &entry, &suffix)); EXPECT_EQ(prefix, "res/xml-sw600dp/"); EXPECT_EQ(entry, "entry"); EXPECT_EQ(suffix, ".9.png"); - EXPECT_FALSE(util::ExtractResFilePathParts("AndroidManifest.xml", &prefix, - &entry, &suffix)); - EXPECT_FALSE( - util::ExtractResFilePathParts("res/.xml", &prefix, &entry, &suffix)); + EXPECT_FALSE(util::ExtractResFilePathParts("AndroidManifest.xml", &prefix, &entry, &suffix)); + EXPECT_FALSE(util::ExtractResFilePathParts("res/.xml", &prefix, &entry, &suffix)); - ASSERT_TRUE( - util::ExtractResFilePathParts("res//.", &prefix, &entry, &suffix)); + ASSERT_TRUE(util::ExtractResFilePathParts("res//.", &prefix, &entry, &suffix)); EXPECT_EQ(prefix, "res//"); EXPECT_EQ(entry, ""); EXPECT_EQ(suffix, "."); diff --git a/tools/aapt2/xml/XmlActionExecutor_test.cpp b/tools/aapt2/xml/XmlActionExecutor_test.cpp index 7110c90fa3a9..0fe7ab05ceb2 100644 --- a/tools/aapt2/xml/XmlActionExecutor_test.cpp +++ b/tools/aapt2/xml/XmlActionExecutor_test.cpp @@ -18,6 +18,8 @@ #include "test/Test.h" +using ::testing::NotNull; + namespace aapt { namespace xml { @@ -42,12 +44,11 @@ TEST(XmlActionExecutorTest, BuildsAccessibleNestedPattern) { test::BuildXmlDom("<manifest><application /></manifest>"); StdErrDiagnostics diag; - ASSERT_TRUE( - executor.Execute(XmlActionExecutorPolicy::kNone, &diag, doc.get())); - ASSERT_NE(nullptr, manifest_el); + ASSERT_TRUE(executor.Execute(XmlActionExecutorPolicy::kNone, &diag, doc.get())); + ASSERT_THAT(manifest_el, NotNull()); EXPECT_EQ(std::string("manifest"), manifest_el->name); - ASSERT_NE(nullptr, application_el); + ASSERT_THAT(application_el, NotNull()); EXPECT_EQ(std::string("application"), application_el->name); } @@ -58,8 +59,7 @@ TEST(XmlActionExecutorTest, FailsWhenUndefinedHierarchyExists) { std::unique_ptr<XmlResource> doc = test::BuildXmlDom("<manifest><application /><activity /></manifest>"); StdErrDiagnostics diag; - ASSERT_FALSE( - executor.Execute(XmlActionExecutorPolicy::kWhitelist, &diag, doc.get())); + ASSERT_FALSE(executor.Execute(XmlActionExecutorPolicy::kWhitelist, &diag, doc.get())); } } // namespace xml diff --git a/tools/aapt2/xml/XmlDom_test.cpp b/tools/aapt2/xml/XmlDom_test.cpp index fb18ea316ca6..c1aa10b89a2f 100644 --- a/tools/aapt2/xml/XmlDom_test.cpp +++ b/tools/aapt2/xml/XmlDom_test.cpp @@ -21,6 +21,8 @@ #include "test/Test.h" +using ::testing::NotNull; + namespace aapt { constexpr const char* kXmlPreamble = @@ -41,10 +43,10 @@ TEST(XmlDomTest, Inflate) { const Source source = {"test.xml"}; StdErrDiagnostics diag; std::unique_ptr<xml::XmlResource> doc = xml::Inflate(&in, &diag, source); - ASSERT_NE(doc, nullptr); + ASSERT_THAT(doc, NotNull()); xml::Namespace* ns = xml::NodeCast<xml::Namespace>(doc->root.get()); - ASSERT_NE(ns, nullptr); + ASSERT_THAT(ns, NotNull()); EXPECT_EQ(ns->namespace_uri, xml::kSchemaAndroid); EXPECT_EQ(ns->namespace_prefix, "android"); } @@ -55,19 +57,19 @@ TEST(XmlDomTest, ForwardEscapes) { <element value="\?hello" pattern="\\d{5}">\\d{5}</element>)EOF"); xml::Element* el = xml::FindRootElement(doc->root.get()); - ASSERT_NE(nullptr, el); + ASSERT_THAT(el, NotNull()); xml::Attribute* attr = el->FindAttribute({}, "pattern"); - ASSERT_NE(nullptr, attr); + ASSERT_THAT(attr, NotNull()); EXPECT_EQ("\\\\d{5}", attr->value); attr = el->FindAttribute({}, "value"); - ASSERT_NE(nullptr, attr); + ASSERT_THAT(attr, NotNull()); EXPECT_EQ("\\?hello", attr->value); ASSERT_EQ(1u, el->children.size()); xml::Text* text = xml::NodeCast<xml::Text>(el->children[0].get()); - ASSERT_NE(nullptr, text); + ASSERT_THAT(text, NotNull()); EXPECT_EQ("\\\\d{5}", text->text); } diff --git a/tools/aapt2/xml/XmlUtil_test.cpp b/tools/aapt2/xml/XmlUtil_test.cpp index 5eecc8f5fb20..cbded8ffac8e 100644 --- a/tools/aapt2/xml/XmlUtil_test.cpp +++ b/tools/aapt2/xml/XmlUtil_test.cpp @@ -21,37 +21,30 @@ namespace aapt { TEST(XmlUtilTest, ExtractPackageFromNamespace) { - AAPT_ASSERT_FALSE(xml::ExtractPackageFromNamespace("com.android")); - AAPT_ASSERT_FALSE( - xml::ExtractPackageFromNamespace("http://schemas.android.com/apk")); - AAPT_ASSERT_FALSE( - xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res")); - AAPT_ASSERT_FALSE( - xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res/")); - AAPT_ASSERT_FALSE(xml::ExtractPackageFromNamespace( - "http://schemas.android.com/apk/prv/res/")); + ASSERT_FALSE(xml::ExtractPackageFromNamespace("com.android")); + ASSERT_FALSE(xml::ExtractPackageFromNamespace("http://schemas.android.com/apk")); + ASSERT_FALSE(xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res")); + ASSERT_FALSE(xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res/")); + ASSERT_FALSE(xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/prv/res/")); Maybe<xml::ExtractedPackage> p = xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res/a"); - AAPT_ASSERT_TRUE(p); + ASSERT_TRUE(p); EXPECT_EQ(std::string("a"), p.value().package); EXPECT_FALSE(p.value().private_namespace); - p = xml::ExtractPackageFromNamespace( - "http://schemas.android.com/apk/prv/res/android"); - AAPT_ASSERT_TRUE(p); + p = xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/prv/res/android"); + ASSERT_TRUE(p); EXPECT_EQ(std::string("android"), p.value().package); EXPECT_TRUE(p.value().private_namespace); - p = xml::ExtractPackageFromNamespace( - "http://schemas.android.com/apk/prv/res/com.test"); - AAPT_ASSERT_TRUE(p); + p = xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/prv/res/com.test"); + ASSERT_TRUE(p); EXPECT_EQ(std::string("com.test"), p.value().package); EXPECT_TRUE(p.value().private_namespace); - p = xml::ExtractPackageFromNamespace( - "http://schemas.android.com/apk/res-auto"); - AAPT_ASSERT_TRUE(p); + p = xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res-auto"); + ASSERT_TRUE(p); EXPECT_EQ(std::string(), p.value().package); EXPECT_TRUE(p.value().private_namespace); } diff --git a/tools/incident_report/Android.mk b/tools/incident_report/Android.mk index e57a95949e5a..9e56e3d7eeaf 100644 --- a/tools/incident_report/Android.mk +++ b/tools/incident_report/Android.mk @@ -34,9 +34,6 @@ LOCAL_SHARED_LIBRARIES := \ libplatformprotos \ libprotobuf-cpp-full -# b/34740546, work around clang-tidy segmentation fault. -LOCAL_TIDY_CHECKS := -modernize* - LOCAL_C_FLAGS := \ -Wno-unused-parameter include $(BUILD_HOST_EXECUTABLE) diff --git a/tools/incident_section_gen/Android.mk b/tools/incident_section_gen/Android.mk index 05490266576a..acf3f8327b5c 100644 --- a/tools/incident_section_gen/Android.mk +++ b/tools/incident_section_gen/Android.mk @@ -21,8 +21,6 @@ LOCAL_PATH:= $(call my-dir) include $(CLEAR_VARS) LOCAL_MODULE := incident-section-gen -# b/34740546, work around clang-tidy segmentation fault. -LOCAL_TIDY_CHECKS := -modernize* LOCAL_CFLAGS += -g -O0 LOCAL_C_INCLUDES := \ external/protobuf/src |