Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
e78fd617ec60139a973a01925fa7adad31febb39
frameworks_base/tools/aapt2/ResourceParser_test.cpp
Adam Lesinski e78fd617ec AAPT2: Move comments and source into Value 
Values are closely related to where they were defined, so
this information should live inside the Value.

This also enables comments to be attached to nested Values.

Change-Id: Ic7481b5a5f26d0ef248d638e2e29252f88154581
2015-10-22 16:35:47 -07:00

450 lines
17 KiB
C++
Raw Blame History

/*
* 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 "XmlPullParser.h"
#include "test/Context.h"
#include <gtest/gtest.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" }, {});
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,
Maybe<std::u16string> product = {}) {
std::stringstream input(kXmlPreamble);
input << "<resources>\n" << str << "\n</resources>" << std::endl;
ResourceParser parser(mContext->getDiagnostics(), &mTable, Source{ "test" }, {},
ResourceParserOptions{ product });
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, u"@string/foo");
ASSERT_NE(nullptr, str);
EXPECT_EQ(std::u16string(u" 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, u"@string/foo");
ASSERT_NE(nullptr, str);
EXPECT_EQ(std::u16string(u"?123"), *str->value);
}
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, u"@string/foo");
ASSERT_NE(nullptr, str);
EXPECT_EQ(StringPiece16(u"There are %1$d apples"), StringPiece16(*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, u"@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, u"@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, u"@attr/foo");
ASSERT_NE(nullptr, attr);
EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->typeMask);
attr = test::getValue<Attribute>(&mTable, u"@attr/bar");
ASSERT_NE(nullptr, attr);
EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_ANY), attr->typeMask);
}
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, u"@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, u"@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, u"@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, u"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, u"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, u"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, u"@attr/foo");
ASSERT_NE(flagAttr, nullptr);
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, u"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, u"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, u"baz");
EXPECT_EQ(flagAttr->symbols[2].value, 2u);
std::unique_ptr<BinaryPrimitive> flagValue = ResourceUtils::tryParseFlagSymbol(flagAttr,
u"baz|bat");
ASSERT_NE(flagValue, nullptr);
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, u"@style/foo");
ASSERT_NE(style, nullptr);
AAPT_ASSERT_TRUE(style->parent);
AAPT_ASSERT_TRUE(style->parent.value().name);
EXPECT_EQ(test::parseNameOrDie(u"@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(u"@attr/bar"), style->entries[0].key.name.value());
AAPT_ASSERT_TRUE(style->entries[1].key.name);
EXPECT_EQ(test::parseNameOrDie(u"@attr/bat"), style->entries[1].key.name.value());
AAPT_ASSERT_TRUE(style->entries[2].key.name);
EXPECT_EQ(test::parseNameOrDie(u"@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, u"@style/foo");
ASSERT_NE(style, nullptr);
AAPT_ASSERT_TRUE(style->parent);
AAPT_ASSERT_TRUE(style->parent.value().name);
EXPECT_EQ(test::parseNameOrDie(u"@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, u"@style/foo");
ASSERT_NE(style, nullptr);
AAPT_ASSERT_TRUE(style->parent);
AAPT_ASSERT_TRUE(style->parent.value().name);
EXPECT_EQ(test::parseNameOrDie(u"@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, u"@style/foo");
ASSERT_NE(style, nullptr);
ASSERT_EQ(1u, style->entries.size());
EXPECT_EQ(test::parseNameOrDie(u"@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, u"@style/foo.bar");
ASSERT_NE(style, nullptr);
AAPT_ASSERT_TRUE(style->parent);
AAPT_ASSERT_TRUE(style->parent.value().name);
EXPECT_EQ(style->parent.value().name.value(), test::parseNameOrDie(u"@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, u"@style/foo.bar");
ASSERT_NE(style, nullptr);
AAPT_EXPECT_FALSE(style->parent);
EXPECT_FALSE(style->parentInferred);
}
TEST_F(ResourceParserTest, ParseAutoGeneratedIdReference) {
std::string input = "<string name=\"foo\">@+id/bar</string>";
ASSERT_TRUE(testParse(input));
Id* id = test::getValue<Id>(&mTable, u"@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));
Attribute* attr = test::getValue<Attribute>(&mTable, u"@attr/bar");
ASSERT_NE(attr, nullptr);
EXPECT_TRUE(attr->isWeak());
attr = test::getValue<Attribute>(&mTable, u"@attr/bat");
ASSERT_NE(attr, nullptr);
EXPECT_TRUE(attr->isWeak());
attr = test::getValue<Attribute>(&mTable, u"@attr/baz");
ASSERT_NE(attr, nullptr);
EXPECT_TRUE(attr->isWeak());
EXPECT_EQ(1u, attr->symbols.size());
EXPECT_NE(nullptr, test::getValue<Id>(&mTable, u"@id/foo"));
Styleable* styleable = test::getValue<Styleable>(&mTable, u"@styleable/foo");
ASSERT_NE(styleable, nullptr);
ASSERT_EQ(3u, styleable->entries.size());
EXPECT_EQ(test::parseNameOrDie(u"@attr/bar"), styleable->entries[0].name.value());
EXPECT_EQ(test::parseNameOrDie(u"@attr/bat"), styleable->entries[1].name.value());
}
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, u"@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, u"@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, u"@string/foo");
ASSERT_NE(nullptr, value);
EXPECT_EQ(value->getComment(), u"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, u"@string/foo");
ASSERT_NE(nullptr, value);
EXPECT_EQ(value->getComment(), u"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, u"@string/foo");
ASSERT_NE(nullptr, value);
EXPECT_EQ(value->getComment(), u"One");
}
/*
* 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, u"@id/foo");
ASSERT_NE(nullptr, id);
}
TEST_F(ResourceParserTest, FilterProductsThatDontMatch) {
std::string input = "<string name=\"foo\" product=\"phone\">hi</string>\n"
"<string name=\"foo\" product=\"no-sdcard\">ho</string>\n"
"<string name=\"bar\" product=\"\">wee</string>\n"
"<string name=\"baz\">woo</string>\n";
ASSERT_TRUE(testParse(input, std::u16string(u"no-sdcard")));
String* fooStr = test::getValue<String>(&mTable, u"@string/foo");
ASSERT_NE(nullptr, fooStr);
EXPECT_EQ(StringPiece16(u"ho"), *fooStr->value);
EXPECT_NE(nullptr, test::getValue<String>(&mTable, u"@string/bar"));
EXPECT_NE(nullptr, test::getValue<String>(&mTable, u"@string/baz"));
}
TEST_F(ResourceParserTest, FailWhenProductFilterStripsOutAllVersionsOfResource) {
std::string input = "<string name=\"foo\" product=\"tablet\">hello</string>\n";
ASSERT_FALSE(testParse(input, std::u16string(u"phone")));
}
} // namespace aapt
Reference in New Issue View Git Blame Copy Permalink