tools/aapt2/ResourceParser_test.cpp - platform/frameworks/base - Gitiles

 /*
  * 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));

     Maybe<ResourceTable::SearchResult> result = mTable.findResource(
             test::parseNameOrDie(u"@string/foo"));
     AAPT_ASSERT_TRUE(result);

     ResourceEntry* entry = result.value().entry;
     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));

     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
	/*
	* 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));

	Maybe<ResourceTable::SearchResult> result = mTable.findResource(
	test::parseNameOrDie(u"@string/foo"));
	AAPT_ASSERT_TRUE(result);

	ResourceEntry* entry = result.value().entry;
	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));

	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