tools/aapt2/ResourceParser_test.cpp

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