drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
android_frameworks_base/tools/aapt2/ResourceParser_test.cpp
Adam Lesinski dfa5e0705f AAPT2: Fix issue where @null was wrongly encoded 
@null must be encoded as TYPE_REFERENCE with a value of
0. TYPE_NULL is used by the runtime as a placeholder when resolving
style attributes. If we set a style attribute to TYPE_NULL,
the runtime will throw. The runtime will convert a TYPE_REFERENCE
with value 0 to a proper null value.

Change-Id: Id983ca7e1fbee3124dddafe32f1b5741b824225b
2015-05-12 21:56:43 -07:00

493 lines
19 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 "ResourceValues.h"
#include "SourceXmlPullParser.h"
#include <gtest/gtest.h>
#include <sstream>
#include <string>
namespace aapt {
constexpr const char* kXmlPreamble = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
TEST(ResourceParserReferenceTest, ParseReferenceWithNoPackage) {
ResourceNameRef expected = { {}, ResourceType::kColor, u"foo" };
ResourceNameRef actual;
bool create = false;
bool privateRef = false;
EXPECT_TRUE(ResourceParser::tryParseReference(u"@color/foo", &actual, &create, &privateRef));
EXPECT_EQ(expected, actual);
EXPECT_FALSE(create);
EXPECT_FALSE(privateRef);
}
TEST(ResourceParserReferenceTest, ParseReferenceWithPackage) {
ResourceNameRef expected = { u"android", ResourceType::kColor, u"foo" };
ResourceNameRef actual;
bool create = false;
bool privateRef = false;
EXPECT_TRUE(ResourceParser::tryParseReference(u"@android:color/foo", &actual, &create,
&privateRef));
EXPECT_EQ(expected, actual);
EXPECT_FALSE(create);
EXPECT_FALSE(privateRef);
}
TEST(ResourceParserReferenceTest, ParseReferenceWithSurroundingWhitespace) {
ResourceNameRef expected = { u"android", ResourceType::kColor, u"foo" };
ResourceNameRef actual;
bool create = false;
bool privateRef = false;
EXPECT_TRUE(ResourceParser::tryParseReference(u"\t @android:color/foo\n \n\t", &actual,
&create, &privateRef));
EXPECT_EQ(expected, actual);
EXPECT_FALSE(create);
EXPECT_FALSE(privateRef);
}
TEST(ResourceParserReferenceTest, ParseAutoCreateIdReference) {
ResourceNameRef expected = { u"android", ResourceType::kId, u"foo" };
ResourceNameRef actual;
bool create = false;
bool privateRef = false;
EXPECT_TRUE(ResourceParser::tryParseReference(u"@+android:id/foo", &actual, &create,
&privateRef));
EXPECT_EQ(expected, actual);
EXPECT_TRUE(create);
EXPECT_FALSE(privateRef);
}
TEST(ResourceParserReferenceTest, ParsePrivateReference) {
ResourceNameRef expected = { u"android", ResourceType::kId, u"foo" };
ResourceNameRef actual;
bool create = false;
bool privateRef = false;
EXPECT_TRUE(ResourceParser::tryParseReference(u"@*android:id/foo", &actual, &create,
&privateRef));
EXPECT_EQ(expected, actual);
EXPECT_FALSE(create);
EXPECT_TRUE(privateRef);
}
TEST(ResourceParserReferenceTest, FailToParseAutoCreateNonIdReference) {
bool create = false;
bool privateRef = false;
ResourceNameRef actual;
EXPECT_FALSE(ResourceParser::tryParseReference(u"@+android:color/foo", &actual, &create,
&privateRef));
}
TEST(ResourceParserReferenceTest, ParseStyleParentReference) {
Reference ref;
std::string errStr;
EXPECT_TRUE(ResourceParser::parseStyleParentReference(u"@android:style/foo", &ref, &errStr));
EXPECT_EQ(ref.name, (ResourceName{ u"android", ResourceType::kStyle, u"foo" }));
EXPECT_TRUE(ResourceParser::parseStyleParentReference(u"@style/foo", &ref, &errStr));
EXPECT_EQ(ref.name, (ResourceName{ {}, ResourceType::kStyle, u"foo" }));
EXPECT_TRUE(ResourceParser::parseStyleParentReference(u"?android:style/foo", &ref, &errStr));
EXPECT_EQ(ref.name, (ResourceName{ u"android", ResourceType::kStyle, u"foo" }));
EXPECT_TRUE(ResourceParser::parseStyleParentReference(u"?style/foo", &ref, &errStr));
EXPECT_EQ(ref.name, (ResourceName{ {}, ResourceType::kStyle, u"foo" }));
EXPECT_TRUE(ResourceParser::parseStyleParentReference(u"android:style/foo", &ref, &errStr));
EXPECT_EQ(ref.name, (ResourceName{ u"android", ResourceType::kStyle, u"foo" }));
EXPECT_TRUE(ResourceParser::parseStyleParentReference(u"android:foo", &ref, &errStr));
EXPECT_EQ(ref.name, (ResourceName{ u"android", ResourceType::kStyle, u"foo" }));
EXPECT_TRUE(ResourceParser::parseStyleParentReference(u"foo", &ref, &errStr));
EXPECT_EQ(ref.name, (ResourceName{ {}, ResourceType::kStyle, u"foo" }));
}
struct ResourceParserTest : public ::testing::Test {
virtual void SetUp() override {
mTable = std::make_shared<ResourceTable>();
mTable->setPackage(u"android");
}
::testing::AssertionResult testParse(const StringPiece& str) {
std::stringstream input(kXmlPreamble);
input << "<resources>\n" << str << "\n</resources>" << std::endl;
ResourceParser parser(mTable, Source{ "test" }, {},
std::make_shared<SourceXmlPullParser>(input));
if (parser.parse()) {
return ::testing::AssertionSuccess();
}
return ::testing::AssertionFailure();
}
template <typename T>
const T* findResource(const ResourceNameRef& name, const ConfigDescription& config) {
using std::begin;
using std::end;
const ResourceTableType* type;
const ResourceEntry* entry;
std::tie(type, entry) = mTable->findResource(name);
if (!type || !entry) {
return nullptr;
}
for (const auto& configValue : entry->values) {
if (configValue.config == config) {
return dynamic_cast<const T*>(configValue.value.get());
}
}
return nullptr;
}
template <typename T>
const T* findResource(const ResourceNameRef& name) {
return findResource<T>(name, {});
}
std::shared_ptr<ResourceTable> mTable;
};
TEST_F(ResourceParserTest, FailToParseWithNoRootResourcesElement) {
std::stringstream input(kXmlPreamble);
input << "<attr name=\"foo\"/>" << std::endl;
ResourceParser parser(mTable, {}, {}, std::make_shared<SourceXmlPullParser>(input));
ASSERT_FALSE(parser.parse());
}
TEST_F(ResourceParserTest, ParseQuotedString) {
std::string input = "<string name=\"foo\"> \" hey there \" </string>";
ASSERT_TRUE(testParse(input));
const String* str = findResource<String>(ResourceName{
u"android", ResourceType::kString, u"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));
const String* str = findResource<String>(ResourceName{
u"android", ResourceType::kString, u"foo" });
ASSERT_NE(nullptr, str);
EXPECT_EQ(std::u16string(u"?123"), *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.
const BinaryPrimitive* integer = findResource<BinaryPrimitive>(ResourceName{
u"android", ResourceType::kInteger, u"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));
const BinaryPrimitive* integer = findResource<BinaryPrimitive>(ResourceName{
u"android", ResourceType::kInteger, u"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));
const Attribute* attr = findResource<Attribute>(ResourceName{
u"android", ResourceType::kAttr, u"foo"});
EXPECT_NE(nullptr, attr);
EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->typeMask);
attr = findResource<Attribute>(ResourceName{
u"android", ResourceType::kAttr, u"bar"});
EXPECT_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));
const Attribute* attr = findResource<Attribute>(ResourceName{
u"android", ResourceType::kAttr, u"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));
const Attribute* attr = findResource<Attribute>(ResourceName{
u"android", ResourceType::kAttr, u"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));
const Attribute* enumAttr = findResource<Attribute>(ResourceName{
u"android", ResourceType::kAttr, u"foo"});
ASSERT_NE(enumAttr, nullptr);
EXPECT_EQ(enumAttr->typeMask, android::ResTable_map::TYPE_ENUM);
ASSERT_EQ(enumAttr->symbols.size(), 3u);
EXPECT_EQ(enumAttr->symbols[0].symbol.name.entry, u"bar");
EXPECT_EQ(enumAttr->symbols[0].value, 0u);
EXPECT_EQ(enumAttr->symbols[1].symbol.name.entry, u"bat");
EXPECT_EQ(enumAttr->symbols[1].value, 1u);
EXPECT_EQ(enumAttr->symbols[2].symbol.name.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));
const Attribute* flagAttr = findResource<Attribute>(ResourceName{
u"android", ResourceType::kAttr, u"foo"});
ASSERT_NE(flagAttr, nullptr);
EXPECT_EQ(flagAttr->typeMask, android::ResTable_map::TYPE_FLAGS);
ASSERT_EQ(flagAttr->symbols.size(), 3u);
EXPECT_EQ(flagAttr->symbols[0].symbol.name.entry, u"bar");
EXPECT_EQ(flagAttr->symbols[0].value, 0u);
EXPECT_EQ(flagAttr->symbols[1].symbol.name.entry, u"bat");
EXPECT_EQ(flagAttr->symbols[1].value, 1u);
EXPECT_EQ(flagAttr->symbols[2].symbol.name.entry, u"baz");
EXPECT_EQ(flagAttr->symbols[2].value, 2u);
std::unique_ptr<BinaryPrimitive> flagValue =
ResourceParser::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));
const Style* style = findResource<Style>(ResourceName{
u"android", ResourceType::kStyle, u"foo"});
ASSERT_NE(style, nullptr);
EXPECT_EQ(ResourceNameRef(u"android", ResourceType::kStyle, u"fu"), style->parent.name);
ASSERT_EQ(style->entries.size(), 3u);
EXPECT_EQ(style->entries[0].key.name,
(ResourceName{ u"android", ResourceType::kAttr, u"bar" }));
EXPECT_EQ(style->entries[1].key.name,
(ResourceName{ u"android", ResourceType::kAttr, u"bat" }));
EXPECT_EQ(style->entries[2].key.name,
(ResourceName{ u"android", ResourceType::kAttr, u"baz" }));
}
TEST_F(ResourceParserTest, ParseStyleWithShorthandParent) {
std::string input = "<style name=\"foo\" parent=\"com.app:Theme\"/>";
ASSERT_TRUE(testParse(input));
const Style* style = findResource<Style>(
ResourceName{ u"android", ResourceType::kStyle, u"foo" });
ASSERT_NE(style, nullptr);
EXPECT_EQ(ResourceNameRef(u"com.app", ResourceType::kStyle, u"Theme"), style->parent.name);
}
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));
const Style* style = findResource<Style>(ResourceName{
u"android", ResourceType::kStyle, u"foo" });
ASSERT_NE(style, nullptr);
EXPECT_EQ(ResourceNameRef(u"android", ResourceType::kStyle, u"Theme"), style->parent.name);
}
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));
const Style* style = findResource<Style>(ResourceName{
u"android", ResourceType::kStyle, u"foo" });
ASSERT_NE(style, nullptr);
ASSERT_EQ(1u, style->entries.size());
EXPECT_EQ(ResourceNameRef(u"android", ResourceType::kAttr, u"bar"),
style->entries[0].key.name);
}
TEST_F(ResourceParserTest, ParseStyleWithInferredParent) {
std::string input = "<style name=\"foo.bar\"/>";
ASSERT_TRUE(testParse(input));
const Style* style = findResource<Style>(ResourceName{
u"android", ResourceType::kStyle, u"foo.bar" });
ASSERT_NE(style, nullptr);
EXPECT_EQ(style->parent.name, (ResourceName{ u"android", ResourceType::kStyle, u"foo" }));
EXPECT_TRUE(style->parentInferred);
}
TEST_F(ResourceParserTest, ParseStyleWithInferredParentOverridenByEmptyParentAttribute) {
std::string input = "<style name=\"foo.bar\" parent=\"\"/>";
ASSERT_TRUE(testParse(input));
const Style* style = findResource<Style>(ResourceName{
u"android", ResourceType::kStyle, u"foo.bar" });
ASSERT_NE(style, nullptr);
EXPECT_FALSE(style->parent.name.isValid());
EXPECT_FALSE(style->parentInferred);
}
TEST_F(ResourceParserTest, ParseAutoGeneratedIdReference) {
std::string input = "<string name=\"foo\">@+id/bar</string>";
ASSERT_TRUE(testParse(input));
const Id* id = findResource<Id>(ResourceName{ u"android", ResourceType::kId, u"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"
"</declare-styleable>";
ASSERT_TRUE(testParse(input));
const Attribute* attr = findResource<Attribute>(ResourceName{
u"android", ResourceType::kAttr, u"bar"});
ASSERT_NE(attr, nullptr);
EXPECT_TRUE(attr->isWeak());
attr = findResource<Attribute>(ResourceName{ u"android", ResourceType::kAttr, u"bat"});
ASSERT_NE(attr, nullptr);
EXPECT_TRUE(attr->isWeak());
const Styleable* styleable = findResource<Styleable>(ResourceName{
u"android", ResourceType::kStyleable, u"foo" });
ASSERT_NE(styleable, nullptr);
ASSERT_EQ(2u, styleable->entries.size());
EXPECT_EQ((ResourceName{u"android", ResourceType::kAttr, u"bar"}), styleable->entries[0].name);
EXPECT_EQ((ResourceName{u"android", ResourceType::kAttr, u"bat"}), styleable->entries[1].name);
}
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));
const Array* array = findResource<Array>(ResourceName{
u"android", ResourceType::kArray, u"foo" });
ASSERT_NE(array, nullptr);
ASSERT_EQ(3u, array->items.size());
EXPECT_NE(nullptr, dynamic_cast<const Reference*>(array->items[0].get()));
EXPECT_NE(nullptr, dynamic_cast<const String*>(array->items[1].get()));
EXPECT_NE(nullptr, dynamic_cast<const BinaryPrimitive*>(array->items[2].get()));
}
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));
const ResourceTableType* type;
const ResourceEntry* entry;
std::tie(type, entry) = mTable->findResource(ResourceName{
u"android", ResourceType::kString, u"foo"});
ASSERT_NE(type, nullptr);
ASSERT_NE(entry, nullptr);
ASSERT_FALSE(entry->values.empty());
EXPECT_EQ(entry->values.front().comment, u"This is a comment");
}
/*
* 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));
const Id* id = findResource<Id>(ResourceName{ u"android", ResourceType::kId, u"foo" });
ASSERT_NE(nullptr, id);
}
} // namespace aapt
Reference in New Issue View Git Blame Copy Permalink