AAPT2: Clean up tests a bit
Since the latest gtest has fixed support for
explicit bool operators, remvoe AAPT_ASSERT_* and AAPT_EXPECT_*.
Also switch to use NotNull() matchers, which are more legible.
Test: make aapt2_tests
Change-Id: Idce199ca9d567d70f7aae275fee15e04bb914c9e
diff --git a/tools/aapt2/ResourceParser_test.cpp b/tools/aapt2/ResourceParser_test.cpp
index c6382b1..e189144 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 @@
};
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 @@
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 @@
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 @@
</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());
+ 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[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());
+ 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>
+ // 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>)EOF";
+ <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 @@
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
diff --git a/tools/aapt2/ResourceTable_test.cpp b/tools/aapt2/ResourceTable_test.cpp
index e2b37be..2a3c131 100644
--- a/tools/aapt2/ResourceTable_test.cpp
+++ b/tools/aapt2/ResourceTable_test.cpp
@@ -24,6 +24,8 @@
#include <ostream>
#include <string>
+using ::testing::NotNull;
+
namespace aapt {
TEST(ResourceTableTest, FailToAddResourceWithBadName) {
@@ -56,7 +58,7 @@
test::ValueBuilder<Id>().SetSource("test/path/file.xml", 23u).Build(),
test::GetDiagnostics()));
- ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:attr/id"));
+ EXPECT_THAT(test::GetValue<Id>(&table, "android:attr/id"), NotNull());
}
TEST(ResourceTableTest, AddMultipleResources) {
@@ -88,11 +90,10 @@
.Build(),
test::GetDiagnostics()));
- ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:attr/layout_width"));
- ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:attr/id"));
- ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:string/ok"));
- ASSERT_NE(nullptr, test::GetValueForConfig<BinaryPrimitive>(
- &table, "android:string/ok", language_config));
+ EXPECT_THAT(test::GetValue<Id>(&table, "android:attr/layout_width"), NotNull());
+ EXPECT_THAT(test::GetValue<Id>(&table, "android:attr/id"), NotNull());
+ EXPECT_THAT(test::GetValue<Id>(&table, "android:string/ok"), NotNull());
+ EXPECT_THAT(test::GetValueForConfig<BinaryPrimitive>(&table, "android:string/ok", language_config), NotNull());
}
TEST(ResourceTableTest, OverrideWeakResourceValue) {
@@ -103,7 +104,7 @@
util::make_unique<Attribute>(true), test::GetDiagnostics()));
Attribute* attr = test::GetValue<Attribute>(&table, "android:attr/foo");
- ASSERT_NE(nullptr, attr);
+ ASSERT_THAT(attr, NotNull());
EXPECT_TRUE(attr->IsWeak());
ASSERT_TRUE(table.AddResource(
@@ -111,7 +112,7 @@
util::make_unique<Attribute>(false), test::GetDiagnostics()));
attr = test::GetValue<Attribute>(&table, "android:attr/foo");
- ASSERT_NE(nullptr, attr);
+ ASSERT_THAT(attr, NotNull());
EXPECT_FALSE(attr->IsWeak());
}
@@ -127,16 +128,12 @@
util::make_unique<Id>(),
test::GetDiagnostics()));
- EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<Id>(
- &table, "android:string/foo",
- test::ParseConfigOrDie("land"), "tablet"));
- EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<Id>(
- &table, "android:string/foo",
- test::ParseConfigOrDie("land"), "phone"));
+ EXPECT_THAT(test::GetValueForConfigAndProduct<Id>(&table, "android:string/foo",test::ParseConfigOrDie("land"), "tablet"), NotNull());
+ EXPECT_THAT(test::GetValueForConfigAndProduct<Id>(&table, "android:string/foo",test::ParseConfigOrDie("land"), "phone"), NotNull());
Maybe<ResourceTable::SearchResult> sr =
table.FindResource(test::ParseNameOrDie("android:string/foo"));
- AAPT_ASSERT_TRUE(sr);
+ ASSERT_TRUE(sr);
std::vector<ResourceConfigValue*> values =
sr.value().entry->FindAllValues(test::ParseConfigOrDie("land"));
ASSERT_EQ(2u, values.size());
diff --git a/tools/aapt2/ResourceUtils_test.cpp b/tools/aapt2/ResourceUtils_test.cpp
index cdc34f1..3a5e685e 100644
--- a/tools/aapt2/ResourceUtils_test.cpp
+++ b/tools/aapt2/ResourceUtils_test.cpp
@@ -20,96 +20,88 @@
#include "test/Test.h"
using ::aapt::test::ValueEq;
+using ::android::Res_value;
+using ::android::ResTable_map;
+using ::testing::Eq;
+using ::testing::NotNull;
using ::testing::Pointee;
namespace aapt {
TEST(ResourceUtilsTest, ParseBool) {
- EXPECT_EQ(Maybe<bool>(true), ResourceUtils::ParseBool("true"));
- EXPECT_EQ(Maybe<bool>(true), ResourceUtils::ParseBool("TRUE"));
- EXPECT_EQ(Maybe<bool>(true), ResourceUtils::ParseBool("True"));
- EXPECT_EQ(Maybe<bool>(false), ResourceUtils::ParseBool("false"));
- EXPECT_EQ(Maybe<bool>(false), ResourceUtils::ParseBool("FALSE"));
- EXPECT_EQ(Maybe<bool>(false), ResourceUtils::ParseBool("False"));
+ EXPECT_THAT(ResourceUtils::ParseBool("true"), Eq(Maybe<bool>(true)));
+ EXPECT_THAT(ResourceUtils::ParseBool("TRUE"), Eq(Maybe<bool>(true)));
+ EXPECT_THAT(ResourceUtils::ParseBool("True"), Eq(Maybe<bool>(true)));
+
+ EXPECT_THAT(ResourceUtils::ParseBool("false"), Eq(Maybe<bool>(false)));
+ EXPECT_THAT(ResourceUtils::ParseBool("FALSE"), Eq(Maybe<bool>(false)));
+ EXPECT_THAT(ResourceUtils::ParseBool("False"), Eq(Maybe<bool>(false)));
}
TEST(ResourceUtilsTest, ParseResourceName) {
ResourceNameRef actual;
bool actual_priv = false;
- EXPECT_TRUE(ResourceUtils::ParseResourceName("android:color/foo", &actual,
- &actual_priv));
- EXPECT_EQ(ResourceNameRef("android", ResourceType::kColor, "foo"), actual);
+ EXPECT_TRUE(ResourceUtils::ParseResourceName("android:color/foo", &actual, &actual_priv));
+ EXPECT_THAT(actual, Eq(ResourceNameRef("android", ResourceType::kColor, "foo")));
EXPECT_FALSE(actual_priv);
- EXPECT_TRUE(
- ResourceUtils::ParseResourceName("color/foo", &actual, &actual_priv));
- EXPECT_EQ(ResourceNameRef({}, ResourceType::kColor, "foo"), actual);
+ EXPECT_TRUE(ResourceUtils::ParseResourceName("color/foo", &actual, &actual_priv));
+ EXPECT_THAT(actual, Eq(ResourceNameRef({}, ResourceType::kColor, "foo")));
EXPECT_FALSE(actual_priv);
- EXPECT_TRUE(ResourceUtils::ParseResourceName("*android:color/foo", &actual,
- &actual_priv));
- EXPECT_EQ(ResourceNameRef("android", ResourceType::kColor, "foo"), actual);
+ EXPECT_TRUE(ResourceUtils::ParseResourceName("*android:color/foo", &actual, &actual_priv));
+ EXPECT_THAT(actual, Eq(ResourceNameRef("android", ResourceType::kColor, "foo")));
EXPECT_TRUE(actual_priv);
EXPECT_FALSE(ResourceUtils::ParseResourceName(android::StringPiece(), &actual, &actual_priv));
}
TEST(ResourceUtilsTest, ParseReferenceWithNoPackage) {
- ResourceNameRef expected({}, ResourceType::kColor, "foo");
ResourceNameRef actual;
bool create = false;
bool private_ref = false;
- EXPECT_TRUE(ResourceUtils::ParseReference("@color/foo", &actual, &create,
- &private_ref));
- EXPECT_EQ(expected, actual);
+ EXPECT_TRUE(ResourceUtils::ParseReference("@color/foo", &actual, &create, &private_ref));
+ EXPECT_THAT(actual, Eq(ResourceNameRef({}, ResourceType::kColor, "foo")));
EXPECT_FALSE(create);
EXPECT_FALSE(private_ref);
}
TEST(ResourceUtilsTest, ParseReferenceWithPackage) {
- ResourceNameRef expected("android", ResourceType::kColor, "foo");
ResourceNameRef actual;
bool create = false;
bool private_ref = false;
- EXPECT_TRUE(ResourceUtils::ParseReference("@android:color/foo", &actual,
- &create, &private_ref));
- EXPECT_EQ(expected, actual);
+ EXPECT_TRUE(ResourceUtils::ParseReference("@android:color/foo", &actual, &create, &private_ref));
+ EXPECT_THAT(actual, Eq(ResourceNameRef("android", ResourceType::kColor, "foo")));
EXPECT_FALSE(create);
EXPECT_FALSE(private_ref);
}
TEST(ResourceUtilsTest, ParseReferenceWithSurroundingWhitespace) {
- ResourceNameRef expected("android", ResourceType::kColor, "foo");
ResourceNameRef actual;
bool create = false;
bool private_ref = false;
- EXPECT_TRUE(ResourceUtils::ParseReference("\t @android:color/foo\n \n\t",
- &actual, &create, &private_ref));
- EXPECT_EQ(expected, actual);
+ EXPECT_TRUE(ResourceUtils::ParseReference("\t @android:color/foo\n \n\t", &actual, &create, &private_ref));
+ EXPECT_THAT(actual, Eq(ResourceNameRef("android", ResourceType::kColor, "foo")));
EXPECT_FALSE(create);
EXPECT_FALSE(private_ref);
}
TEST(ResourceUtilsTest, ParseAutoCreateIdReference) {
- ResourceNameRef expected("android", ResourceType::kId, "foo");
ResourceNameRef actual;
bool create = false;
bool private_ref = false;
- EXPECT_TRUE(ResourceUtils::ParseReference("@+android:id/foo", &actual,
- &create, &private_ref));
- EXPECT_EQ(expected, actual);
+ EXPECT_TRUE(ResourceUtils::ParseReference("@+android:id/foo", &actual, &create, &private_ref));
+ EXPECT_THAT(actual, Eq(ResourceNameRef("android", ResourceType::kId, "foo")));
EXPECT_TRUE(create);
EXPECT_FALSE(private_ref);
}
TEST(ResourceUtilsTest, ParsePrivateReference) {
- ResourceNameRef expected("android", ResourceType::kId, "foo");
ResourceNameRef actual;
bool create = false;
bool private_ref = false;
- EXPECT_TRUE(ResourceUtils::ParseReference("@*android:id/foo", &actual,
- &create, &private_ref));
- EXPECT_EQ(expected, actual);
+ EXPECT_TRUE(ResourceUtils::ParseReference("@*android:id/foo", &actual, &create, &private_ref));
+ EXPECT_THAT(actual, Eq(ResourceNameRef("android", ResourceType::kId, "foo")));
EXPECT_FALSE(create);
EXPECT_TRUE(private_ref);
}
@@ -118,8 +110,7 @@
bool create = false;
bool private_ref = false;
ResourceNameRef actual;
- EXPECT_FALSE(ResourceUtils::ParseReference("@+android:color/foo", &actual,
- &create, &private_ref));
+ EXPECT_FALSE(ResourceUtils::ParseReference("@+android:color/foo", &actual, &create, &private_ref));
}
TEST(ResourceUtilsTest, ParseAttributeReferences) {
@@ -143,82 +134,69 @@
}
TEST(ResourceUtilsTest, ParseStyleParentReference) {
- const ResourceName kAndroidStyleFooName("android", ResourceType::kStyle,
- "foo");
+ const ResourceName kAndroidStyleFooName("android", ResourceType::kStyle, "foo");
const ResourceName kStyleFooName({}, ResourceType::kStyle, "foo");
std::string err_str;
- Maybe<Reference> ref =
- ResourceUtils::ParseStyleParentReference("@android:style/foo", &err_str);
- AAPT_ASSERT_TRUE(ref);
- EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
+ Maybe<Reference> ref = ResourceUtils::ParseStyleParentReference("@android:style/foo", &err_str);
+ ASSERT_TRUE(ref);
+ EXPECT_THAT(ref.value().name, Eq(make_value(kAndroidStyleFooName)));
ref = ResourceUtils::ParseStyleParentReference("@style/foo", &err_str);
- AAPT_ASSERT_TRUE(ref);
- EXPECT_EQ(ref.value().name.value(), kStyleFooName);
+ ASSERT_TRUE(ref);
+ EXPECT_THAT(ref.value().name, Eq(make_value(kStyleFooName)));
- ref =
- ResourceUtils::ParseStyleParentReference("?android:style/foo", &err_str);
- AAPT_ASSERT_TRUE(ref);
- EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
+ ref = ResourceUtils::ParseStyleParentReference("?android:style/foo", &err_str);
+ ASSERT_TRUE(ref);
+ EXPECT_THAT(ref.value().name, Eq(make_value(kAndroidStyleFooName)));
ref = ResourceUtils::ParseStyleParentReference("?style/foo", &err_str);
- AAPT_ASSERT_TRUE(ref);
- EXPECT_EQ(ref.value().name.value(), kStyleFooName);
+ ASSERT_TRUE(ref);
+ EXPECT_THAT(ref.value().name, Eq(make_value(kStyleFooName)));
ref = ResourceUtils::ParseStyleParentReference("android:style/foo", &err_str);
- AAPT_ASSERT_TRUE(ref);
- EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
+ ASSERT_TRUE(ref);
+ EXPECT_THAT(ref.value().name, Eq(make_value(kAndroidStyleFooName)));
ref = ResourceUtils::ParseStyleParentReference("android:foo", &err_str);
- AAPT_ASSERT_TRUE(ref);
- EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
+ ASSERT_TRUE(ref);
+ EXPECT_THAT(ref.value().name, Eq(make_value(kAndroidStyleFooName)));
ref = ResourceUtils::ParseStyleParentReference("@android:foo", &err_str);
- AAPT_ASSERT_TRUE(ref);
- EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
+ ASSERT_TRUE(ref);
+ EXPECT_THAT(ref.value().name, Eq(make_value(kAndroidStyleFooName)));
ref = ResourceUtils::ParseStyleParentReference("foo", &err_str);
- AAPT_ASSERT_TRUE(ref);
- EXPECT_EQ(ref.value().name.value(), kStyleFooName);
+ ASSERT_TRUE(ref);
+ EXPECT_THAT(ref.value().name, Eq(make_value(kStyleFooName)));
- ref =
- ResourceUtils::ParseStyleParentReference("*android:style/foo", &err_str);
- AAPT_ASSERT_TRUE(ref);
- EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
+ ref = ResourceUtils::ParseStyleParentReference("*android:style/foo", &err_str);
+ ASSERT_TRUE(ref);
+ EXPECT_THAT(ref.value().name, Eq(make_value(kAndroidStyleFooName)));
EXPECT_TRUE(ref.value().private_reference);
}
TEST(ResourceUtilsTest, ParseEmptyFlag) {
std::unique_ptr<Attribute> attr =
test::AttributeBuilder(false)
- .SetTypeMask(android::ResTable_map::TYPE_FLAGS)
+ .SetTypeMask(ResTable_map::TYPE_FLAGS)
.AddItem("one", 0x01)
.AddItem("two", 0x02)
.Build();
- std::unique_ptr<BinaryPrimitive> result =
- ResourceUtils::TryParseFlagSymbol(attr.get(), "");
- ASSERT_NE(nullptr, result);
- EXPECT_EQ(0u, result->value.data);
+ std::unique_ptr<BinaryPrimitive> result = ResourceUtils::TryParseFlagSymbol(attr.get(), "");
+ ASSERT_THAT(result, NotNull());
+ EXPECT_THAT(result->value.data, Eq(0u));
}
TEST(ResourceUtilsTest, NullIsEmptyReference) {
- auto null_value = ResourceUtils::MakeNull();
- ASSERT_THAT(null_value, Pointee(ValueEq(Reference())));
-
- auto value = ResourceUtils::TryParseNullOrEmpty("@null");
- ASSERT_THAT(value, Pointee(ValueEq(Reference())));
+ ASSERT_THAT(ResourceUtils::MakeNull(), Pointee(ValueEq(Reference())));
+ ASSERT_THAT(ResourceUtils::TryParseNullOrEmpty("@null"), Pointee(ValueEq(Reference())));
}
TEST(ResourceUtilsTest, EmptyIsBinaryPrimitive) {
- auto empty_value = ResourceUtils::MakeEmpty();
- ASSERT_THAT(empty_value, Pointee(ValueEq(BinaryPrimitive(android::Res_value::TYPE_NULL,
- android::Res_value::DATA_NULL_EMPTY))));
-
- auto value = ResourceUtils::TryParseNullOrEmpty("@empty");
- ASSERT_THAT(value, Pointee(ValueEq(BinaryPrimitive(android::Res_value::TYPE_NULL,
- android::Res_value::DATA_NULL_EMPTY))));
+ ASSERT_THAT(ResourceUtils::MakeEmpty(), Pointee(ValueEq(BinaryPrimitive(Res_value::TYPE_NULL, Res_value::DATA_NULL_EMPTY))));
+ ASSERT_THAT(ResourceUtils::TryParseNullOrEmpty("@empty"), Pointee(ValueEq(BinaryPrimitive(Res_value::TYPE_NULL, Res_value::DATA_NULL_EMPTY))));
}
} // namespace aapt
diff --git a/tools/aapt2/compile/IdAssigner_test.cpp b/tools/aapt2/compile/IdAssigner_test.cpp
index d465091..5cff004 100644
--- a/tools/aapt2/compile/IdAssigner_test.cpp
+++ b/tools/aapt2/compile/IdAssigner_test.cpp
@@ -64,12 +64,12 @@
// Expect to fill in the gaps between 0x0101XXXX and 0x0104XXXX.
maybe_result = table->FindResource(test::ParseNameOrDie("android:dimen/two"));
- AAPT_ASSERT_TRUE(maybe_result);
+ ASSERT_TRUE(maybe_result);
EXPECT_EQ(make_value<uint8_t>(2), maybe_result.value().type->id);
maybe_result =
table->FindResource(test::ParseNameOrDie("android:integer/three"));
- AAPT_ASSERT_TRUE(maybe_result);
+ ASSERT_TRUE(maybe_result);
EXPECT_EQ(make_value<uint8_t>(3), maybe_result.value().type->id);
// Expect to bypass the reserved 0x0104XXXX IDs and use the next 0x0105XXXX
@@ -77,17 +77,17 @@
maybe_result =
table->FindResource(test::ParseNameOrDie("android:string/five"));
- AAPT_ASSERT_TRUE(maybe_result);
+ ASSERT_TRUE(maybe_result);
EXPECT_EQ(make_value<uint8_t>(5), maybe_result.value().type->id);
// Expect to fill in the gaps between 0x01040000 and 0x01040006.
maybe_result = table->FindResource(test::ParseNameOrDie("android:attr/bar"));
- AAPT_ASSERT_TRUE(maybe_result);
+ ASSERT_TRUE(maybe_result);
EXPECT_EQ(make_value<uint16_t>(1), maybe_result.value().entry->id);
maybe_result = table->FindResource(test::ParseNameOrDie("android:attr/baz"));
- AAPT_ASSERT_TRUE(maybe_result);
+ ASSERT_TRUE(maybe_result);
EXPECT_EQ(make_value<uint16_t>(2), maybe_result.value().entry->id);
}
@@ -121,7 +121,7 @@
ASSERT_TRUE(VerifyIds(table.get()));
Maybe<ResourceTable::SearchResult> result =
table->FindResource(test::ParseNameOrDie("android:attr/foo"));
- AAPT_ASSERT_TRUE(result);
+ ASSERT_TRUE(result);
const ResourceTable::SearchResult& search_result = result.value();
EXPECT_EQ(make_value<uint8_t>(0x01), search_result.package->id);
diff --git a/tools/aapt2/flatten/TableFlattener_test.cpp b/tools/aapt2/flatten/TableFlattener_test.cpp
index 6d1350d..4fdb2ec 100644
--- a/tools/aapt2/flatten/TableFlattener_test.cpp
+++ b/tools/aapt2/flatten/TableFlattener_test.cpp
@@ -26,6 +26,9 @@
using namespace android;
+using ::testing::IsNull;
+using ::testing::NotNull;
+
namespace aapt {
class TableFlattenerTest : public ::testing::Test {
@@ -235,13 +238,12 @@
ResourceTable result;
ASSERT_TRUE(Flatten(context_.get(), {}, table.get(), &result));
- Attribute* actualAttr =
- test::GetValue<Attribute>(&result, "android:attr/foo");
- ASSERT_NE(nullptr, actualAttr);
- EXPECT_EQ(attr.IsWeak(), actualAttr->IsWeak());
- EXPECT_EQ(attr.type_mask, actualAttr->type_mask);
- EXPECT_EQ(attr.min_int, actualAttr->min_int);
- EXPECT_EQ(attr.max_int, actualAttr->max_int);
+ Attribute* actual_attr = test::GetValue<Attribute>(&result, "android:attr/foo");
+ ASSERT_THAT(actual_attr, NotNull());
+ EXPECT_EQ(attr.IsWeak(), actual_attr->IsWeak());
+ EXPECT_EQ(attr.type_mask, actual_attr->type_mask);
+ EXPECT_EQ(attr.min_int, actual_attr->min_int);
+ EXPECT_EQ(attr.max_int, actual_attr->max_int);
}
static std::unique_ptr<ResourceTable> BuildTableWithSparseEntries(
@@ -303,15 +305,13 @@
auto value = test::GetValueForConfig<BinaryPrimitive>(&sparse_table, "android:string/foo_0",
sparse_config);
- ASSERT_NE(nullptr, value);
+ ASSERT_THAT(value, NotNull());
EXPECT_EQ(0u, value->value.data);
- ASSERT_EQ(nullptr, test::GetValueForConfig<BinaryPrimitive>(&sparse_table, "android:string/foo_1",
- sparse_config));
+ ASSERT_THAT(test::GetValueForConfig<BinaryPrimitive>(&sparse_table, "android:string/foo_1", sparse_config), IsNull());
- value = test::GetValueForConfig<BinaryPrimitive>(&sparse_table, "android:string/foo_4",
- sparse_config);
- ASSERT_NE(nullptr, value);
+ value = test::GetValueForConfig<BinaryPrimitive>(&sparse_table, "android:string/foo_4", sparse_config);
+ ASSERT_THAT(value, NotNull());
EXPECT_EQ(4u, value->value.data);
}
@@ -372,7 +372,7 @@
Maybe<ResourceTable::SearchResult> search_result =
result.FindResource(test::ParseNameOrDie("lib:id/foo"));
- AAPT_ASSERT_TRUE(search_result);
+ ASSERT_TRUE(search_result);
EXPECT_EQ(0x00u, search_result.value().package->id.value());
auto iter = result.included_packages_.find(0x00);
@@ -398,7 +398,7 @@
ASSERT_TRUE(Flatten(context.get(), {}, table.get(), &result));
const DynamicRefTable* dynamic_ref_table = result.getDynamicRefTableForCookie(1);
- ASSERT_NE(nullptr, dynamic_ref_table);
+ ASSERT_THAT(dynamic_ref_table, NotNull());
const KeyedVector<String16, uint8_t>& entries = dynamic_ref_table->entries();
@@ -423,7 +423,7 @@
ASSERT_TRUE(Flatten(context.get(), {}, table.get(), &result));
const DynamicRefTable* dynamic_ref_table = result.getDynamicRefTableForCookie(1);
- ASSERT_NE(nullptr, dynamic_ref_table);
+ ASSERT_THAT(dynamic_ref_table, NotNull());
const KeyedVector<String16, uint8_t>& entries = dynamic_ref_table->entries();
ssize_t idx = entries.indexOfKey(android::String16("app"));
diff --git a/tools/aapt2/link/AutoVersioner_test.cpp b/tools/aapt2/link/AutoVersioner_test.cpp
index 755af0a..49639f8 100644
--- a/tools/aapt2/link/AutoVersioner_test.cpp
+++ b/tools/aapt2/link/AutoVersioner_test.cpp
@@ -19,43 +19,34 @@
#include "ConfigDescription.h"
#include "test/Test.h"
+using ::testing::NotNull;
+
namespace aapt {
TEST(AutoVersionerTest, GenerateVersionedResources) {
const ConfigDescription land_config = test::ParseConfigOrDie("land");
- const ConfigDescription sw600dp_land_config =
- test::ParseConfigOrDie("sw600dp-land");
+ const ConfigDescription sw600dp_land_config = test::ParseConfigOrDie("sw600dp-land");
ResourceEntry entry("foo");
- entry.values.push_back(util::make_unique<ResourceConfigValue>(
- ConfigDescription::DefaultConfig(), ""));
- entry.values.push_back(
- util::make_unique<ResourceConfigValue>(land_config, ""));
- entry.values.push_back(
- util::make_unique<ResourceConfigValue>(sw600dp_land_config, ""));
+ entry.values.push_back(util::make_unique<ResourceConfigValue>(ConfigDescription::DefaultConfig(), ""));
+ entry.values.push_back(util::make_unique<ResourceConfigValue>(land_config, ""));
+ entry.values.push_back(util::make_unique<ResourceConfigValue>(sw600dp_land_config, ""));
- EXPECT_TRUE(ShouldGenerateVersionedResource(
- &entry, ConfigDescription::DefaultConfig(), 17));
+ EXPECT_TRUE(ShouldGenerateVersionedResource(&entry, ConfigDescription::DefaultConfig(), 17));
EXPECT_TRUE(ShouldGenerateVersionedResource(&entry, land_config, 17));
}
TEST(AutoVersionerTest, GenerateVersionedResourceWhenHigherVersionExists) {
- const ConfigDescription sw600dp_v13_config =
- test::ParseConfigOrDie("sw600dp-v13");
+ const ConfigDescription sw600dp_v13_config = test::ParseConfigOrDie("sw600dp-v13");
const ConfigDescription v21_config = test::ParseConfigOrDie("v21");
ResourceEntry entry("foo");
- entry.values.push_back(util::make_unique<ResourceConfigValue>(
- ConfigDescription::DefaultConfig(), ""));
- entry.values.push_back(
- util::make_unique<ResourceConfigValue>(sw600dp_v13_config, ""));
- entry.values.push_back(
- util::make_unique<ResourceConfigValue>(v21_config, ""));
+ entry.values.push_back(util::make_unique<ResourceConfigValue>(ConfigDescription::DefaultConfig(), ""));
+ entry.values.push_back(util::make_unique<ResourceConfigValue>(sw600dp_v13_config, ""));
+ entry.values.push_back(util::make_unique<ResourceConfigValue>(v21_config, ""));
- EXPECT_TRUE(ShouldGenerateVersionedResource(
- &entry, ConfigDescription::DefaultConfig(), 17));
- EXPECT_FALSE(ShouldGenerateVersionedResource(
- &entry, ConfigDescription::DefaultConfig(), 22));
+ EXPECT_TRUE(ShouldGenerateVersionedResource(&entry, ConfigDescription::DefaultConfig(), 17));
+ EXPECT_FALSE(ShouldGenerateVersionedResource(&entry, ConfigDescription::DefaultConfig(), 22));
}
TEST(AutoVersionerTest, VersionStylesForTable) {
@@ -92,46 +83,28 @@
AutoVersioner versioner;
ASSERT_TRUE(versioner.Consume(context.get(), table.get()));
- Style* style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo",
- test::ParseConfigOrDie("v4"));
- ASSERT_NE(style, nullptr);
+ Style* style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo", test::ParseConfigOrDie("v4"));
+ ASSERT_THAT(style, NotNull());
ASSERT_EQ(style->entries.size(), 1u);
- AAPT_ASSERT_TRUE(style->entries.front().key.name);
- EXPECT_EQ(style->entries.front().key.name.value(),
- test::ParseNameOrDie("android:attr/onClick"));
+ EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/onClick")), style->entries.front().key.name);
- style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo",
- test::ParseConfigOrDie("v13"));
- ASSERT_NE(style, nullptr);
+ style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo", test::ParseConfigOrDie("v13"));
+ ASSERT_THAT(style, NotNull());
ASSERT_EQ(style->entries.size(), 2u);
- AAPT_ASSERT_TRUE(style->entries[0].key.name);
- EXPECT_EQ(style->entries[0].key.name.value(),
- test::ParseNameOrDie("android:attr/onClick"));
- AAPT_ASSERT_TRUE(style->entries[1].key.name);
- EXPECT_EQ(style->entries[1].key.name.value(),
- test::ParseNameOrDie("android:attr/requiresSmallestWidthDp"));
+ EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/onClick")),style->entries[0].key.name);
+ EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/requiresSmallestWidthDp")), style->entries[1].key.name);
- style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo",
- test::ParseConfigOrDie("v17"));
- ASSERT_NE(style, nullptr);
+ style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo", test::ParseConfigOrDie("v17"));
+ ASSERT_THAT(style, NotNull());
ASSERT_EQ(style->entries.size(), 3u);
- AAPT_ASSERT_TRUE(style->entries[0].key.name);
- EXPECT_EQ(style->entries[0].key.name.value(),
- test::ParseNameOrDie("android:attr/onClick"));
- AAPT_ASSERT_TRUE(style->entries[1].key.name);
- EXPECT_EQ(style->entries[1].key.name.value(),
- test::ParseNameOrDie("android:attr/requiresSmallestWidthDp"));
- AAPT_ASSERT_TRUE(style->entries[2].key.name);
- EXPECT_EQ(style->entries[2].key.name.value(),
- test::ParseNameOrDie("android:attr/paddingStart"));
+ EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/onClick")), style->entries[0].key.name);
+ EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/requiresSmallestWidthDp")), style->entries[1].key.name);
+ EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/paddingStart")), style->entries[2].key.name);
- style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo",
- test::ParseConfigOrDie("v21"));
- ASSERT_NE(style, nullptr);
- ASSERT_EQ(style->entries.size(), 1u);
- AAPT_ASSERT_TRUE(style->entries.front().key.name);
- EXPECT_EQ(style->entries.front().key.name.value(),
- test::ParseNameOrDie("android:attr/paddingEnd"));
+ style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo", test::ParseConfigOrDie("v21"));
+ ASSERT_THAT(style, NotNull());
+ ASSERT_EQ(1u, style->entries.size());
+ EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/paddingEnd")), style->entries.front().key.name);
}
} // namespace aapt
diff --git a/tools/aapt2/link/ReferenceLinker_test.cpp b/tools/aapt2/link/ReferenceLinker_test.cpp
index d8e33a4..72a9168 100644
--- a/tools/aapt2/link/ReferenceLinker_test.cpp
+++ b/tools/aapt2/link/ReferenceLinker_test.cpp
@@ -19,6 +19,7 @@
#include "test/Test.h"
using android::ResTable_map;
+using ::testing::NotNull;
namespace aapt {
@@ -54,18 +55,18 @@
ASSERT_TRUE(linker.Consume(context.get(), table.get()));
Reference* ref = test::GetValue<Reference>(table.get(), "com.app.test:string/foo");
- ASSERT_NE(nullptr, ref);
- AAPT_ASSERT_TRUE(ref->id);
+ ASSERT_THAT(ref, NotNull());
+ ASSERT_TRUE(ref->id);
EXPECT_EQ(ResourceId(0x7f020001), ref->id.value());
ref = test::GetValue<Reference>(table.get(), "com.app.test:string/bar");
- ASSERT_NE(nullptr, ref);
- AAPT_ASSERT_TRUE(ref->id);
+ ASSERT_THAT(ref, NotNull());
+ ASSERT_TRUE(ref->id);
EXPECT_EQ(ResourceId(0x7f020002), ref->id.value());
ref = test::GetValue<Reference>(table.get(), "com.app.test:string/baz");
- ASSERT_NE(nullptr, ref);
- AAPT_ASSERT_TRUE(ref->id);
+ ASSERT_THAT(ref, NotNull());
+ ASSERT_TRUE(ref->id);
EXPECT_EQ(ResourceId(0x01040034), ref->id.value());
}
@@ -84,10 +85,9 @@
{
// We need to fill in the value for the attribute android:attr/bar after we
- // build the
- // table, because we need access to the string pool.
+ // build the table, because we need access to the string pool.
Style* style = test::GetValue<Style>(table.get(), "com.app.test:style/Theme");
- ASSERT_NE(nullptr, style);
+ ASSERT_THAT(style, NotNull());
style->entries.back().value =
util::make_unique<RawString>(table->string_pool.MakeRef("one|two"));
}
@@ -118,20 +118,20 @@
ASSERT_TRUE(linker.Consume(context.get(), table.get()));
Style* style = test::GetValue<Style>(table.get(), "com.app.test:style/Theme");
- ASSERT_NE(nullptr, style);
- AAPT_ASSERT_TRUE(style->parent);
- AAPT_ASSERT_TRUE(style->parent.value().id);
+ ASSERT_THAT(style, NotNull());
+ ASSERT_TRUE(style->parent);
+ ASSERT_TRUE(style->parent.value().id);
EXPECT_EQ(ResourceId(0x01060000), style->parent.value().id.value());
ASSERT_EQ(2u, style->entries.size());
- AAPT_ASSERT_TRUE(style->entries[0].key.id);
+ ASSERT_TRUE(style->entries[0].key.id);
EXPECT_EQ(ResourceId(0x01010001), style->entries[0].key.id.value());
- ASSERT_NE(nullptr, ValueCast<BinaryPrimitive>(style->entries[0].value.get()));
+ ASSERT_THAT(ValueCast<BinaryPrimitive>(style->entries[0].value.get()), NotNull());
- AAPT_ASSERT_TRUE(style->entries[1].key.id);
+ ASSERT_TRUE(style->entries[1].key.id);
EXPECT_EQ(ResourceId(0x01010002), style->entries[1].key.id.value());
- ASSERT_NE(nullptr, ValueCast<BinaryPrimitive>(style->entries[1].value.get()));
+ ASSERT_THAT(ValueCast<BinaryPrimitive>(style->entries[1].value.get()), NotNull());
}
TEST(ReferenceLinkerTest, LinkMangledReferencesAndAttributes) {
@@ -165,9 +165,9 @@
ASSERT_TRUE(linker.Consume(context.get(), table.get()));
Style* style = test::GetValue<Style>(table.get(), "com.app.test:style/Theme");
- ASSERT_NE(nullptr, style);
+ ASSERT_THAT(style, NotNull());
ASSERT_EQ(1u, style->entries.size());
- AAPT_ASSERT_TRUE(style->entries.front().key.id);
+ ASSERT_TRUE(style->entries.front().key.id);
EXPECT_EQ(ResourceId(0x7f010000), style->entries.front().key.id.value());
}
@@ -266,7 +266,7 @@
const CallSite call_site{ResourceNameRef("com.app.test", ResourceType::kString, "foo")};
const SymbolTable::Symbol* symbol = ReferenceLinker::ResolveSymbolCheckVisibility(
*test::BuildReference("com.app.test:string/foo"), call_site, &table, &error);
- ASSERT_NE(nullptr, symbol);
+ ASSERT_THAT(symbol, NotNull());
EXPECT_TRUE(error.empty());
}
@@ -283,12 +283,12 @@
std::string error;
const CallSite call_site{ResourceNameRef("com.app.ext", ResourceType::kLayout, "foo")};
- AAPT_EXPECT_FALSE(ReferenceLinker::CompileXmlAttribute(
+ EXPECT_FALSE(ReferenceLinker::CompileXmlAttribute(
*test::BuildReference("com.app.test:attr/foo"), call_site, &table, &error));
EXPECT_FALSE(error.empty());
error = "";
- AAPT_ASSERT_TRUE(ReferenceLinker::CompileXmlAttribute(
+ ASSERT_TRUE(ReferenceLinker::CompileXmlAttribute(
*test::BuildReference("com.app.test:attr/public_foo"), call_site, &table, &error));
EXPECT_TRUE(error.empty());
}
diff --git a/tools/aapt2/link/XmlReferenceLinker_test.cpp b/tools/aapt2/link/XmlReferenceLinker_test.cpp
index de81e73..228cfb9 100644
--- a/tools/aapt2/link/XmlReferenceLinker_test.cpp
+++ b/tools/aapt2/link/XmlReferenceLinker_test.cpp
@@ -18,6 +18,9 @@
#include "test/Test.h"
+using ::testing::IsNull;
+using ::testing::NotNull;
+
namespace aapt {
class XmlReferenceLinkerTest : public ::testing::Test {
@@ -90,56 +93,48 @@
ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
xml::Element* view_el = xml::FindRootElement(doc.get());
- ASSERT_NE(nullptr, view_el);
+ ASSERT_THAT(view_el, NotNull());
xml::Attribute* xml_attr = view_el->FindAttribute(xml::kSchemaAndroid, "layout_width");
- ASSERT_NE(nullptr, xml_attr);
- AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
- AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
- EXPECT_EQ(ResourceId(0x01010000), xml_attr->compiled_attribute.value().id.value());
- ASSERT_NE(nullptr, xml_attr->compiled_value);
- ASSERT_NE(nullptr, ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()));
+ ASSERT_THAT(xml_attr, NotNull());
+ ASSERT_TRUE(xml_attr->compiled_attribute);
+ EXPECT_EQ(make_value(ResourceId(0x01010000)), xml_attr->compiled_attribute.value().id);
+ EXPECT_THAT(ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()), NotNull());
xml_attr = view_el->FindAttribute(xml::kSchemaAndroid, "background");
- ASSERT_NE(nullptr, xml_attr);
- AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
- AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
- EXPECT_EQ(ResourceId(0x01010001), xml_attr->compiled_attribute.value().id.value());
- ASSERT_NE(nullptr, xml_attr->compiled_value);
+ ASSERT_THAT(xml_attr, NotNull());
+ ASSERT_TRUE(xml_attr->compiled_attribute);
+ EXPECT_EQ(make_value(ResourceId(0x01010001)), xml_attr->compiled_attribute.value().id);
Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get());
- ASSERT_NE(nullptr, ref);
- AAPT_ASSERT_TRUE(ref->name);
- EXPECT_EQ(test::ParseNameOrDie("color/green"), ref->name.value()); // Make sure the name
- // didn't change.
- AAPT_ASSERT_TRUE(ref->id);
- EXPECT_EQ(ResourceId(0x7f020000), ref->id.value());
+ ASSERT_THAT(ref, NotNull());
+ EXPECT_EQ(make_value(test::ParseNameOrDie("color/green")), ref->name); // Make sure the name
+ // didn't change.
+ EXPECT_EQ(make_value(ResourceId(0x7f020000)), ref->id);
xml_attr = view_el->FindAttribute(xml::kSchemaAndroid, "text");
- ASSERT_NE(nullptr, xml_attr);
- AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
- ASSERT_FALSE(xml_attr->compiled_value); // Strings don't get compiled for memory sake.
+ ASSERT_THAT(xml_attr, NotNull());
+ EXPECT_TRUE(xml_attr->compiled_attribute);
+ EXPECT_THAT(xml_attr->compiled_value, IsNull()); // Strings don't get compiled for memory sake.
xml_attr = view_el->FindAttribute(xml::kSchemaAndroid, "attr");
- ASSERT_NE(nullptr, xml_attr);
- AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
- ASSERT_FALSE(xml_attr->compiled_value); // Should be a plain string.
+ ASSERT_THAT(xml_attr, NotNull());
+ EXPECT_TRUE(xml_attr->compiled_attribute);
+ EXPECT_THAT(xml_attr->compiled_value, IsNull()); // Should be a plain string.
xml_attr = view_el->FindAttribute("", "nonAaptAttr");
- ASSERT_NE(nullptr, xml_attr);
- AAPT_ASSERT_FALSE(xml_attr->compiled_attribute);
- ASSERT_NE(nullptr, xml_attr->compiled_value);
- ASSERT_NE(nullptr, ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()));
+ ASSERT_THAT(xml_attr, NotNull());
+ EXPECT_FALSE(xml_attr->compiled_attribute);
+ EXPECT_THAT(ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()), NotNull());
xml_attr = view_el->FindAttribute("", "nonAaptAttrRef");
- ASSERT_NE(nullptr, xml_attr);
- AAPT_ASSERT_FALSE(xml_attr->compiled_attribute);
- ASSERT_NE(nullptr, xml_attr->compiled_value);
- ASSERT_NE(nullptr, ValueCast<Reference>(xml_attr->compiled_value.get()));
+ ASSERT_THAT(xml_attr, NotNull());
+ EXPECT_FALSE(xml_attr->compiled_attribute);
+ EXPECT_THAT(ValueCast<Reference>(xml_attr->compiled_value.get()), NotNull());
xml_attr = view_el->FindAttribute("", "class");
- ASSERT_NE(nullptr, xml_attr);
- AAPT_ASSERT_FALSE(xml_attr->compiled_attribute);
- ASSERT_EQ(nullptr, xml_attr->compiled_value);
+ ASSERT_THAT(xml_attr, NotNull());
+ EXPECT_FALSE(xml_attr->compiled_attribute);
+ EXPECT_THAT(xml_attr->compiled_value, IsNull());
}
TEST_F(XmlReferenceLinkerTest, PrivateSymbolsAreNotLinked) {
@@ -169,15 +164,14 @@
ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
xml::Element* view_el = xml::FindRootElement(doc.get());
- ASSERT_NE(view_el, nullptr);
+ ASSERT_THAT(view_el, NotNull());
xml::Attribute* xml_attr =
view_el->FindAttribute(xml::BuildPackageNamespace("com.android.support"), "colorAccent");
- ASSERT_NE(xml_attr, nullptr);
- AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
- AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
- EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(), ResourceId(0x7f010001));
- ASSERT_NE(ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()), nullptr);
+ ASSERT_THAT(xml_attr, NotNull());
+ ASSERT_TRUE(xml_attr->compiled_attribute);
+ EXPECT_EQ(make_value(ResourceId(0x7f010001)), xml_attr->compiled_attribute.value().id);
+ EXPECT_THAT(ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()), NotNull());
}
TEST_F(XmlReferenceLinkerTest, LinkAutoResReference) {
@@ -189,18 +183,16 @@
ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
xml::Element* view_el = xml::FindRootElement(doc.get());
- ASSERT_NE(view_el, nullptr);
+ ASSERT_THAT(view_el, NotNull());
xml::Attribute* xml_attr = view_el->FindAttribute(xml::kSchemaAuto, "colorAccent");
- ASSERT_NE(xml_attr, nullptr);
- AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
- AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
- EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(), ResourceId(0x7f010000));
+ ASSERT_THAT(xml_attr, NotNull());
+ ASSERT_TRUE(xml_attr->compiled_attribute);
+ EXPECT_EQ(make_value(ResourceId(0x7f010000)), xml_attr->compiled_attribute.value().id);
Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get());
- ASSERT_NE(ref, nullptr);
- AAPT_ASSERT_TRUE(ref->name);
- AAPT_ASSERT_TRUE(ref->id);
- EXPECT_EQ(ref->id.value(), ResourceId(0x7f020001));
+ ASSERT_THAT(ref, NotNull());
+ ASSERT_TRUE(ref->name);
+ EXPECT_EQ(make_value(ResourceId(0x7f020001)), ref->id);
}
TEST_F(XmlReferenceLinkerTest, LinkViewWithShadowedPackageAlias) {
@@ -215,35 +207,31 @@
ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
xml::Element* view_el = xml::FindRootElement(doc.get());
- ASSERT_NE(view_el, nullptr);
+ ASSERT_THAT(view_el, NotNull());
// All attributes and references in this element should be referring to
// "android" (0x01).
xml::Attribute* xml_attr = view_el->FindAttribute(xml::kSchemaAndroid, "attr");
- ASSERT_NE(xml_attr, nullptr);
- AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
- AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
- EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(), ResourceId(0x01010002));
+ ASSERT_THAT(xml_attr, NotNull());
+ ASSERT_TRUE(xml_attr->compiled_attribute);
+ EXPECT_EQ(make_value(ResourceId(0x01010002)), xml_attr->compiled_attribute.value().id);
Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get());
- ASSERT_NE(ref, nullptr);
- AAPT_ASSERT_TRUE(ref->id);
- EXPECT_EQ(ref->id.value(), ResourceId(0x01030000));
+ ASSERT_THAT(ref, NotNull());
+ EXPECT_EQ(make_value(ResourceId(0x01030000)), ref->id);
ASSERT_FALSE(view_el->GetChildElements().empty());
view_el = view_el->GetChildElements().front();
- ASSERT_NE(view_el, nullptr);
+ ASSERT_THAT(view_el, NotNull());
// All attributes and references in this element should be referring to
// "com.app.test" (0x7f).
xml_attr = view_el->FindAttribute(xml::BuildPackageNamespace("com.app.test"), "attr");
- ASSERT_NE(xml_attr, nullptr);
- AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
- AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
- EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(), ResourceId(0x7f010002));
+ ASSERT_THAT(xml_attr, NotNull());
+ ASSERT_TRUE(xml_attr->compiled_attribute);
+ EXPECT_EQ(make_value(ResourceId(0x7f010002)), xml_attr->compiled_attribute.value().id);
ref = ValueCast<Reference>(xml_attr->compiled_value.get());
- ASSERT_NE(ref, nullptr);
- AAPT_ASSERT_TRUE(ref->id);
- EXPECT_EQ(ref->id.value(), ResourceId(0x7f030000));
+ ASSERT_THAT(ref, NotNull());
+ EXPECT_EQ(make_value(ResourceId(0x7f030000)), ref->id);
}
TEST_F(XmlReferenceLinkerTest, LinkViewWithLocalPackageAndAliasOfTheSameName) {
@@ -255,20 +243,17 @@
ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
xml::Element* view_el = xml::FindRootElement(doc.get());
- ASSERT_NE(view_el, nullptr);
+ ASSERT_THAT(view_el, NotNull());
// All attributes and references in this element should be referring to
// "com.app.test" (0x7f).
- xml::Attribute* xml_attr =
- view_el->FindAttribute(xml::BuildPackageNamespace("com.app.test"), "attr");
- ASSERT_NE(xml_attr, nullptr);
- AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
- AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
- EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(), ResourceId(0x7f010002));
+ xml::Attribute* xml_attr = view_el->FindAttribute(xml::BuildPackageNamespace("com.app.test"), "attr");
+ ASSERT_THAT(xml_attr, NotNull());
+ ASSERT_TRUE(xml_attr->compiled_attribute);
+ EXPECT_EQ(make_value(ResourceId(0x7f010002)), xml_attr->compiled_attribute.value().id);
Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get());
- ASSERT_NE(ref, nullptr);
- AAPT_ASSERT_TRUE(ref->id);
- EXPECT_EQ(ref->id.value(), ResourceId(0x7f030000));
+ ASSERT_THAT(ref, NotNull());
+ EXPECT_EQ(make_value(ResourceId(0x7f030000)), ref->id);
}
} // namespace aapt
diff --git a/tools/aapt2/proto/TableProtoSerializer_test.cpp b/tools/aapt2/proto/TableProtoSerializer_test.cpp
index e6ce6d3..3ebb08e 100644
--- a/tools/aapt2/proto/TableProtoSerializer_test.cpp
+++ b/tools/aapt2/proto/TableProtoSerializer_test.cpp
@@ -20,6 +20,7 @@
#include "test/Test.h"
using ::google::protobuf::io::StringOutputStream;
+using ::testing::NotNull;
namespace aapt {
@@ -46,8 +47,7 @@
// Make a plural.
std::unique_ptr<Plural> plural = util::make_unique<Plural>();
- plural->values[Plural::One] =
- util::make_unique<String>(table->string_pool.MakeRef("one"));
+ plural->values[Plural::One] = util::make_unique<String>(table->string_pool.MakeRef("one"));
ASSERT_TRUE(table->AddResource(test::ParseNameOrDie("com.app.a:plurals/hey"),
ConfigDescription{}, {}, std::move(plural),
context->GetDiagnostics()));
@@ -77,19 +77,19 @@
context->GetDiagnostics()));
std::unique_ptr<pb::ResourceTable> pb_table = SerializeTableToPb(table.get());
- ASSERT_NE(nullptr, pb_table);
+ ASSERT_THAT(pb_table, NotNull());
std::unique_ptr<ResourceTable> new_table = DeserializeTableFromPb(
*pb_table, Source{"test"}, context->GetDiagnostics());
- ASSERT_NE(nullptr, new_table);
+ ASSERT_THAT(new_table, NotNull());
Id* new_id = test::GetValue<Id>(new_table.get(), "com.app.a:id/foo");
- ASSERT_NE(nullptr, new_id);
+ ASSERT_THAT(new_id, NotNull());
EXPECT_EQ(id->IsWeak(), new_id->IsWeak());
Maybe<ResourceTable::SearchResult> result =
new_table->FindResource(test::ParseNameOrDie("com.app.a:layout/main"));
- AAPT_ASSERT_TRUE(result);
+ ASSERT_TRUE(result);
EXPECT_EQ(SymbolState::kPublic, result.value().type->symbol_status.state);
EXPECT_EQ(SymbolState::kPublic, result.value().entry->symbol_status.state);
@@ -101,18 +101,18 @@
// Find the product-dependent values
BinaryPrimitive* prim = test::GetValueForConfigAndProduct<BinaryPrimitive>(
new_table.get(), "com.app.a:integer/one", test::ParseConfigOrDie("land"), "");
- ASSERT_NE(nullptr, prim);
+ ASSERT_THAT(prim, NotNull());
EXPECT_EQ(123u, prim->value.data);
prim = test::GetValueForConfigAndProduct<BinaryPrimitive>(
new_table.get(), "com.app.a:integer/one", test::ParseConfigOrDie("land"), "tablet");
- ASSERT_NE(nullptr, prim);
+ ASSERT_THAT(prim, NotNull());
EXPECT_EQ(321u, prim->value.data);
Reference* actual_ref = test::GetValue<Reference>(new_table.get(), "com.app.a:layout/abc");
- ASSERT_NE(nullptr, actual_ref);
- AAPT_ASSERT_TRUE(actual_ref->name);
- AAPT_ASSERT_TRUE(actual_ref->id);
+ ASSERT_THAT(actual_ref, NotNull());
+ ASSERT_TRUE(actual_ref->name);
+ ASSERT_TRUE(actual_ref->id);
EXPECT_EQ(expected_ref.name.value(), actual_ref->name.value());
EXPECT_EQ(expected_ref.id.value(), actual_ref->id.value());
}
@@ -159,7 +159,7 @@
std::unique_ptr<ResourceFile> file = DeserializeCompiledFileFromPb(
new_pb_file, Source("test"), context->GetDiagnostics());
- ASSERT_NE(nullptr, file);
+ ASSERT_THAT(file, NotNull());
uint64_t offset, len;
ASSERT_TRUE(in_file_stream.ReadDataMetaData(&offset, &len));
@@ -171,16 +171,14 @@
EXPECT_EQ(0u, offset & 0x03);
ASSERT_EQ(1u, file->exported_symbols.size());
- EXPECT_EQ(test::ParseNameOrDie("id/unchecked"),
- file->exported_symbols[0].name);
+ EXPECT_EQ(test::ParseNameOrDie("id/unchecked"), file->exported_symbols[0].name);
// Read the second compiled file.
ASSERT_TRUE(in_file_stream.ReadCompiledFile(&new_pb_file));
- file = DeserializeCompiledFileFromPb(new_pb_file, Source("test"),
- context->GetDiagnostics());
- ASSERT_NE(nullptr, file);
+ file = DeserializeCompiledFileFromPb(new_pb_file, Source("test"), context->GetDiagnostics());
+ ASSERT_THAT(file, NotNull());
ASSERT_TRUE(in_file_stream.ReadDataMetaData(&offset, &len));
diff --git a/tools/aapt2/test/Builders.h b/tools/aapt2/test/Builders.h
index f3da780..6b82076 100644
--- a/tools/aapt2/test/Builders.h
+++ b/tools/aapt2/test/Builders.h
@@ -212,8 +212,7 @@
}
StyleBuilder& AddItem(const android::StringPiece& str, std::unique_ptr<Item> value) {
- style_->entries.push_back(
- Style::Entry{Reference(ParseNameOrDie(str)), std::move(value)});
+ style_->entries.push_back(Style::Entry{Reference(ParseNameOrDie(str)), std::move(value)});
return *this;
}
@@ -224,7 +223,9 @@
return *this;
}
- std::unique_ptr<Style> Build() { return std::move(style_); }
+ std::unique_ptr<Style> Build() {
+ return std::move(style_);
+ }
private:
DISALLOW_COPY_AND_ASSIGN(StyleBuilder);
diff --git a/tools/aapt2/test/Common.h b/tools/aapt2/test/Common.h
index 0585148..bc8d274 100644
--- a/tools/aapt2/test/Common.h
+++ b/tools/aapt2/test/Common.h
@@ -34,15 +34,6 @@
#include "io/File.h"
#include "process/IResourceTableConsumer.h"
-//
-// GTEST 1.7 doesn't explicitly cast to bool, which causes explicit operators to
-// fail to compile.
-//
-#define AAPT_ASSERT_TRUE(v) ASSERT_TRUE(bool(v))
-#define AAPT_ASSERT_FALSE(v) ASSERT_FALSE(bool(v))
-#define AAPT_EXPECT_TRUE(v) EXPECT_TRUE(bool(v))
-#define AAPT_EXPECT_FALSE(v) EXPECT_FALSE(bool(v))
-
namespace aapt {
namespace test {
@@ -150,6 +141,10 @@
return arg.Equals(&a);
}
+MATCHER_P(StrValueEq, a, std::string(negation ? "isn't" : "is") + " equal to " + ::testing::PrintToString(a)) {
+ return *(arg.value) == a;
+}
+
} // namespace test
} // namespace aapt
diff --git a/tools/aapt2/util/BigBuffer_test.cpp b/tools/aapt2/util/BigBuffer_test.cpp
index 12c0b3e..a7776e3 100644
--- a/tools/aapt2/util/BigBuffer_test.cpp
+++ b/tools/aapt2/util/BigBuffer_test.cpp
@@ -18,12 +18,14 @@
#include "test/Test.h"
+using ::testing::NotNull;
+
namespace aapt {
TEST(BigBufferTest, AllocateSingleBlock) {
BigBuffer buffer(4);
- EXPECT_NE(nullptr, buffer.NextBlock<char>(2));
+ EXPECT_THAT(buffer.NextBlock<char>(2), NotNull());
EXPECT_EQ(2u, buffer.size());
}
@@ -31,10 +33,10 @@
BigBuffer buffer(16);
char* b1 = buffer.NextBlock<char>(8);
- EXPECT_NE(nullptr, b1);
+ EXPECT_THAT(b1, NotNull());
char* b2 = buffer.NextBlock<char>(4);
- EXPECT_NE(nullptr, b2);
+ EXPECT_THAT(b2, NotNull());
EXPECT_EQ(b1 + 8, b2);
}
@@ -42,7 +44,7 @@
TEST(BigBufferTest, AllocateExactSizeBlockIfLargerThanBlockSize) {
BigBuffer buffer(16);
- EXPECT_NE(nullptr, buffer.NextBlock<char>(32));
+ EXPECT_THAT(buffer.NextBlock<char>(32), NotNull());
EXPECT_EQ(32u, buffer.size());
}
@@ -50,13 +52,13 @@
BigBuffer buffer(16);
uint32_t* b1 = buffer.NextBlock<uint32_t>();
- ASSERT_NE(nullptr, b1);
+ ASSERT_THAT(b1, NotNull());
*b1 = 33;
{
BigBuffer buffer2(16);
b1 = buffer2.NextBlock<uint32_t>();
- ASSERT_NE(nullptr, b1);
+ ASSERT_THAT(b1, NotNull());
*b1 = 44;
buffer.AppendBuffer(std::move(buffer2));
@@ -83,7 +85,7 @@
TEST(BigBufferTest, PadAndAlignProperly) {
BigBuffer buffer(16);
- ASSERT_NE(buffer.NextBlock<char>(2), nullptr);
+ ASSERT_THAT(buffer.NextBlock<char>(2), NotNull());
ASSERT_EQ(2u, buffer.size());
buffer.Pad(2);
ASSERT_EQ(4u, buffer.size());
diff --git a/tools/aapt2/util/Maybe_test.cpp b/tools/aapt2/util/Maybe_test.cpp
index ca14793..2057ddc 100644
--- a/tools/aapt2/util/Maybe_test.cpp
+++ b/tools/aapt2/util/Maybe_test.cpp
@@ -80,22 +80,22 @@
TEST(MaybeTest, MakeNothing) {
Maybe<int> val = make_nothing<int>();
- AAPT_EXPECT_FALSE(val);
+ EXPECT_FALSE(val);
Maybe<std::string> val2 = make_nothing<std::string>();
- AAPT_EXPECT_FALSE(val2);
+ EXPECT_FALSE(val2);
val2 = make_nothing<std::string>();
- AAPT_EXPECT_FALSE(val2);
+ EXPECT_FALSE(val2);
}
TEST(MaybeTest, MakeSomething) {
Maybe<int> val = make_value(23);
- AAPT_ASSERT_TRUE(val);
+ ASSERT_TRUE(val);
EXPECT_EQ(23, val.value());
Maybe<std::string> val2 = make_value(std::string("hey"));
- AAPT_ASSERT_TRUE(val2);
+ ASSERT_TRUE(val2);
EXPECT_EQ(std::string("hey"), val2.value());
}
diff --git a/tools/aapt2/util/Util_test.cpp b/tools/aapt2/util/Util_test.cpp
index e49aee5..a09001a 100644
--- a/tools/aapt2/util/Util_test.cpp
+++ b/tools/aapt2/util/Util_test.cpp
@@ -147,54 +147,48 @@
TEST(UtilTest, FullyQualifiedClassName) {
Maybe<std::string> res = util::GetFullyQualifiedClassName("android", ".asdf");
- AAPT_ASSERT_TRUE(res);
+ ASSERT_TRUE(res);
EXPECT_EQ(res.value(), "android.asdf");
res = util::GetFullyQualifiedClassName("android", ".a.b");
- AAPT_ASSERT_TRUE(res);
+ ASSERT_TRUE(res);
EXPECT_EQ(res.value(), "android.a.b");
res = util::GetFullyQualifiedClassName("android", "a.b");
- AAPT_ASSERT_TRUE(res);
+ ASSERT_TRUE(res);
EXPECT_EQ(res.value(), "a.b");
res = util::GetFullyQualifiedClassName("", "a.b");
- AAPT_ASSERT_TRUE(res);
+ ASSERT_TRUE(res);
EXPECT_EQ(res.value(), "a.b");
res = util::GetFullyQualifiedClassName("android", "Class");
- AAPT_ASSERT_TRUE(res);
+ ASSERT_TRUE(res);
EXPECT_EQ(res.value(), "android.Class");
res = util::GetFullyQualifiedClassName("", "");
- AAPT_ASSERT_FALSE(res);
+ ASSERT_FALSE(res);
res = util::GetFullyQualifiedClassName("android", "./Apple");
- AAPT_ASSERT_FALSE(res);
+ ASSERT_FALSE(res);
}
TEST(UtilTest, ExtractResourcePathComponents) {
StringPiece prefix, entry, suffix;
- ASSERT_TRUE(util::ExtractResFilePathParts("res/xml-sw600dp/entry.xml",
- &prefix, &entry, &suffix));
+ ASSERT_TRUE(util::ExtractResFilePathParts("res/xml-sw600dp/entry.xml", &prefix, &entry, &suffix));
EXPECT_EQ(prefix, "res/xml-sw600dp/");
EXPECT_EQ(entry, "entry");
EXPECT_EQ(suffix, ".xml");
- ASSERT_TRUE(util::ExtractResFilePathParts("res/xml-sw600dp/entry.9.png",
- &prefix, &entry, &suffix));
-
+ ASSERT_TRUE(util::ExtractResFilePathParts("res/xml-sw600dp/entry.9.png", &prefix, &entry, &suffix));
EXPECT_EQ(prefix, "res/xml-sw600dp/");
EXPECT_EQ(entry, "entry");
EXPECT_EQ(suffix, ".9.png");
- EXPECT_FALSE(util::ExtractResFilePathParts("AndroidManifest.xml", &prefix,
- &entry, &suffix));
- EXPECT_FALSE(
- util::ExtractResFilePathParts("res/.xml", &prefix, &entry, &suffix));
+ EXPECT_FALSE(util::ExtractResFilePathParts("AndroidManifest.xml", &prefix, &entry, &suffix));
+ EXPECT_FALSE(util::ExtractResFilePathParts("res/.xml", &prefix, &entry, &suffix));
- ASSERT_TRUE(
- util::ExtractResFilePathParts("res//.", &prefix, &entry, &suffix));
+ ASSERT_TRUE(util::ExtractResFilePathParts("res//.", &prefix, &entry, &suffix));
EXPECT_EQ(prefix, "res//");
EXPECT_EQ(entry, "");
EXPECT_EQ(suffix, ".");
diff --git a/tools/aapt2/xml/XmlActionExecutor_test.cpp b/tools/aapt2/xml/XmlActionExecutor_test.cpp
index 7110c90..0fe7ab0 100644
--- a/tools/aapt2/xml/XmlActionExecutor_test.cpp
+++ b/tools/aapt2/xml/XmlActionExecutor_test.cpp
@@ -18,6 +18,8 @@
#include "test/Test.h"
+using ::testing::NotNull;
+
namespace aapt {
namespace xml {
@@ -42,12 +44,11 @@
test::BuildXmlDom("<manifest><application /></manifest>");
StdErrDiagnostics diag;
- ASSERT_TRUE(
- executor.Execute(XmlActionExecutorPolicy::kNone, &diag, doc.get()));
- ASSERT_NE(nullptr, manifest_el);
+ ASSERT_TRUE(executor.Execute(XmlActionExecutorPolicy::kNone, &diag, doc.get()));
+ ASSERT_THAT(manifest_el, NotNull());
EXPECT_EQ(std::string("manifest"), manifest_el->name);
- ASSERT_NE(nullptr, application_el);
+ ASSERT_THAT(application_el, NotNull());
EXPECT_EQ(std::string("application"), application_el->name);
}
@@ -58,8 +59,7 @@
std::unique_ptr<XmlResource> doc =
test::BuildXmlDom("<manifest><application /><activity /></manifest>");
StdErrDiagnostics diag;
- ASSERT_FALSE(
- executor.Execute(XmlActionExecutorPolicy::kWhitelist, &diag, doc.get()));
+ ASSERT_FALSE(executor.Execute(XmlActionExecutorPolicy::kWhitelist, &diag, doc.get()));
}
} // namespace xml
diff --git a/tools/aapt2/xml/XmlDom_test.cpp b/tools/aapt2/xml/XmlDom_test.cpp
index fb18ea3..c1aa10b 100644
--- a/tools/aapt2/xml/XmlDom_test.cpp
+++ b/tools/aapt2/xml/XmlDom_test.cpp
@@ -21,6 +21,8 @@
#include "test/Test.h"
+using ::testing::NotNull;
+
namespace aapt {
constexpr const char* kXmlPreamble =
@@ -41,10 +43,10 @@
const Source source = {"test.xml"};
StdErrDiagnostics diag;
std::unique_ptr<xml::XmlResource> doc = xml::Inflate(&in, &diag, source);
- ASSERT_NE(doc, nullptr);
+ ASSERT_THAT(doc, NotNull());
xml::Namespace* ns = xml::NodeCast<xml::Namespace>(doc->root.get());
- ASSERT_NE(ns, nullptr);
+ ASSERT_THAT(ns, NotNull());
EXPECT_EQ(ns->namespace_uri, xml::kSchemaAndroid);
EXPECT_EQ(ns->namespace_prefix, "android");
}
@@ -55,19 +57,19 @@
<element value="\?hello" pattern="\\d{5}">\\d{5}</element>)EOF");
xml::Element* el = xml::FindRootElement(doc->root.get());
- ASSERT_NE(nullptr, el);
+ ASSERT_THAT(el, NotNull());
xml::Attribute* attr = el->FindAttribute({}, "pattern");
- ASSERT_NE(nullptr, attr);
+ ASSERT_THAT(attr, NotNull());
EXPECT_EQ("\\\\d{5}", attr->value);
attr = el->FindAttribute({}, "value");
- ASSERT_NE(nullptr, attr);
+ ASSERT_THAT(attr, NotNull());
EXPECT_EQ("\\?hello", attr->value);
ASSERT_EQ(1u, el->children.size());
xml::Text* text = xml::NodeCast<xml::Text>(el->children[0].get());
- ASSERT_NE(nullptr, text);
+ ASSERT_THAT(text, NotNull());
EXPECT_EQ("\\\\d{5}", text->text);
}
diff --git a/tools/aapt2/xml/XmlUtil_test.cpp b/tools/aapt2/xml/XmlUtil_test.cpp
index 5eecc8f..cbded8f 100644
--- a/tools/aapt2/xml/XmlUtil_test.cpp
+++ b/tools/aapt2/xml/XmlUtil_test.cpp
@@ -21,37 +21,30 @@
namespace aapt {
TEST(XmlUtilTest, ExtractPackageFromNamespace) {
- AAPT_ASSERT_FALSE(xml::ExtractPackageFromNamespace("com.android"));
- AAPT_ASSERT_FALSE(
- xml::ExtractPackageFromNamespace("http://schemas.android.com/apk"));
- AAPT_ASSERT_FALSE(
- xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res"));
- AAPT_ASSERT_FALSE(
- xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res/"));
- AAPT_ASSERT_FALSE(xml::ExtractPackageFromNamespace(
- "http://schemas.android.com/apk/prv/res/"));
+ ASSERT_FALSE(xml::ExtractPackageFromNamespace("com.android"));
+ ASSERT_FALSE(xml::ExtractPackageFromNamespace("http://schemas.android.com/apk"));
+ ASSERT_FALSE(xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res"));
+ ASSERT_FALSE(xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res/"));
+ ASSERT_FALSE(xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/prv/res/"));
Maybe<xml::ExtractedPackage> p =
xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res/a");
- AAPT_ASSERT_TRUE(p);
+ ASSERT_TRUE(p);
EXPECT_EQ(std::string("a"), p.value().package);
EXPECT_FALSE(p.value().private_namespace);
- p = xml::ExtractPackageFromNamespace(
- "http://schemas.android.com/apk/prv/res/android");
- AAPT_ASSERT_TRUE(p);
+ p = xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/prv/res/android");
+ ASSERT_TRUE(p);
EXPECT_EQ(std::string("android"), p.value().package);
EXPECT_TRUE(p.value().private_namespace);
- p = xml::ExtractPackageFromNamespace(
- "http://schemas.android.com/apk/prv/res/com.test");
- AAPT_ASSERT_TRUE(p);
+ p = xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/prv/res/com.test");
+ ASSERT_TRUE(p);
EXPECT_EQ(std::string("com.test"), p.value().package);
EXPECT_TRUE(p.value().private_namespace);
- p = xml::ExtractPackageFromNamespace(
- "http://schemas.android.com/apk/res-auto");
- AAPT_ASSERT_TRUE(p);
+ p = xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res-auto");
+ ASSERT_TRUE(p);
EXPECT_EQ(std::string(), p.value().package);
EXPECT_TRUE(p.value().private_namespace);
}