| /* |
| * Copyright (C) 2015 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 "ResourceParser.h" |
| #include "ResourceTable.h" |
| #include "ResourceUtils.h" |
| #include "ResourceValues.h" |
| #include "test/Test.h" |
| #include "xml/XmlPullParser.h" |
| |
| #include <sstream> |
| #include <string> |
| |
| namespace aapt { |
| |
| constexpr const char* kXmlPreamble = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"; |
| |
| TEST(ResourceParserSingleTest, FailToParseWithNoRootResourcesElement) { |
| std::unique_ptr<IAaptContext> context = test::ContextBuilder().build(); |
| std::stringstream input(kXmlPreamble); |
| input << "<attr name=\"foo\"/>" << std::endl; |
| ResourceTable table; |
| ResourceParser parser(context->getDiagnostics(), &table, Source{ "test" }, {}); |
| xml::XmlPullParser xmlParser(input); |
| ASSERT_FALSE(parser.parse(&xmlParser)); |
| } |
| |
| struct ResourceParserTest : public ::testing::Test { |
| ResourceTable mTable; |
| std::unique_ptr<IAaptContext> mContext; |
| |
| void SetUp() override { |
| mContext = test::ContextBuilder().build(); |
| } |
| |
| ::testing::AssertionResult testParse(const StringPiece& str) { |
| return testParse(str, ConfigDescription{}); |
| } |
| |
| ::testing::AssertionResult testParse(const StringPiece& str, const ConfigDescription& config) { |
| std::stringstream input(kXmlPreamble); |
| input << "<resources>\n" << str << "\n</resources>" << std::endl; |
| ResourceParserOptions parserOptions; |
| ResourceParser parser(mContext->getDiagnostics(), &mTable, Source{ "test" }, config, |
| parserOptions); |
| xml::XmlPullParser xmlParser(input); |
| if (parser.parse(&xmlParser)) { |
| return ::testing::AssertionSuccess(); |
| } |
| return ::testing::AssertionFailure(); |
| } |
| }; |
| |
| TEST_F(ResourceParserTest, ParseQuotedString) { |
| std::string input = "<string name=\"foo\"> \" hey there \" </string>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| String* str = test::getValue<String>(&mTable, "string/foo"); |
| ASSERT_NE(nullptr, str); |
| EXPECT_EQ(std::string(" hey there "), *str->value); |
| } |
| |
| TEST_F(ResourceParserTest, ParseEscapedString) { |
| std::string input = "<string name=\"foo\">\\?123</string>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| String* str = test::getValue<String>(&mTable, "string/foo"); |
| ASSERT_NE(nullptr, str); |
| EXPECT_EQ(std::string("?123"), *str->value); |
| } |
| |
| 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)); |
| } |
| |
| TEST_F(ResourceParserTest, IgnoreXliffTags) { |
| std::string input = "<string name=\"foo\" \n" |
| " xmlns:xliff=\"urn:oasis:names:tc:xliff:document:1.2\">\n" |
| " There are <xliff:g id=\"count\">%1$d</xliff:g> apples</string>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| String* str = test::getValue<String>(&mTable, "string/foo"); |
| ASSERT_NE(nullptr, str); |
| EXPECT_EQ(StringPiece("There are %1$d apples"), StringPiece(*str->value)); |
| } |
| |
| TEST_F(ResourceParserTest, ParseNull) { |
| std::string input = "<integer name=\"foo\">@null</integer>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| // The Android runtime treats a value of android::Res_value::TYPE_NULL as |
| // a non-existing value, and this causes problems in styles when trying to resolve |
| // an attribute. Null values must be encoded as android::Res_value::TYPE_REFERENCE |
| // with a data value of 0. |
| BinaryPrimitive* integer = test::getValue<BinaryPrimitive>(&mTable, "integer/foo"); |
| ASSERT_NE(nullptr, integer); |
| EXPECT_EQ(uint16_t(android::Res_value::TYPE_REFERENCE), integer->value.dataType); |
| EXPECT_EQ(0u, integer->value.data); |
| } |
| |
| TEST_F(ResourceParserTest, ParseEmpty) { |
| std::string input = "<integer name=\"foo\">@empty</integer>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| BinaryPrimitive* integer = test::getValue<BinaryPrimitive>(&mTable, "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); |
| } |
| |
| TEST_F(ResourceParserTest, ParseAttr) { |
| std::string input = "<attr name=\"foo\" format=\"string\"/>\n" |
| "<attr name=\"bar\"/>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| Attribute* attr = test::getValue<Attribute>(&mTable, "attr/foo"); |
| ASSERT_NE(nullptr, attr); |
| EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->typeMask); |
| |
| attr = test::getValue<Attribute>(&mTable, "attr/bar"); |
| ASSERT_NE(nullptr, attr); |
| EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_ANY), attr->typeMask); |
| } |
| |
| // 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 watchConfig = test::parseConfigOrDie("watch"); |
| std::string input = R"EOF( |
| <attr name="foo" /> |
| <declare-styleable name="bar"> |
| <attr name="baz" /> |
| </declare-styleable>)EOF"; |
| ASSERT_TRUE(testParse(input, watchConfig)); |
| |
| EXPECT_EQ(nullptr, test::getValueForConfig<Attribute>(&mTable, "attr/foo", watchConfig)); |
| EXPECT_EQ(nullptr, test::getValueForConfig<Attribute>(&mTable, "attr/baz", watchConfig)); |
| EXPECT_EQ(nullptr, test::getValueForConfig<Styleable>(&mTable, "styleable/bar", watchConfig)); |
| |
| EXPECT_NE(nullptr, test::getValue<Attribute>(&mTable, "attr/foo")); |
| EXPECT_NE(nullptr, test::getValue<Attribute>(&mTable, "attr/baz")); |
| EXPECT_NE(nullptr, test::getValue<Styleable>(&mTable, "styleable/bar")); |
| } |
| |
| TEST_F(ResourceParserTest, ParseAttrWithMinMax) { |
| std::string input = "<attr name=\"foo\" min=\"10\" max=\"23\" format=\"integer\"/>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| Attribute* attr = test::getValue<Attribute>(&mTable, "attr/foo"); |
| ASSERT_NE(nullptr, attr); |
| EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_INTEGER), attr->typeMask); |
| EXPECT_EQ(10, attr->minInt); |
| EXPECT_EQ(23, attr->maxInt); |
| } |
| |
| TEST_F(ResourceParserTest, FailParseAttrWithMinMaxButNotInteger) { |
| std::string input = "<attr name=\"foo\" min=\"10\" max=\"23\" format=\"string\"/>"; |
| ASSERT_FALSE(testParse(input)); |
| } |
| |
| TEST_F(ResourceParserTest, ParseUseAndDeclOfAttr) { |
| std::string input = "<declare-styleable name=\"Styleable\">\n" |
| " <attr name=\"foo\" />\n" |
| "</declare-styleable>\n" |
| "<attr name=\"foo\" format=\"string\"/>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| Attribute* attr = test::getValue<Attribute>(&mTable, "attr/foo"); |
| ASSERT_NE(nullptr, attr); |
| EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->typeMask); |
| } |
| |
| 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>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| Attribute* attr = test::getValue<Attribute>(&mTable, "attr/foo"); |
| ASSERT_NE(nullptr, attr); |
| EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_BOOLEAN), attr->typeMask); |
| } |
| |
| 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>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| Attribute* enumAttr = test::getValue<Attribute>(&mTable, "attr/foo"); |
| ASSERT_NE(enumAttr, nullptr); |
| EXPECT_EQ(enumAttr->typeMask, android::ResTable_map::TYPE_ENUM); |
| ASSERT_EQ(enumAttr->symbols.size(), 3u); |
| |
| AAPT_ASSERT_TRUE(enumAttr->symbols[0].symbol.name); |
| EXPECT_EQ(enumAttr->symbols[0].symbol.name.value().entry, "bar"); |
| EXPECT_EQ(enumAttr->symbols[0].value, 0u); |
| |
| AAPT_ASSERT_TRUE(enumAttr->symbols[1].symbol.name); |
| EXPECT_EQ(enumAttr->symbols[1].symbol.name.value().entry, "bat"); |
| EXPECT_EQ(enumAttr->symbols[1].value, 1u); |
| |
| AAPT_ASSERT_TRUE(enumAttr->symbols[2].symbol.name); |
| EXPECT_EQ(enumAttr->symbols[2].symbol.name.value().entry, "baz"); |
| EXPECT_EQ(enumAttr->symbols[2].value, 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>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| Attribute* flagAttr = test::getValue<Attribute>(&mTable, "attr/foo"); |
| ASSERT_NE(nullptr, flagAttr); |
| EXPECT_EQ(flagAttr->typeMask, android::ResTable_map::TYPE_FLAGS); |
| ASSERT_EQ(flagAttr->symbols.size(), 3u); |
| |
| AAPT_ASSERT_TRUE(flagAttr->symbols[0].symbol.name); |
| EXPECT_EQ(flagAttr->symbols[0].symbol.name.value().entry, "bar"); |
| EXPECT_EQ(flagAttr->symbols[0].value, 0u); |
| |
| AAPT_ASSERT_TRUE(flagAttr->symbols[1].symbol.name); |
| EXPECT_EQ(flagAttr->symbols[1].symbol.name.value().entry, "bat"); |
| EXPECT_EQ(flagAttr->symbols[1].value, 1u); |
| |
| AAPT_ASSERT_TRUE(flagAttr->symbols[2].symbol.name); |
| EXPECT_EQ(flagAttr->symbols[2].symbol.name.value().entry, "baz"); |
| EXPECT_EQ(flagAttr->symbols[2].value, 2u); |
| |
| std::unique_ptr<BinaryPrimitive> flagValue = ResourceUtils::tryParseFlagSymbol(flagAttr, |
| "baz|bat"); |
| ASSERT_NE(nullptr, flagValue); |
| EXPECT_EQ(flagValue->value.data, 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>"; |
| 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>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| Style* style = test::getValue<Style>(&mTable, "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()); |
| |
| 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()); |
| } |
| |
| TEST_F(ResourceParserTest, ParseStyleWithShorthandParent) { |
| std::string input = "<style name=\"foo\" parent=\"com.app:Theme\"/>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| Style* style = test::getValue<Style>(&mTable, "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()); |
| } |
| |
| TEST_F(ResourceParserTest, ParseStyleWithPackageAliasedParent) { |
| std::string input = "<style xmlns:app=\"http://schemas.android.com/apk/res/android\"\n" |
| " name=\"foo\" parent=\"app:Theme\"/>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| Style* style = test::getValue<Style>(&mTable, "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()); |
| } |
| |
| 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>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| Style* style = test::getValue<Style>(&mTable, "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()); |
| } |
| |
| TEST_F(ResourceParserTest, ParseStyleWithInferredParent) { |
| std::string input = "<style name=\"foo.bar\"/>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| Style* style = test::getValue<Style>(&mTable, "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")); |
| EXPECT_TRUE(style->parentInferred); |
| } |
| |
| TEST_F(ResourceParserTest, ParseStyleWithInferredParentOverridenByEmptyParentAttribute) { |
| std::string input = "<style name=\"foo.bar\" parent=\"\"/>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| Style* style = test::getValue<Style>(&mTable, "style/foo.bar"); |
| ASSERT_NE(nullptr, style); |
| AAPT_EXPECT_FALSE(style->parent); |
| EXPECT_FALSE(style->parentInferred); |
| } |
| |
| TEST_F(ResourceParserTest, ParseStyleWithPrivateParentReference) { |
| std::string input = R"EOF(<style name="foo" parent="*android:style/bar" />)EOF"; |
| ASSERT_TRUE(testParse(input)); |
| |
| Style* style = test::getValue<Style>(&mTable, "style/foo"); |
| ASSERT_NE(nullptr, style); |
| AAPT_ASSERT_TRUE(style->parent); |
| EXPECT_TRUE(style->parent.value().privateReference); |
| } |
| |
| TEST_F(ResourceParserTest, ParseAutoGeneratedIdReference) { |
| std::string input = "<string name=\"foo\">@+id/bar</string>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| Id* id = test::getValue<Id>(&mTable, "id/bar"); |
| ASSERT_NE(id, nullptr); |
| } |
| |
| 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>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| Maybe<ResourceTable::SearchResult> result = |
| mTable.findResource(test::parseNameOrDie("styleable/foo")); |
| AAPT_ASSERT_TRUE(result); |
| EXPECT_EQ(SymbolState::kPublic, result.value().entry->symbolStatus.state); |
| |
| Attribute* attr = test::getValue<Attribute>(&mTable, "attr/bar"); |
| ASSERT_NE(attr, nullptr); |
| EXPECT_TRUE(attr->isWeak()); |
| |
| attr = test::getValue<Attribute>(&mTable, "attr/bat"); |
| ASSERT_NE(attr, nullptr); |
| EXPECT_TRUE(attr->isWeak()); |
| |
| attr = test::getValue<Attribute>(&mTable, "attr/baz"); |
| ASSERT_NE(attr, nullptr); |
| EXPECT_TRUE(attr->isWeak()); |
| EXPECT_EQ(1u, attr->symbols.size()); |
| |
| EXPECT_NE(nullptr, test::getValue<Id>(&mTable, "id/foo")); |
| |
| Styleable* styleable = test::getValue<Styleable>(&mTable, "styleable/foo"); |
| ASSERT_NE(styleable, nullptr); |
| ASSERT_EQ(3u, styleable->entries.size()); |
| |
| EXPECT_EQ(test::parseNameOrDie("attr/bar"), styleable->entries[0].name.value()); |
| EXPECT_EQ(test::parseNameOrDie("attr/bat"), styleable->entries[1].name.value()); |
| } |
| |
| 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>"; |
| ASSERT_TRUE(testParse(input)); |
| Styleable* styleable = test::getValue<Styleable>(&mTable, "styleable/foo"); |
| ASSERT_NE(nullptr, styleable); |
| ASSERT_EQ(2u, styleable->entries.size()); |
| |
| EXPECT_TRUE(styleable->entries[0].privateReference); |
| AAPT_ASSERT_TRUE(styleable->entries[0].name); |
| EXPECT_EQ(std::string("android"), styleable->entries[0].name.value().package); |
| |
| EXPECT_TRUE(styleable->entries[1].privateReference); |
| AAPT_ASSERT_TRUE(styleable->entries[1].name); |
| EXPECT_EQ(std::string("android"), styleable->entries[1].name.value().package); |
| } |
| |
| 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>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| Array* array = test::getValue<Array>(&mTable, "array/foo"); |
| ASSERT_NE(array, nullptr); |
| ASSERT_EQ(3u, array->items.size()); |
| |
| 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())); |
| } |
| |
| TEST_F(ResourceParserTest, ParseStringArray) { |
| std::string input = "<string-array name=\"foo\">\n" |
| " <item>\"Werk\"</item>\n" |
| "</string-array>\n"; |
| ASSERT_TRUE(testParse(input)); |
| EXPECT_NE(nullptr, test::getValue<Array>(&mTable, "array/foo")); |
| } |
| |
| TEST_F(ResourceParserTest, ParsePlural) { |
| std::string input = "<plurals name=\"foo\">\n" |
| " <item quantity=\"other\">apples</item>\n" |
| " <item quantity=\"one\">apple</item>\n" |
| "</plurals>"; |
| ASSERT_TRUE(testParse(input)); |
| } |
| |
| TEST_F(ResourceParserTest, ParseCommentsWithResource) { |
| std::string input = "<!--This is a comment-->\n" |
| "<string name=\"foo\">Hi</string>"; |
| ASSERT_TRUE(testParse(input)); |
| |
| String* value = test::getValue<String>(&mTable, "string/foo"); |
| ASSERT_NE(nullptr, value); |
| EXPECT_EQ(value->getComment(), "This is a comment"); |
| } |
| |
| TEST_F(ResourceParserTest, DoNotCombineMultipleComments) { |
| std::string input = "<!--One-->\n" |
| "<!--Two-->\n" |
| "<string name=\"foo\">Hi</string>"; |
| |
| ASSERT_TRUE(testParse(input)); |
| |
| String* value = test::getValue<String>(&mTable, "string/foo"); |
| ASSERT_NE(nullptr, value); |
| EXPECT_EQ(value->getComment(), "Two"); |
| } |
| |
| TEST_F(ResourceParserTest, IgnoreCommentBeforeEndTag) { |
| std::string input = "<!--One-->\n" |
| "<string name=\"foo\">\n" |
| " Hi\n" |
| "<!--Two-->\n" |
| "</string>"; |
| |
| ASSERT_TRUE(testParse(input)); |
| |
| String* value = test::getValue<String>(&mTable, "string/foo"); |
| ASSERT_NE(nullptr, value); |
| EXPECT_EQ(value->getComment(), "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"; |
| ASSERT_TRUE(testParse(input)); |
| |
| Styleable* styleable = test::getValue<Styleable>(&mTable, "styleable/foo"); |
| ASSERT_NE(nullptr, styleable); |
| ASSERT_EQ(1u, styleable->entries.size()); |
| |
| EXPECT_EQ(StringPiece("The name of the bar"), styleable->entries.front().getComment()); |
| |
| Attribute* attr = test::getValue<Attribute>(&mTable, "attr/foo"); |
| ASSERT_NE(nullptr, attr); |
| ASSERT_EQ(1u, attr->symbols.size()); |
| |
| EXPECT_EQ(StringPiece("The very first"), attr->symbols.front().symbol.getComment()); |
| } |
| |
| /* |
| * 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>(&mTable, "id/foo"); |
| ASSERT_NE(nullptr, id); |
| } |
| |
| 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"; |
| ASSERT_TRUE(testParse(input)); |
| |
| EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(&mTable, "string/foo", |
| ConfigDescription::defaultConfig(), |
| "phone")); |
| EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(&mTable, "string/foo", |
| ConfigDescription::defaultConfig(), |
| "no-sdcard")); |
| EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(&mTable, "string/bar", |
| ConfigDescription::defaultConfig(), |
| "")); |
| EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(&mTable, "string/baz", |
| ConfigDescription::defaultConfig(), |
| "")); |
| EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(&mTable, "string/bit", |
| ConfigDescription::defaultConfig(), |
| "phablet")); |
| EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(&mTable, "string/bot", |
| ConfigDescription::defaultConfig(), |
| "default")); |
| } |
| |
| 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"; |
| ASSERT_TRUE(testParse(input)); |
| |
| Maybe<ResourceTable::SearchResult> result = mTable.findResource( |
| test::parseNameOrDie("attr/foo")); |
| AAPT_ASSERT_TRUE(result); |
| |
| AAPT_ASSERT_TRUE(result.value().package->id); |
| AAPT_ASSERT_TRUE(result.value().type->id); |
| AAPT_ASSERT_TRUE(result.value().entry->id); |
| ResourceId actualId(result.value().package->id.value(), |
| result.value().type->id.value(), |
| result.value().entry->id.value()); |
| EXPECT_EQ(ResourceId(0x01010040), actualId); |
| |
| result = mTable.findResource(test::parseNameOrDie("attr/bar")); |
| AAPT_ASSERT_TRUE(result); |
| |
| AAPT_ASSERT_TRUE(result.value().package->id); |
| AAPT_ASSERT_TRUE(result.value().type->id); |
| AAPT_ASSERT_TRUE(result.value().entry->id); |
| actualId = ResourceId(result.value().package->id.value(), |
| result.value().type->id.value(), |
| result.value().entry->id.value()); |
| EXPECT_EQ(ResourceId(0x01010041), actualId); |
| } |
| |
| 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)); |
| } |
| |
| TEST_F(ResourceParserTest, AddResourcesElementShouldAddEntryWithUndefinedSymbol) { |
| std::string input = R"EOF(<add-resource name="bar" type="string" />)EOF"; |
| ASSERT_TRUE(testParse(input)); |
| |
| Maybe<ResourceTable::SearchResult> result = mTable.findResource( |
| test::parseNameOrDie("string/bar")); |
| AAPT_ASSERT_TRUE(result); |
| const ResourceEntry* entry = result.value().entry; |
| ASSERT_NE(nullptr, entry); |
| EXPECT_EQ(SymbolState::kUndefined, entry->symbolStatus.state); |
| } |
| |
| TEST_F(ResourceParserTest, ParseItemElementWithFormat) { |
| std::string input = R"EOF(<item name="foo" type="integer" format="float">0.3</item>)EOF"; |
| ASSERT_TRUE(testParse(input)); |
| |
| BinaryPrimitive* val = test::getValue<BinaryPrimitive>(&mTable, "integer/foo"); |
| ASSERT_NE(nullptr, val); |
| |
| EXPECT_EQ(uint32_t(android::Res_value::TYPE_FLOAT), val->value.dataType); |
| } |
| |
| } // namespace aapt |