diff options
Diffstat (limited to 'tools/aapt2/ResourceParser_test.cpp')
| -rw-r--r-- | tools/aapt2/ResourceParser_test.cpp | 755 |
1 files changed, 342 insertions, 413 deletions
diff --git a/tools/aapt2/ResourceParser_test.cpp b/tools/aapt2/ResourceParser_test.cpp index c6382b177f42..e18914410871 100644 --- a/tools/aapt2/ResourceParser_test.cpp +++ b/tools/aapt2/ResourceParser_test.cpp @@ -25,11 +25,17 @@ #include "test/Test.h" #include "xml/XmlPullParser.h" +using ::aapt::test::StrValueEq; using ::aapt::test::ValueEq; +using ::android::ResTable_map; +using ::android::Res_value; using ::android::StringPiece; using ::testing::Eq; +using ::testing::IsEmpty; +using ::testing::IsNull; using ::testing::NotNull; using ::testing::Pointee; +using ::testing::SizeIs; namespace aapt { @@ -74,31 +80,26 @@ class ResourceParserTest : public ::testing::Test { }; TEST_F(ResourceParserTest, ParseQuotedString) { - std::string input = "<string name=\"foo\"> \" hey there \" </string>"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<string name="foo"> " hey there " </string>)")); String* str = test::GetValue<String>(&table_, "string/foo"); - ASSERT_NE(nullptr, str); - EXPECT_EQ(std::string(" hey there "), *str->value); - EXPECT_TRUE(str->untranslatable_sections.empty()); + ASSERT_THAT(str, NotNull()); + EXPECT_THAT(*str, StrValueEq(" hey there ")); + EXPECT_THAT(str->untranslatable_sections, IsEmpty()); } TEST_F(ResourceParserTest, ParseEscapedString) { - std::string input = "<string name=\"foo\">\\?123</string>"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<string name="foo">\?123</string>)")); String* str = test::GetValue<String>(&table_, "string/foo"); - ASSERT_NE(nullptr, str); - EXPECT_EQ(std::string("?123"), *str->value); - EXPECT_TRUE(str->untranslatable_sections.empty()); + ASSERT_THAT(str, NotNull()); + EXPECT_THAT(*str, StrValueEq("?123")); + EXPECT_THAT(str->untranslatable_sections, IsEmpty()); } 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)); + ASSERT_FALSE(TestParse(R"(<string name="foo">%d %s</string>)")); + ASSERT_TRUE(TestParse(R"(<string name="foo">%1$d %2$s</string>)")); } TEST_F(ResourceParserTest, ParseStyledString) { @@ -109,98 +110,93 @@ TEST_F(ResourceParserTest, ParseStyledString) { ASSERT_TRUE(TestParse(input)); StyledString* str = test::GetValue<StyledString>(&table_, "string/foo"); - ASSERT_NE(nullptr, str); + ASSERT_THAT(str, NotNull()); - const std::string expected_str = "This is my aunt\u2019s fickle string"; - EXPECT_EQ(expected_str, *str->value->str); - EXPECT_EQ(2u, str->value->spans.size()); - EXPECT_TRUE(str->untranslatable_sections.empty()); + EXPECT_THAT(*str->value->str, Eq("This is my aunt\u2019s fickle string")); + EXPECT_THAT(str->value->spans, SizeIs(2)); + EXPECT_THAT(str->untranslatable_sections, IsEmpty()); - EXPECT_EQ(std::string("b"), *str->value->spans[0].name); - EXPECT_EQ(17u, str->value->spans[0].first_char); - EXPECT_EQ(30u, str->value->spans[0].last_char); + EXPECT_THAT(*str->value->spans[0].name, Eq("b")); + EXPECT_THAT(str->value->spans[0].first_char, Eq(17u)); + EXPECT_THAT(str->value->spans[0].last_char, Eq(30u)); - EXPECT_EQ(std::string("small"), *str->value->spans[1].name); - EXPECT_EQ(24u, str->value->spans[1].first_char); - EXPECT_EQ(30u, str->value->spans[1].last_char); + EXPECT_THAT(*str->value->spans[1].name, Eq("small")); + EXPECT_THAT(str->value->spans[1].first_char, Eq(24u)); + EXPECT_THAT(str->value->spans[1].last_char, Eq(30u)); } TEST_F(ResourceParserTest, ParseStringWithWhitespace) { - std::string input = "<string name=\"foo\"> This is what I think </string>"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<string name="foo"> This is what I think </string>)")); String* str = test::GetValue<String>(&table_, "string/foo"); - ASSERT_NE(nullptr, str); - EXPECT_EQ(std::string("This is what I think"), *str->value); - EXPECT_TRUE(str->untranslatable_sections.empty()); + ASSERT_THAT(str, NotNull()); + EXPECT_THAT(*str->value, Eq("This is what I think")); + EXPECT_THAT(str->untranslatable_sections, IsEmpty()); - input = "<string name=\"foo2\">\" This is what I think \"</string>"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<string name="foo2">" This is what I think "</string>)")); str = test::GetValue<String>(&table_, "string/foo2"); - ASSERT_NE(nullptr, str); - EXPECT_EQ(std::string(" This is what I think "), *str->value); + ASSERT_THAT(str, NotNull()); + EXPECT_THAT(*str, StrValueEq(" This is what I think ")); } TEST_F(ResourceParserTest, IgnoreXliffTagsOtherThanG) { - std::string input = R"EOF( + std::string input = R"( <string name="foo" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"> - There are <xliff:source>no</xliff:source> apples</string>)EOF"; + There are <xliff:source>no</xliff:source> apples</string>)"; ASSERT_TRUE(TestParse(input)); String* str = test::GetValue<String>(&table_, "string/foo"); - ASSERT_NE(nullptr, str); - EXPECT_EQ(StringPiece("There are no apples"), StringPiece(*str->value)); - EXPECT_TRUE(str->untranslatable_sections.empty()); + ASSERT_THAT(str, NotNull()); + EXPECT_THAT(*str, StrValueEq("There are no apples")); + EXPECT_THAT(str->untranslatable_sections, IsEmpty()); } TEST_F(ResourceParserTest, NestedXliffGTagsAreIllegal) { - std::string input = R"EOF( + std::string input = R"( <string name="foo" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"> - Do not <xliff:g>translate <xliff:g>this</xliff:g></xliff:g></string>)EOF"; + Do not <xliff:g>translate <xliff:g>this</xliff:g></xliff:g></string>)"; EXPECT_FALSE(TestParse(input)); } TEST_F(ResourceParserTest, RecordUntranslateableXliffSectionsInString) { - std::string input = R"EOF( + std::string input = R"( <string name="foo" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"> - There are <xliff:g id="count">%1$d</xliff:g> apples</string>)EOF"; + There are <xliff:g id="count">%1$d</xliff:g> apples</string>)"; ASSERT_TRUE(TestParse(input)); String* str = test::GetValue<String>(&table_, "string/foo"); - ASSERT_NE(nullptr, str); - EXPECT_EQ(StringPiece("There are %1$d apples"), StringPiece(*str->value)); - - ASSERT_EQ(1u, str->untranslatable_sections.size()); + ASSERT_THAT(str, NotNull()); + EXPECT_THAT(*str, StrValueEq("There are %1$d apples")); + ASSERT_THAT(str->untranslatable_sections, SizeIs(1)); // We expect indices and lengths that span to include the whitespace // before %1$d. This is due to how the StringBuilder withholds whitespace unless // needed (to deal with line breaks, etc.). - EXPECT_EQ(9u, str->untranslatable_sections[0].start); - EXPECT_EQ(14u, str->untranslatable_sections[0].end); + EXPECT_THAT(str->untranslatable_sections[0].start, Eq(9u)); + EXPECT_THAT(str->untranslatable_sections[0].end, Eq(14u)); } TEST_F(ResourceParserTest, RecordUntranslateableXliffSectionsInStyledString) { - std::string input = R"EOF( + std::string input = R"( <string name="foo" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"> - There are <b><xliff:g id="count">%1$d</xliff:g></b> apples</string>)EOF"; + There are <b><xliff:g id="count">%1$d</xliff:g></b> apples</string>)"; ASSERT_TRUE(TestParse(input)); StyledString* str = test::GetValue<StyledString>(&table_, "string/foo"); - ASSERT_NE(nullptr, str); - EXPECT_EQ(StringPiece("There are %1$d apples"), StringPiece(*str->value->str)); - - ASSERT_EQ(1u, str->untranslatable_sections.size()); + ASSERT_THAT(str, NotNull()); + EXPECT_THAT(*str->value->str, Eq("There are %1$d apples")); + ASSERT_THAT(str->untranslatable_sections, SizeIs(1)); // We expect indices and lengths that span to include the whitespace // before %1$d. This is due to how the StringBuilder withholds whitespace unless // needed (to deal with line breaks, etc.). - EXPECT_EQ(9u, str->untranslatable_sections[0].start); - EXPECT_EQ(14u, str->untranslatable_sections[0].end); + EXPECT_THAT(str->untranslatable_sections[0].start, Eq(9u)); + EXPECT_THAT(str->untranslatable_sections[0].end, Eq(14u)); } TEST_F(ResourceParserTest, ParseNull) { - std::string input = "<integer name=\"foo\">@null</integer>"; + std::string input = R"(<integer name="foo">@null</integer>)"; ASSERT_TRUE(TestParse(input)); // The Android runtime treats a value of android::Res_value::TYPE_NULL as @@ -211,38 +207,36 @@ TEST_F(ResourceParserTest, ParseNull) { ASSERT_THAT(null_ref, NotNull()); EXPECT_FALSE(null_ref->name); EXPECT_FALSE(null_ref->id); - EXPECT_EQ(Reference::Type::kResource, null_ref->reference_type); + EXPECT_THAT(null_ref->reference_type, Eq(Reference::Type::kResource)); } TEST_F(ResourceParserTest, ParseEmpty) { - std::string input = "<integer name=\"foo\">@empty</integer>"; + std::string input = R"(<integer name="foo">@empty</integer>)"; ASSERT_TRUE(TestParse(input)); BinaryPrimitive* integer = test::GetValue<BinaryPrimitive>(&table_, "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); + ASSERT_THAT(integer, NotNull()); + EXPECT_THAT(integer->value.dataType, Eq(Res_value::TYPE_NULL)); + EXPECT_THAT(integer->value.data, Eq(Res_value::DATA_NULL_EMPTY)); } TEST_F(ResourceParserTest, ParseAttr) { - std::string input = - "<attr name=\"foo\" format=\"string\"/>\n" - "<attr name=\"bar\"/>"; + std::string input = R"( + <attr name="foo" format="string"/> + <attr name="bar"/>)"; ASSERT_TRUE(TestParse(input)); Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo"); - ASSERT_NE(nullptr, attr); - EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->type_mask); + ASSERT_THAT(attr, NotNull()); + EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_STRING)); attr = test::GetValue<Attribute>(&table_, "attr/bar"); - ASSERT_NE(nullptr, attr); - EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_ANY), attr->type_mask); + ASSERT_THAT(attr, NotNull()); + EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_ANY)); } -// 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. +// 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 watch_config = test::ParseConfigOrDie("watch"); std::string input = R"( @@ -252,583 +246,519 @@ TEST_F(ResourceParserTest, ParseAttrAndDeclareStyleableUnderConfigButRecordAsNoC </declare-styleable>)"; ASSERT_TRUE(TestParse(input, watch_config)); - EXPECT_EQ(nullptr, test::GetValueForConfig<Attribute>(&table_, "attr/foo", watch_config)); - EXPECT_EQ(nullptr, test::GetValueForConfig<Attribute>(&table_, "attr/baz", watch_config)); - EXPECT_EQ(nullptr, test::GetValueForConfig<Styleable>(&table_, "styleable/bar", watch_config)); + EXPECT_THAT(test::GetValueForConfig<Attribute>(&table_, "attr/foo", watch_config), IsNull()); + EXPECT_THAT(test::GetValueForConfig<Attribute>(&table_, "attr/baz", watch_config), IsNull()); + EXPECT_THAT(test::GetValueForConfig<Styleable>(&table_, "styleable/bar", watch_config), IsNull()); - EXPECT_NE(nullptr, test::GetValue<Attribute>(&table_, "attr/foo")); - EXPECT_NE(nullptr, test::GetValue<Attribute>(&table_, "attr/baz")); - EXPECT_NE(nullptr, test::GetValue<Styleable>(&table_, "styleable/bar")); + EXPECT_THAT(test::GetValue<Attribute>(&table_, "attr/foo"), NotNull()); + EXPECT_THAT(test::GetValue<Attribute>(&table_, "attr/baz"), NotNull()); + EXPECT_THAT(test::GetValue<Styleable>(&table_, "styleable/bar"), NotNull()); } TEST_F(ResourceParserTest, ParseAttrWithMinMax) { - std::string input = - "<attr name=\"foo\" min=\"10\" max=\"23\" format=\"integer\"/>"; + std::string input = R"(<attr name="foo" min="10" max="23" format="integer"/>)"; ASSERT_TRUE(TestParse(input)); Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo"); - ASSERT_NE(nullptr, attr); - EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_INTEGER), attr->type_mask); - EXPECT_EQ(10, attr->min_int); - EXPECT_EQ(23, attr->max_int); + ASSERT_THAT(attr, NotNull()); + EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_INTEGER)); + EXPECT_THAT(attr->min_int, Eq(10)); + EXPECT_THAT(attr->max_int, Eq(23)); } TEST_F(ResourceParserTest, FailParseAttrWithMinMaxButNotInteger) { - std::string input = - "<attr name=\"foo\" min=\"10\" max=\"23\" format=\"string\"/>"; - ASSERT_FALSE(TestParse(input)); + ASSERT_FALSE(TestParse(R"(<attr name="foo" min="10" max="23" format="string"/>)")); } TEST_F(ResourceParserTest, ParseUseAndDeclOfAttr) { - std::string input = - "<declare-styleable name=\"Styleable\">\n" - " <attr name=\"foo\" />\n" - "</declare-styleable>\n" - "<attr name=\"foo\" format=\"string\"/>"; + std::string input = R"( + <declare-styleable name="Styleable"> + <attr name="foo" /> + </declare-styleable> + <attr name="foo" format="string"/>)"; ASSERT_TRUE(TestParse(input)); Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo"); - ASSERT_NE(nullptr, attr); - EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->type_mask); + ASSERT_THAT(attr, NotNull()); + EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_STRING)); } 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>"; + std::string input = R"( + <declare-styleable name="Theme"> + <attr name="foo" /> + </declare-styleable> + <declare-styleable name="Window"> + <attr name="foo" format="boolean"/> + </declare-styleable>)"; ASSERT_TRUE(TestParse(input)); Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo"); - ASSERT_NE(nullptr, attr); - EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_BOOLEAN), attr->type_mask); + ASSERT_THAT(attr, NotNull()); + EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_BOOLEAN)); } 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>"; + std::string input = R"( + <attr name="foo"> + <enum name="bar" value="0"/> + <enum name="bat" value="1"/> + <enum name="baz" value="2"/> + </attr>)"; ASSERT_TRUE(TestParse(input)); Attribute* enum_attr = test::GetValue<Attribute>(&table_, "attr/foo"); - ASSERT_NE(enum_attr, nullptr); - EXPECT_EQ(enum_attr->type_mask, android::ResTable_map::TYPE_ENUM); - ASSERT_EQ(enum_attr->symbols.size(), 3u); + ASSERT_THAT(enum_attr, NotNull()); + EXPECT_THAT(enum_attr->type_mask, Eq(ResTable_map::TYPE_ENUM)); + ASSERT_THAT(enum_attr->symbols, SizeIs(3)); - AAPT_ASSERT_TRUE(enum_attr->symbols[0].symbol.name); - EXPECT_EQ(enum_attr->symbols[0].symbol.name.value().entry, "bar"); - EXPECT_EQ(enum_attr->symbols[0].value, 0u); + ASSERT_TRUE(enum_attr->symbols[0].symbol.name); + EXPECT_THAT(enum_attr->symbols[0].symbol.name.value().entry, Eq("bar")); + EXPECT_THAT(enum_attr->symbols[0].value, Eq(0u)); - AAPT_ASSERT_TRUE(enum_attr->symbols[1].symbol.name); - EXPECT_EQ(enum_attr->symbols[1].symbol.name.value().entry, "bat"); - EXPECT_EQ(enum_attr->symbols[1].value, 1u); + ASSERT_TRUE(enum_attr->symbols[1].symbol.name); + EXPECT_THAT(enum_attr->symbols[1].symbol.name.value().entry, Eq("bat")); + EXPECT_THAT(enum_attr->symbols[1].value, Eq(1u)); - AAPT_ASSERT_TRUE(enum_attr->symbols[2].symbol.name); - EXPECT_EQ(enum_attr->symbols[2].symbol.name.value().entry, "baz"); - EXPECT_EQ(enum_attr->symbols[2].value, 2u); + ASSERT_TRUE(enum_attr->symbols[2].symbol.name); + EXPECT_THAT(enum_attr->symbols[2].symbol.name.value().entry, Eq("baz")); + EXPECT_THAT(enum_attr->symbols[2].value, Eq(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>"; + std::string input = R"( + <attr name="foo"> + <flag name="bar" value="0"/> + <flag name="bat" value="1"/> + <flag name="baz" value="2"/> + </attr>)"; ASSERT_TRUE(TestParse(input)); Attribute* flag_attr = test::GetValue<Attribute>(&table_, "attr/foo"); - ASSERT_NE(nullptr, flag_attr); - EXPECT_EQ(flag_attr->type_mask, android::ResTable_map::TYPE_FLAGS); - ASSERT_EQ(flag_attr->symbols.size(), 3u); + ASSERT_THAT(flag_attr, NotNull()); + EXPECT_THAT(flag_attr->type_mask, Eq(ResTable_map::TYPE_FLAGS)); + ASSERT_THAT(flag_attr->symbols, SizeIs(3)); - AAPT_ASSERT_TRUE(flag_attr->symbols[0].symbol.name); - EXPECT_EQ(flag_attr->symbols[0].symbol.name.value().entry, "bar"); - EXPECT_EQ(flag_attr->symbols[0].value, 0u); + ASSERT_TRUE(flag_attr->symbols[0].symbol.name); + EXPECT_THAT(flag_attr->symbols[0].symbol.name.value().entry, Eq("bar")); + EXPECT_THAT(flag_attr->symbols[0].value, Eq(0u)); - AAPT_ASSERT_TRUE(flag_attr->symbols[1].symbol.name); - EXPECT_EQ(flag_attr->symbols[1].symbol.name.value().entry, "bat"); - EXPECT_EQ(flag_attr->symbols[1].value, 1u); + ASSERT_TRUE(flag_attr->symbols[1].symbol.name); + EXPECT_THAT(flag_attr->symbols[1].symbol.name.value().entry, Eq("bat")); + EXPECT_THAT(flag_attr->symbols[1].value, Eq(1u)); - AAPT_ASSERT_TRUE(flag_attr->symbols[2].symbol.name); - EXPECT_EQ(flag_attr->symbols[2].symbol.name.value().entry, "baz"); - EXPECT_EQ(flag_attr->symbols[2].value, 2u); + ASSERT_TRUE(flag_attr->symbols[2].symbol.name); + EXPECT_THAT(flag_attr->symbols[2].symbol.name.value().entry, Eq("baz")); + EXPECT_THAT(flag_attr->symbols[2].value, Eq(2u)); std::unique_ptr<BinaryPrimitive> flag_value = ResourceUtils::TryParseFlagSymbol(flag_attr, "baz|bat"); - ASSERT_NE(nullptr, flag_value); - EXPECT_EQ(flag_value->value.data, 1u | 2u); + ASSERT_THAT(flag_value, NotNull()); + EXPECT_THAT(flag_value->value.data, Eq(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>"; + std::string input = R"( + <attr name="foo"> + <enum name="bar" value="0"/> + <enum name="bat" value="1"/> + <enum name="bat" value="2"/> + </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>"; + std::string input = R"( + <style name="foo" parent="@style/fu"> + <item name="bar">#ffffffff</item> + <item name="bat">@string/hey</item> + <item name="baz"><b>hey</b></item> + </style>)"; ASSERT_TRUE(TestParse(input)); Style* style = test::GetValue<Style>(&table_, "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()); + ASSERT_THAT(style, NotNull()); + ASSERT_TRUE(style->parent); + EXPECT_THAT(style->parent.value().name, Eq(make_value(test::ParseNameOrDie("style/fu")))); + ASSERT_THAT(style->entries, SizeIs(3)); - 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()); + EXPECT_THAT(style->entries[0].key.name, Eq(make_value(test::ParseNameOrDie("attr/bar")))); + EXPECT_THAT(style->entries[1].key.name, Eq(make_value(test::ParseNameOrDie("attr/bat")))); + EXPECT_THAT(style->entries[2].key.name, Eq(make_value(test::ParseNameOrDie("attr/baz")))); } TEST_F(ResourceParserTest, ParseStyleWithShorthandParent) { - std::string input = "<style name=\"foo\" parent=\"com.app:Theme\"/>"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<style name="foo" parent="com.app:Theme"/>)")); Style* style = test::GetValue<Style>(&table_, "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()); + ASSERT_THAT(style, NotNull()); + ASSERT_TRUE(style->parent); + EXPECT_THAT(style->parent.value().name, Eq(make_value(test::ParseNameOrDie("com.app:style/Theme")))); } TEST_F(ResourceParserTest, ParseStyleWithPackageAliasedParent) { - std::string input = - "<style xmlns:app=\"http://schemas.android.com/apk/res/android\"\n" - " name=\"foo\" parent=\"app:Theme\"/>"; + std::string input = R"( + <style xmlns:app="http://schemas.android.com/apk/res/android" + name="foo" parent="app:Theme"/>)"; ASSERT_TRUE(TestParse(input)); Style* style = test::GetValue<Style>(&table_, "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()); + ASSERT_THAT(style, NotNull()); + ASSERT_TRUE(style->parent); + ASSERT_TRUE(style->parent.value().name); + EXPECT_THAT(style->parent.value().name, Eq(make_value(test::ParseNameOrDie("android:style/Theme")))); } 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>"; + std::string input = R"( + <style xmlns:app="http://schemas.android.com/apk/res/android" name="foo"> + <item name="app:bar">0</item> + </style>)"; ASSERT_TRUE(TestParse(input)); Style* style = test::GetValue<Style>(&table_, "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()); + ASSERT_THAT(style, NotNull()); + ASSERT_THAT(style->entries, SizeIs(1)); + EXPECT_THAT(style->entries[0].key.name, Eq(make_value(test::ParseNameOrDie("android:attr/bar")))); } TEST_F(ResourceParserTest, ParseStyleWithInferredParent) { - std::string input = "<style name=\"foo.bar\"/>"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<style name="foo.bar"/>)")); Style* style = test::GetValue<Style>(&table_, "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")); + ASSERT_THAT(style, NotNull()); + ASSERT_TRUE(style->parent); + EXPECT_THAT(style->parent.value().name, Eq(make_value(test::ParseNameOrDie("style/foo")))); EXPECT_TRUE(style->parent_inferred); } -TEST_F(ResourceParserTest, - ParseStyleWithInferredParentOverridenByEmptyParentAttribute) { - std::string input = "<style name=\"foo.bar\" parent=\"\"/>"; - ASSERT_TRUE(TestParse(input)); +TEST_F(ResourceParserTest, ParseStyleWithInferredParentOverridenByEmptyParentAttribute) { + ASSERT_TRUE(TestParse(R"(<style name="foo.bar" parent=""/>)")); Style* style = test::GetValue<Style>(&table_, "style/foo.bar"); - ASSERT_NE(nullptr, style); - AAPT_EXPECT_FALSE(style->parent); + ASSERT_THAT(style, NotNull()); + EXPECT_FALSE(style->parent); EXPECT_FALSE(style->parent_inferred); } TEST_F(ResourceParserTest, ParseStyleWithPrivateParentReference) { - std::string input = - R"EOF(<style name="foo" parent="*android:style/bar" />)EOF"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<style name="foo" parent="*android:style/bar" />)")); Style* style = test::GetValue<Style>(&table_, "style/foo"); - ASSERT_NE(nullptr, style); - AAPT_ASSERT_TRUE(style->parent); + ASSERT_THAT(style, NotNull()); + ASSERT_TRUE(style->parent); EXPECT_TRUE(style->parent.value().private_reference); } TEST_F(ResourceParserTest, ParseAutoGeneratedIdReference) { - std::string input = "<string name=\"foo\">@+id/bar</string>"; - ASSERT_TRUE(TestParse(input)); - - Id* id = test::GetValue<Id>(&table_, "id/bar"); - ASSERT_NE(id, nullptr); + ASSERT_TRUE(TestParse(R"(<string name="foo">@+id/bar</string>)")); + ASSERT_THAT(test::GetValue<Id>(&table_, "id/bar"), NotNull()); } 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>"; + std::string input = R"( + <declare-styleable name="foo"> + <attr name="bar" /> + <attr name="bat" format="string|reference"/> + <attr name="baz"> + <enum name="foo" value="1"/> + </attr> + </declare-styleable>)"; ASSERT_TRUE(TestParse(input)); Maybe<ResourceTable::SearchResult> result = table_.FindResource(test::ParseNameOrDie("styleable/foo")); - AAPT_ASSERT_TRUE(result); - EXPECT_EQ(SymbolState::kPublic, result.value().entry->symbol_status.state); + ASSERT_TRUE(result); + EXPECT_THAT(result.value().entry->symbol_status.state, Eq(SymbolState::kPublic)); Attribute* attr = test::GetValue<Attribute>(&table_, "attr/bar"); - ASSERT_NE(attr, nullptr); + ASSERT_THAT(attr, NotNull()); EXPECT_TRUE(attr->IsWeak()); attr = test::GetValue<Attribute>(&table_, "attr/bat"); - ASSERT_NE(attr, nullptr); + ASSERT_THAT(attr, NotNull()); EXPECT_TRUE(attr->IsWeak()); attr = test::GetValue<Attribute>(&table_, "attr/baz"); - ASSERT_NE(attr, nullptr); + ASSERT_THAT(attr, NotNull()); EXPECT_TRUE(attr->IsWeak()); - EXPECT_EQ(1u, attr->symbols.size()); + EXPECT_THAT(attr->symbols, SizeIs(1)); - EXPECT_NE(nullptr, test::GetValue<Id>(&table_, "id/foo")); + EXPECT_THAT(test::GetValue<Id>(&table_, "id/foo"), NotNull()); Styleable* styleable = test::GetValue<Styleable>(&table_, "styleable/foo"); - ASSERT_NE(styleable, nullptr); - ASSERT_EQ(3u, styleable->entries.size()); + ASSERT_THAT(styleable, NotNull()); + ASSERT_THAT(styleable->entries, SizeIs(3)); - EXPECT_EQ(test::ParseNameOrDie("attr/bar"), - styleable->entries[0].name.value()); - EXPECT_EQ(test::ParseNameOrDie("attr/bat"), - styleable->entries[1].name.value()); + EXPECT_THAT(styleable->entries[0].name, Eq(make_value(test::ParseNameOrDie("attr/bar")))); + EXPECT_THAT(styleable->entries[1].name, Eq(make_value(test::ParseNameOrDie("attr/bat")))); + EXPECT_THAT(styleable->entries[2].name, Eq(make_value(test::ParseNameOrDie("attr/baz")))); } 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>"; + std::string input = R"( + <declare-styleable xmlns:privAndroid="http://schemas.android.com/apk/prv/res/android" + name="foo"> + <attr name="*android:bar" /> + <attr name="privAndroid:bat" /> + </declare-styleable>)"; ASSERT_TRUE(TestParse(input)); Styleable* styleable = test::GetValue<Styleable>(&table_, "styleable/foo"); - ASSERT_NE(nullptr, styleable); - ASSERT_EQ(2u, styleable->entries.size()); + ASSERT_THAT(styleable, NotNull()); + ASSERT_THAT(styleable->entries, SizeIs(2)); EXPECT_TRUE(styleable->entries[0].private_reference); - AAPT_ASSERT_TRUE(styleable->entries[0].name); - EXPECT_EQ(std::string("android"), styleable->entries[0].name.value().package); + ASSERT_TRUE(styleable->entries[0].name); + EXPECT_THAT(styleable->entries[0].name.value().package, Eq("android")); EXPECT_TRUE(styleable->entries[1].private_reference); - AAPT_ASSERT_TRUE(styleable->entries[1].name); - EXPECT_EQ(std::string("android"), styleable->entries[1].name.value().package); + ASSERT_TRUE(styleable->entries[1].name); + EXPECT_THAT(styleable->entries[1].name.value().package, Eq("android")); } 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>"; + std::string input = R"( + <array name="foo"> + <item>@string/ref</item> + <item>hey</item> + <item>23</item> + </array>)"; ASSERT_TRUE(TestParse(input)); Array* array = test::GetValue<Array>(&table_, "array/foo"); - ASSERT_NE(array, nullptr); - ASSERT_EQ(3u, array->items.size()); + ASSERT_THAT(array, NotNull()); + ASSERT_THAT(array->items, SizeIs(3)); - 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())); + EXPECT_THAT(ValueCast<Reference>(array->items[0].get()), NotNull()); + EXPECT_THAT(ValueCast<String>(array->items[1].get()), NotNull()); + EXPECT_THAT(ValueCast<BinaryPrimitive>(array->items[2].get()), NotNull()); } TEST_F(ResourceParserTest, ParseStringArray) { - std::string input = R"EOF( + std::string input = R"( <string-array name="foo"> <item>"Werk"</item>" - </string-array>)EOF"; + </string-array>)"; ASSERT_TRUE(TestParse(input)); - EXPECT_NE(nullptr, test::GetValue<Array>(&table_, "array/foo")); + EXPECT_THAT(test::GetValue<Array>(&table_, "array/foo"), NotNull()); } TEST_F(ResourceParserTest, ParseArrayWithFormat) { - std::string input = R"EOF( + std::string input = R"( <array name="foo" format="string"> <item>100</item> - </array>)EOF"; + </array>)"; ASSERT_TRUE(TestParse(input)); Array* array = test::GetValue<Array>(&table_, "array/foo"); - ASSERT_NE(nullptr, array); - - ASSERT_EQ(1u, array->items.size()); + ASSERT_THAT(array, NotNull()); + ASSERT_THAT(array->items, SizeIs(1)); String* str = ValueCast<String>(array->items[0].get()); - ASSERT_NE(nullptr, str); - EXPECT_EQ(std::string("100"), *str->value); + ASSERT_THAT(str, NotNull()); + EXPECT_THAT(*str, StrValueEq("100")); } TEST_F(ResourceParserTest, ParseArrayWithBadFormat) { - std::string input = R"EOF( + std::string input = R"( <array name="foo" format="integer"> <item>Hi</item> - </array>)EOF"; + </array>)"; ASSERT_FALSE(TestParse(input)); } TEST_F(ResourceParserTest, ParsePlural) { - std::string input = - "<plurals name=\"foo\">\n" - " <item quantity=\"other\">apples</item>\n" - " <item quantity=\"one\">apple</item>\n" - "</plurals>"; + std::string input = R"( + <plurals name="foo"> + <item quantity="other">apples</item> + <item quantity="one">apple</item> + </plurals>)"; ASSERT_TRUE(TestParse(input)); Plural* plural = test::GetValue<Plural>(&table_, "plurals/foo"); - ASSERT_NE(nullptr, plural); - EXPECT_EQ(nullptr, plural->values[Plural::Zero]); - EXPECT_EQ(nullptr, plural->values[Plural::Two]); - EXPECT_EQ(nullptr, plural->values[Plural::Few]); - EXPECT_EQ(nullptr, plural->values[Plural::Many]); + ASSERT_THAT(plural, NotNull()); + EXPECT_THAT(plural->values[Plural::Zero], IsNull()); + EXPECT_THAT(plural->values[Plural::Two], IsNull()); + EXPECT_THAT(plural->values[Plural::Few], IsNull()); + EXPECT_THAT(plural->values[Plural::Many], IsNull()); - EXPECT_NE(nullptr, plural->values[Plural::One]); - EXPECT_NE(nullptr, plural->values[Plural::Other]); + EXPECT_THAT(plural->values[Plural::One], NotNull()); + EXPECT_THAT(plural->values[Plural::Other], NotNull()); } TEST_F(ResourceParserTest, ParseCommentsWithResource) { - std::string input = - "<!--This is a comment-->\n" - "<string name=\"foo\">Hi</string>"; + std::string input = R"( + <!--This is a comment--> + <string name="foo">Hi</string>)"; ASSERT_TRUE(TestParse(input)); String* value = test::GetValue<String>(&table_, "string/foo"); - ASSERT_NE(nullptr, value); - EXPECT_EQ(value->GetComment(), "This is a comment"); + ASSERT_THAT(value, NotNull()); + EXPECT_THAT(value->GetComment(), Eq("This is a comment")); } TEST_F(ResourceParserTest, DoNotCombineMultipleComments) { - std::string input = - "<!--One-->\n" - "<!--Two-->\n" - "<string name=\"foo\">Hi</string>"; + std::string input = R"( + <!--One--> + <!--Two--> + <string name="foo">Hi</string>)"; ASSERT_TRUE(TestParse(input)); String* value = test::GetValue<String>(&table_, "string/foo"); - ASSERT_NE(nullptr, value); - EXPECT_EQ(value->GetComment(), "Two"); + ASSERT_THAT(value, NotNull()); + EXPECT_THAT(value->GetComment(), Eq("Two")); } TEST_F(ResourceParserTest, IgnoreCommentBeforeEndTag) { - std::string input = - "<!--One-->\n" - "<string name=\"foo\">\n" - " Hi\n" - "<!--Two-->\n" - "</string>"; - + std::string input = R"( + <!--One--> + <string name="foo"> + Hi + <!--Two--> + </string>)"; ASSERT_TRUE(TestParse(input)); String* value = test::GetValue<String>(&table_, "string/foo"); - ASSERT_NE(nullptr, value); - EXPECT_EQ(value->GetComment(), "One"); + ASSERT_THAT(value, NotNull()); + EXPECT_THAT(value->GetComment(), Eq("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"; + // comments from those end up in R.java + std::string input = R"( + <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>)"; ASSERT_TRUE(TestParse(input)); Styleable* styleable = test::GetValue<Styleable>(&table_, "styleable/foo"); - ASSERT_NE(nullptr, styleable); - ASSERT_EQ(1u, styleable->entries.size()); - - EXPECT_EQ(StringPiece("The name of the bar"), - styleable->entries.front().GetComment()); + ASSERT_THAT(styleable, NotNull()); + ASSERT_THAT(styleable->entries, SizeIs(1)); + EXPECT_THAT(styleable->entries[0].GetComment(), Eq("The name of the bar")); Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo"); - ASSERT_NE(nullptr, attr); - ASSERT_EQ(1u, attr->symbols.size()); - - EXPECT_EQ(StringPiece("The very first"), - attr->symbols.front().symbol.GetComment()); + ASSERT_THAT(attr, NotNull()); + ASSERT_THAT(attr->symbols, SizeIs(1)); + EXPECT_THAT(attr->symbols[0].symbol.GetComment(), Eq("The very first")); } -/* - * Declaring an ID as public should not require a separate definition - * (as an ID has no value). - */ +// 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>(&table_, "id/foo"); - ASSERT_NE(nullptr, id); + ASSERT_TRUE(TestParse(R"(<public type="id" name="foo"/>)")); + ASSERT_THAT(test::GetValue<Id>(&table_, "id/foo"), NotNull()); } 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"; + std::string input = R"( + <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>)"; ASSERT_TRUE(TestParse(input)); - EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<String>( - &table_, "string/foo", - ConfigDescription::DefaultConfig(), "phone")); - EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<String>( - &table_, "string/foo", - ConfigDescription::DefaultConfig(), "no-sdcard")); - EXPECT_NE(nullptr, - test::GetValueForConfigAndProduct<String>( - &table_, "string/bar", ConfigDescription::DefaultConfig(), "")); - EXPECT_NE(nullptr, - test::GetValueForConfigAndProduct<String>( - &table_, "string/baz", ConfigDescription::DefaultConfig(), "")); - EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<String>( - &table_, "string/bit", - ConfigDescription::DefaultConfig(), "phablet")); - EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<String>( - &table_, "string/bot", - ConfigDescription::DefaultConfig(), "default")); + ASSERT_THAT(test::GetValueForConfigAndProduct<String>(&table_, "string/foo", ConfigDescription::DefaultConfig(), "phone"), NotNull()); + ASSERT_THAT(test::GetValueForConfigAndProduct<String>(&table_, "string/foo",ConfigDescription::DefaultConfig(), "no-sdcard"), NotNull()); + ASSERT_THAT(test::GetValueForConfigAndProduct<String>(&table_, "string/bar", ConfigDescription::DefaultConfig(), ""), NotNull()); + ASSERT_THAT(test::GetValueForConfigAndProduct<String>(&table_, "string/baz", ConfigDescription::DefaultConfig(), ""), NotNull()); + ASSERT_THAT(test::GetValueForConfigAndProduct<String>(&table_, "string/bit", ConfigDescription::DefaultConfig(), "phablet"), NotNull()); + ASSERT_THAT(test::GetValueForConfigAndProduct<String>(&table_, "string/bot", ConfigDescription::DefaultConfig(), "default"), NotNull()); } 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"; + std::string input = R"( + <public-group type="attr" first-id="0x01010040"> + <public name="foo" /> + <public name="bar" /> + </public-group>)"; ASSERT_TRUE(TestParse(input)); - Maybe<ResourceTable::SearchResult> result = - table_.FindResource(test::ParseNameOrDie("attr/foo")); - AAPT_ASSERT_TRUE(result); + Maybe<ResourceTable::SearchResult> result = table_.FindResource(test::ParseNameOrDie("attr/foo")); + ASSERT_TRUE(result); - AAPT_ASSERT_TRUE(result.value().package->id); - AAPT_ASSERT_TRUE(result.value().type->id); - AAPT_ASSERT_TRUE(result.value().entry->id); + ASSERT_TRUE(result.value().package->id); + ASSERT_TRUE(result.value().type->id); + ASSERT_TRUE(result.value().entry->id); ResourceId actual_id(result.value().package->id.value(), result.value().type->id.value(), result.value().entry->id.value()); - EXPECT_EQ(ResourceId(0x01010040), actual_id); + EXPECT_THAT(actual_id, Eq(ResourceId(0x01010040))); result = table_.FindResource(test::ParseNameOrDie("attr/bar")); - AAPT_ASSERT_TRUE(result); + ASSERT_TRUE(result); - AAPT_ASSERT_TRUE(result.value().package->id); - AAPT_ASSERT_TRUE(result.value().type->id); - AAPT_ASSERT_TRUE(result.value().entry->id); + ASSERT_TRUE(result.value().package->id); + ASSERT_TRUE(result.value().type->id); + ASSERT_TRUE(result.value().entry->id); actual_id = ResourceId(result.value().package->id.value(), result.value().type->id.value(), result.value().entry->id.value()); - EXPECT_EQ(ResourceId(0x01010041), actual_id); + EXPECT_THAT(actual_id, Eq(ResourceId(0x01010041))); } 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)); + ASSERT_TRUE(TestParse(R"(<item type="layout" name="foo">@layout/bar</item>)")); + ASSERT_FALSE(TestParse(R"(<item type="layout" name="bar">"this is a string"</item>)")); } TEST_F(ResourceParserTest, AddResourcesElementShouldAddEntryWithUndefinedSymbol) { - std::string input = R"EOF(<add-resource name="bar" type="string" />)EOF"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<add-resource name="bar" type="string" />)")); Maybe<ResourceTable::SearchResult> result = table_.FindResource(test::ParseNameOrDie("string/bar")); - AAPT_ASSERT_TRUE(result); + ASSERT_TRUE(result); const ResourceEntry* entry = result.value().entry; - ASSERT_NE(nullptr, entry); - EXPECT_EQ(SymbolState::kUndefined, entry->symbol_status.state); + ASSERT_THAT(entry, NotNull()); + EXPECT_THAT(entry->symbol_status.state, Eq(SymbolState::kUndefined)); EXPECT_TRUE(entry->symbol_status.allow_new); } TEST_F(ResourceParserTest, ParseItemElementWithFormat) { - std::string input = R"(<item name="foo" type="integer" format="float">0.3</item>)"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<item name="foo" type="integer" format="float">0.3</item>)")); BinaryPrimitive* val = test::GetValue<BinaryPrimitive>(&table_, "integer/foo"); ASSERT_THAT(val, NotNull()); - EXPECT_THAT(val->value.dataType, Eq(android::Res_value::TYPE_FLOAT)); + EXPECT_THAT(val->value.dataType, Eq(Res_value::TYPE_FLOAT)); - input = R"(<item name="bar" type="integer" format="fraction">100</item>)"; - ASSERT_FALSE(TestParse(input)); + ASSERT_FALSE(TestParse(R"(<item name="bar" type="integer" format="fraction">100</item>)")); } // An <item> without a format specifier accepts all types of values. TEST_F(ResourceParserTest, ParseItemElementWithoutFormat) { - std::string input = R"(<item name="foo" type="integer">100%p</item>)"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<item name="foo" type="integer">100%p</item>)")); BinaryPrimitive* val = test::GetValue<BinaryPrimitive>(&table_, "integer/foo"); ASSERT_THAT(val, NotNull()); - EXPECT_THAT(val->value.dataType, Eq(android::Res_value::TYPE_FRACTION)); + EXPECT_THAT(val->value.dataType, Eq(Res_value::TYPE_FRACTION)); } TEST_F(ResourceParserTest, ParseConfigVaryingItem) { - std::string input = R"EOF(<item name="foo" type="configVarying">Hey</item>)EOF"; - ASSERT_TRUE(TestParse(input)); - ASSERT_NE(nullptr, test::GetValue<String>(&table_, "configVarying/foo")); + ASSERT_TRUE(TestParse(R"(<item name="foo" type="configVarying">Hey</item>)")); + ASSERT_THAT(test::GetValue<String>(&table_, "configVarying/foo"), NotNull()); } TEST_F(ResourceParserTest, ParseBagElement) { - std::string input = - R"EOF(<bag name="bag" type="configVarying"><item name="test">Hello!</item></bag>)EOF"; + std::string input = R"( + <bag name="bag" type="configVarying"> + <item name="test">Hello!</item> + </bag>)"; ASSERT_TRUE(TestParse(input)); Style* val = test::GetValue<Style>(&table_, "configVarying/bag"); - ASSERT_NE(nullptr, val); + ASSERT_THAT(val, NotNull()); + ASSERT_THAT(val->entries, SizeIs(1)); - ASSERT_EQ(1u, val->entries.size()); - EXPECT_EQ(Reference(test::ParseNameOrDie("attr/test")), val->entries[0].key); - EXPECT_NE(nullptr, ValueCast<RawString>(val->entries[0].value.get())); + EXPECT_THAT(val->entries[0].key, Eq(Reference(test::ParseNameOrDie("attr/test")))); + EXPECT_THAT(ValueCast<RawString>(val->entries[0].value.get()), NotNull()); } TEST_F(ResourceParserTest, ParseElementWithNoValue) { @@ -840,12 +770,11 @@ TEST_F(ResourceParserTest, ParseElementWithNoValue) { String* str = test::GetValue<String>(&table_, "string/foo"); ASSERT_THAT(str, NotNull()); - EXPECT_THAT(*str->value, Eq("")); + EXPECT_THAT(*str, StrValueEq("")); } TEST_F(ResourceParserTest, ParsePlatformIndependentNewline) { - std::string input = R"(<string name="foo">%1$s %n %2$s</string>)"; - ASSERT_TRUE(TestParse(input)); + ASSERT_TRUE(TestParse(R"(<string name="foo">%1$s %n %2$s</string>)")); } } // namespace aapt |