diff --git a/tools/aapt2/ResourceParser_test.cpp b/tools/aapt2/ResourceParser_test.cpp
index c6382b177f420..e189144108716 100644
--- a/tools/aapt2/ResourceParser_test.cpp
+++ b/tools/aapt2/ResourceParser_test.cpp
@@ -25,11 +25,17 @@
 #include "test/Test.h"
 #include "xml/XmlPullParser.h"
 
+using ::aapt::test::StrValueEq;
 using ::aapt::test::ValueEq;
+using ::android::ResTable_map;
+using ::android::Res_value;
 using ::android::StringPiece;
 using ::testing::Eq;
+using ::testing::IsEmpty;
+using ::testing::IsNull;
 using ::testing::NotNull;
 using ::testing::Pointee;
+using ::testing::SizeIs;
 
 namespace aapt {
 
@@ -74,31 +80,26 @@ class ResourceParserTest : public ::testing::Test {
 };
 
 TEST_F(ResourceParserTest, ParseQuotedString) {
-  std::string input = "<string name=\"foo\">   \"  hey there \" </string>";
-  ASSERT_TRUE(TestParse(input));
+  ASSERT_TRUE(TestParse(R"(<string name="foo">   "  hey there " </string>)"));
 
   String* str = test::GetValue<String>(&table_, "string/foo");
-  ASSERT_NE(nullptr, str);
-  EXPECT_EQ(std::string("  hey there "), *str->value);
-  EXPECT_TRUE(str->untranslatable_sections.empty());
+  ASSERT_THAT(str, NotNull());
+  EXPECT_THAT(*str, StrValueEq("  hey there "));
+  EXPECT_THAT(str->untranslatable_sections, IsEmpty());
 }
 
 TEST_F(ResourceParserTest, ParseEscapedString) {
-  std::string input = "<string name=\"foo\">\\?123</string>";
-  ASSERT_TRUE(TestParse(input));
+  ASSERT_TRUE(TestParse(R"(<string name="foo">\?123</string>)"));
 
   String* str = test::GetValue<String>(&table_, "string/foo");
-  ASSERT_NE(nullptr, str);
-  EXPECT_EQ(std::string("?123"), *str->value);
-  EXPECT_TRUE(str->untranslatable_sections.empty());
+  ASSERT_THAT(str, NotNull());
+  EXPECT_THAT(*str, StrValueEq("?123"));
+  EXPECT_THAT(str->untranslatable_sections, IsEmpty());
 }
 
 TEST_F(ResourceParserTest, ParseFormattedString) {
-  std::string input = "<string name=\"foo\">%d %s</string>";
-  ASSERT_FALSE(TestParse(input));
-
-  input = "<string name=\"foo\">%1$d %2$s</string>";
-  ASSERT_TRUE(TestParse(input));
+  ASSERT_FALSE(TestParse(R"(<string name="foo">%d %s</string>)"));
+  ASSERT_TRUE(TestParse(R"(<string name="foo">%1$d %2$s</string>)"));
 }
 
 TEST_F(ResourceParserTest, ParseStyledString) {
@@ -109,98 +110,93 @@ TEST_F(ResourceParserTest, ParseStyledString) {
   ASSERT_TRUE(TestParse(input));
 
   StyledString* str = test::GetValue<StyledString>(&table_, "string/foo");
-  ASSERT_NE(nullptr, str);
+  ASSERT_THAT(str, NotNull());
 
-  const std::string expected_str = "This is my aunt\u2019s fickle string";
-  EXPECT_EQ(expected_str, *str->value->str);
-  EXPECT_EQ(2u, str->value->spans.size());
-  EXPECT_TRUE(str->untranslatable_sections.empty());
+  EXPECT_THAT(*str->value->str, Eq("This is my aunt\u2019s fickle string"));
+  EXPECT_THAT(str->value->spans, SizeIs(2));
+  EXPECT_THAT(str->untranslatable_sections, IsEmpty());
 
-  EXPECT_EQ(std::string("b"), *str->value->spans[0].name);
-  EXPECT_EQ(17u, str->value->spans[0].first_char);
-  EXPECT_EQ(30u, str->value->spans[0].last_char);
+  EXPECT_THAT(*str->value->spans[0].name, Eq("b"));
+  EXPECT_THAT(str->value->spans[0].first_char, Eq(17u));
+  EXPECT_THAT(str->value->spans[0].last_char, Eq(30u));
 
-  EXPECT_EQ(std::string("small"), *str->value->spans[1].name);
-  EXPECT_EQ(24u, str->value->spans[1].first_char);
-  EXPECT_EQ(30u, str->value->spans[1].last_char);
+  EXPECT_THAT(*str->value->spans[1].name, Eq("small"));
+  EXPECT_THAT(str->value->spans[1].first_char, Eq(24u));
+  EXPECT_THAT(str->value->spans[1].last_char, Eq(30u));
 }
 
 TEST_F(ResourceParserTest, ParseStringWithWhitespace) {
-  std::string input = "<string name=\"foo\">  This is what  I think  </string>";
-  ASSERT_TRUE(TestParse(input));
+  ASSERT_TRUE(TestParse(R"(<string name="foo">  This is what  I think  </string>)"));
 
   String* str = test::GetValue<String>(&table_, "string/foo");
-  ASSERT_NE(nullptr, str);
-  EXPECT_EQ(std::string("This is what I think"), *str->value);
-  EXPECT_TRUE(str->untranslatable_sections.empty());
+  ASSERT_THAT(str, NotNull());
+  EXPECT_THAT(*str->value, Eq("This is what I think"));
+  EXPECT_THAT(str->untranslatable_sections, IsEmpty());
 
-  input = "<string name=\"foo2\">\"  This is what  I think  \"</string>";
-  ASSERT_TRUE(TestParse(input));
+  ASSERT_TRUE(TestParse(R"(<string name="foo2">"  This is what  I think  "</string>)"));
 
   str = test::GetValue<String>(&table_, "string/foo2");
-  ASSERT_NE(nullptr, str);
-  EXPECT_EQ(std::string("  This is what  I think  "), *str->value);
+  ASSERT_THAT(str, NotNull());
+  EXPECT_THAT(*str, StrValueEq("  This is what  I think  "));
 }
 
 TEST_F(ResourceParserTest, IgnoreXliffTagsOtherThanG) {
-  std::string input = R"EOF(
+  std::string input = R"(
       <string name="foo" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-          There are <xliff:source>no</xliff:source> apples</string>)EOF";
+          There are <xliff:source>no</xliff:source> apples</string>)";
   ASSERT_TRUE(TestParse(input));
 
   String* str = test::GetValue<String>(&table_, "string/foo");
-  ASSERT_NE(nullptr, str);
-  EXPECT_EQ(StringPiece("There are no apples"), StringPiece(*str->value));
-  EXPECT_TRUE(str->untranslatable_sections.empty());
+  ASSERT_THAT(str, NotNull());
+  EXPECT_THAT(*str, StrValueEq("There are no apples"));
+  EXPECT_THAT(str->untranslatable_sections, IsEmpty());
 }
 
 TEST_F(ResourceParserTest, NestedXliffGTagsAreIllegal) {
-  std::string input = R"EOF(
+  std::string input = R"(
       <string name="foo" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-          Do not <xliff:g>translate <xliff:g>this</xliff:g></xliff:g></string>)EOF";
+          Do not <xliff:g>translate <xliff:g>this</xliff:g></xliff:g></string>)";
   EXPECT_FALSE(TestParse(input));
 }
 
 TEST_F(ResourceParserTest, RecordUntranslateableXliffSectionsInString) {
-  std::string input = R"EOF(
+  std::string input = R"(
       <string name="foo" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-          There are <xliff:g id="count">%1$d</xliff:g> apples</string>)EOF";
+          There are <xliff:g id="count">%1$d</xliff:g> apples</string>)";
   ASSERT_TRUE(TestParse(input));
 
   String* str = test::GetValue<String>(&table_, "string/foo");
-  ASSERT_NE(nullptr, str);
-  EXPECT_EQ(StringPiece("There are %1$d apples"), StringPiece(*str->value));
-
-  ASSERT_EQ(1u, str->untranslatable_sections.size());
+  ASSERT_THAT(str, NotNull());
+  EXPECT_THAT(*str, StrValueEq("There are %1$d apples"));
+  ASSERT_THAT(str->untranslatable_sections, SizeIs(1));
 
   // We expect indices and lengths that span to include the whitespace
   // before %1$d. This is due to how the StringBuilder withholds whitespace unless
   // needed (to deal with line breaks, etc.).
-  EXPECT_EQ(9u, str->untranslatable_sections[0].start);
-  EXPECT_EQ(14u, str->untranslatable_sections[0].end);
+  EXPECT_THAT(str->untranslatable_sections[0].start, Eq(9u));
+  EXPECT_THAT(str->untranslatable_sections[0].end, Eq(14u));
 }
 
 TEST_F(ResourceParserTest, RecordUntranslateableXliffSectionsInStyledString) {
-  std::string input = R"EOF(
+  std::string input = R"(
       <string name="foo" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-          There are <b><xliff:g id="count">%1$d</xliff:g></b> apples</string>)EOF";
+          There are <b><xliff:g id="count">%1$d</xliff:g></b> apples</string>)";
   ASSERT_TRUE(TestParse(input));
 
   StyledString* str = test::GetValue<StyledString>(&table_, "string/foo");
-  ASSERT_NE(nullptr, str);
-  EXPECT_EQ(StringPiece("There are %1$d apples"), StringPiece(*str->value->str));
-
-  ASSERT_EQ(1u, str->untranslatable_sections.size());
+  ASSERT_THAT(str, NotNull());
+  EXPECT_THAT(*str->value->str, Eq("There are %1$d apples"));
+  ASSERT_THAT(str->untranslatable_sections, SizeIs(1));
 
   // We expect indices and lengths that span to include the whitespace
   // before %1$d. This is due to how the StringBuilder withholds whitespace unless
   // needed (to deal with line breaks, etc.).
-  EXPECT_EQ(9u, str->untranslatable_sections[0].start);
-  EXPECT_EQ(14u, str->untranslatable_sections[0].end);
+  EXPECT_THAT(str->untranslatable_sections[0].start, Eq(9u));
+  EXPECT_THAT(str->untranslatable_sections[0].end, Eq(14u));
 }
 
 TEST_F(ResourceParserTest, ParseNull) {
-  std::string input = "<integer name=\"foo\">@null</integer>";
+  std::string input = R"(<integer name="foo">@null</integer>)";
   ASSERT_TRUE(TestParse(input));
 
   // The Android runtime treats a value of android::Res_value::TYPE_NULL as
@@ -211,38 +207,36 @@ TEST_F(ResourceParserTest, ParseNull) {
   ASSERT_THAT(null_ref, NotNull());
   EXPECT_FALSE(null_ref->name);
   EXPECT_FALSE(null_ref->id);
-  EXPECT_EQ(Reference::Type::kResource, null_ref->reference_type);
+  EXPECT_THAT(null_ref->reference_type, Eq(Reference::Type::kResource));
 }
 
 TEST_F(ResourceParserTest, ParseEmpty) {
-  std::string input = "<integer name=\"foo\">@empty</integer>";
+  std::string input = R"(<integer name="foo">@empty</integer>)";
   ASSERT_TRUE(TestParse(input));
 
   BinaryPrimitive* integer = test::GetValue<BinaryPrimitive>(&table_, "integer/foo");
-  ASSERT_NE(nullptr, integer);
-  EXPECT_EQ(uint16_t(android::Res_value::TYPE_NULL), integer->value.dataType);
-  EXPECT_EQ(uint32_t(android::Res_value::DATA_NULL_EMPTY), integer->value.data);
+  ASSERT_THAT(integer, NotNull());
+  EXPECT_THAT(integer->value.dataType, Eq(Res_value::TYPE_NULL));
+  EXPECT_THAT(integer->value.data, Eq(Res_value::DATA_NULL_EMPTY));
 }
 
 TEST_F(ResourceParserTest, ParseAttr) {
-  std::string input =
-      "<attr name=\"foo\" format=\"string\"/>\n"
-      "<attr name=\"bar\"/>";
+  std::string input = R"(
+      <attr name="foo" format="string"/>
+      <attr name="bar"/>)";
   ASSERT_TRUE(TestParse(input));
 
   Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo");
-  ASSERT_NE(nullptr, attr);
-  EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->type_mask);
+  ASSERT_THAT(attr, NotNull());
+  EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_STRING));
 
   attr = test::GetValue<Attribute>(&table_, "attr/bar");
-  ASSERT_NE(nullptr, attr);
-  EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_ANY), attr->type_mask);
+  ASSERT_THAT(attr, NotNull());
+  EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_ANY));
 }
 
-// Old AAPT allowed attributes to be defined under different configurations, but
-// ultimately
-// stored them with the default configuration. Check that we have the same
-// behavior.
+// Old AAPT allowed attributes to be defined under different configurations, but ultimately
+// stored them with the default configuration. Check that we have the same behavior.
 TEST_F(ResourceParserTest, ParseAttrAndDeclareStyleableUnderConfigButRecordAsNoConfig) {
   const ConfigDescription watch_config = test::ParseConfigOrDie("watch");
   std::string input = R"(
@@ -252,583 +246,519 @@ TEST_F(ResourceParserTest, ParseAttrAndDeclareStyleableUnderConfigButRecordAsNoC
       </declare-styleable>)";
   ASSERT_TRUE(TestParse(input, watch_config));
 
-  EXPECT_EQ(nullptr, test::GetValueForConfig<Attribute>(&table_, "attr/foo", watch_config));
-  EXPECT_EQ(nullptr, test::GetValueForConfig<Attribute>(&table_, "attr/baz", watch_config));
-  EXPECT_EQ(nullptr, test::GetValueForConfig<Styleable>(&table_, "styleable/bar", watch_config));
+  EXPECT_THAT(test::GetValueForConfig<Attribute>(&table_, "attr/foo", watch_config), IsNull());
+  EXPECT_THAT(test::GetValueForConfig<Attribute>(&table_, "attr/baz", watch_config), IsNull());
+  EXPECT_THAT(test::GetValueForConfig<Styleable>(&table_, "styleable/bar", watch_config), IsNull());
 
-  EXPECT_NE(nullptr, test::GetValue<Attribute>(&table_, "attr/foo"));
-  EXPECT_NE(nullptr, test::GetValue<Attribute>(&table_, "attr/baz"));
-  EXPECT_NE(nullptr, test::GetValue<Styleable>(&table_, "styleable/bar"));
+  EXPECT_THAT(test::GetValue<Attribute>(&table_, "attr/foo"), NotNull());
+  EXPECT_THAT(test::GetValue<Attribute>(&table_, "attr/baz"), NotNull());
+  EXPECT_THAT(test::GetValue<Styleable>(&table_, "styleable/bar"), NotNull());
 }
 
 TEST_F(ResourceParserTest, ParseAttrWithMinMax) {
-  std::string input =
-      "<attr name=\"foo\" min=\"10\" max=\"23\" format=\"integer\"/>";
+  std::string input = R"(<attr name="foo" min="10" max="23" format="integer"/>)";
   ASSERT_TRUE(TestParse(input));
 
   Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo");
-  ASSERT_NE(nullptr, attr);
-  EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_INTEGER), attr->type_mask);
-  EXPECT_EQ(10, attr->min_int);
-  EXPECT_EQ(23, attr->max_int);
+  ASSERT_THAT(attr, NotNull());
+  EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_INTEGER));
+  EXPECT_THAT(attr->min_int, Eq(10));
+  EXPECT_THAT(attr->max_int, Eq(23));
 }
 
 TEST_F(ResourceParserTest, FailParseAttrWithMinMaxButNotInteger) {
-  std::string input =
-      "<attr name=\"foo\" min=\"10\" max=\"23\" format=\"string\"/>";
-  ASSERT_FALSE(TestParse(input));
+  ASSERT_FALSE(TestParse(R"(<attr name="foo" min="10" max="23" format="string"/>)"));
 }
 
 TEST_F(ResourceParserTest, ParseUseAndDeclOfAttr) {
-  std::string input =
-      "<declare-styleable name=\"Styleable\">\n"
-      "  <attr name=\"foo\" />\n"
-      "</declare-styleable>\n"
-      "<attr name=\"foo\" format=\"string\"/>";
+  std::string input = R"(
+      <declare-styleable name="Styleable">
+        <attr name="foo" />
+      </declare-styleable>
+      <attr name="foo" format="string"/>)";
   ASSERT_TRUE(TestParse(input));
 
   Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo");
-  ASSERT_NE(nullptr, attr);
-  EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->type_mask);
+  ASSERT_THAT(attr, NotNull());
+  EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_STRING));
 }
 
 TEST_F(ResourceParserTest, ParseDoubleUseOfAttr) {
-  std::string input =
-      "<declare-styleable name=\"Theme\">"
-      "  <attr name=\"foo\" />\n"
-      "</declare-styleable>\n"
-      "<declare-styleable name=\"Window\">\n"
-      "  <attr name=\"foo\" format=\"boolean\"/>\n"
-      "</declare-styleable>";
+  std::string input = R"(
+      <declare-styleable name="Theme">
+        <attr name="foo" />
+      </declare-styleable>
+      <declare-styleable name="Window">
+        <attr name="foo" format="boolean"/>
+      </declare-styleable>)";
   ASSERT_TRUE(TestParse(input));
 
   Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo");
-  ASSERT_NE(nullptr, attr);
-  EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_BOOLEAN), attr->type_mask);
+  ASSERT_THAT(attr, NotNull());
+  EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_BOOLEAN));
 }
 
 TEST_F(ResourceParserTest, ParseEnumAttr) {
-  std::string input =
-      "<attr name=\"foo\">\n"
-      "  <enum name=\"bar\" value=\"0\"/>\n"
-      "  <enum name=\"bat\" value=\"1\"/>\n"
-      "  <enum name=\"baz\" value=\"2\"/>\n"
-      "</attr>";
+  std::string input = R"(
+      <attr name="foo">
+        <enum name="bar" value="0"/>
+        <enum name="bat" value="1"/>
+        <enum name="baz" value="2"/>
+      </attr>)";
   ASSERT_TRUE(TestParse(input));
 
   Attribute* enum_attr = test::GetValue<Attribute>(&table_, "attr/foo");
-  ASSERT_NE(enum_attr, nullptr);
-  EXPECT_EQ(enum_attr->type_mask, android::ResTable_map::TYPE_ENUM);
-  ASSERT_EQ(enum_attr->symbols.size(), 3u);
+  ASSERT_THAT(enum_attr, NotNull());
+  EXPECT_THAT(enum_attr->type_mask, Eq(ResTable_map::TYPE_ENUM));
+  ASSERT_THAT(enum_attr->symbols, SizeIs(3));
 
-  AAPT_ASSERT_TRUE(enum_attr->symbols[0].symbol.name);
-  EXPECT_EQ(enum_attr->symbols[0].symbol.name.value().entry, "bar");
-  EXPECT_EQ(enum_attr->symbols[0].value, 0u);
+  ASSERT_TRUE(enum_attr->symbols[0].symbol.name);
+  EXPECT_THAT(enum_attr->symbols[0].symbol.name.value().entry, Eq("bar"));
+  EXPECT_THAT(enum_attr->symbols[0].value, Eq(0u));
 
-  AAPT_ASSERT_TRUE(enum_attr->symbols[1].symbol.name);
-  EXPECT_EQ(enum_attr->symbols[1].symbol.name.value().entry, "bat");
-  EXPECT_EQ(enum_attr->symbols[1].value, 1u);
+  ASSERT_TRUE(enum_attr->symbols[1].symbol.name);
+  EXPECT_THAT(enum_attr->symbols[1].symbol.name.value().entry, Eq("bat"));
+  EXPECT_THAT(enum_attr->symbols[1].value, Eq(1u));
 
-  AAPT_ASSERT_TRUE(enum_attr->symbols[2].symbol.name);
-  EXPECT_EQ(enum_attr->symbols[2].symbol.name.value().entry, "baz");
-  EXPECT_EQ(enum_attr->symbols[2].value, 2u);
+  ASSERT_TRUE(enum_attr->symbols[2].symbol.name);
+  EXPECT_THAT(enum_attr->symbols[2].symbol.name.value().entry, Eq("baz"));
+  EXPECT_THAT(enum_attr->symbols[2].value, Eq(2u));
 }
 
 TEST_F(ResourceParserTest, ParseFlagAttr) {
-  std::string input =
-      "<attr name=\"foo\">\n"
-      "  <flag name=\"bar\" value=\"0\"/>\n"
-      "  <flag name=\"bat\" value=\"1\"/>\n"
-      "  <flag name=\"baz\" value=\"2\"/>\n"
-      "</attr>";
+  std::string input = R"(
+      <attr name="foo">
+        <flag name="bar" value="0"/>
+        <flag name="bat" value="1"/>
+        <flag name="baz" value="2"/>
+      </attr>)";
   ASSERT_TRUE(TestParse(input));
 
   Attribute* flag_attr = test::GetValue<Attribute>(&table_, "attr/foo");
-  ASSERT_NE(nullptr, flag_attr);
-  EXPECT_EQ(flag_attr->type_mask, android::ResTable_map::TYPE_FLAGS);
-  ASSERT_EQ(flag_attr->symbols.size(), 3u);
+  ASSERT_THAT(flag_attr, NotNull());
+  EXPECT_THAT(flag_attr->type_mask, Eq(ResTable_map::TYPE_FLAGS));
+  ASSERT_THAT(flag_attr->symbols, SizeIs(3));
 
-  AAPT_ASSERT_TRUE(flag_attr->symbols[0].symbol.name);
-  EXPECT_EQ(flag_attr->symbols[0].symbol.name.value().entry, "bar");
-  EXPECT_EQ(flag_attr->symbols[0].value, 0u);
+  ASSERT_TRUE(flag_attr->symbols[0].symbol.name);
+  EXPECT_THAT(flag_attr->symbols[0].symbol.name.value().entry, Eq("bar"));
+  EXPECT_THAT(flag_attr->symbols[0].value, Eq(0u));
 
-  AAPT_ASSERT_TRUE(flag_attr->symbols[1].symbol.name);
-  EXPECT_EQ(flag_attr->symbols[1].symbol.name.value().entry, "bat");
-  EXPECT_EQ(flag_attr->symbols[1].value, 1u);
+  ASSERT_TRUE(flag_attr->symbols[1].symbol.name);
+  EXPECT_THAT(flag_attr->symbols[1].symbol.name.value().entry, Eq("bat"));
+  EXPECT_THAT(flag_attr->symbols[1].value, Eq(1u));
 
-  AAPT_ASSERT_TRUE(flag_attr->symbols[2].symbol.name);
-  EXPECT_EQ(flag_attr->symbols[2].symbol.name.value().entry, "baz");
-  EXPECT_EQ(flag_attr->symbols[2].value, 2u);
+  ASSERT_TRUE(flag_attr->symbols[2].symbol.name);
+  EXPECT_THAT(flag_attr->symbols[2].symbol.name.value().entry, Eq("baz"));
+  EXPECT_THAT(flag_attr->symbols[2].value, Eq(2u));
 
   std::unique_ptr<BinaryPrimitive> flag_value =
       ResourceUtils::TryParseFlagSymbol(flag_attr, "baz|bat");
-  ASSERT_NE(nullptr, flag_value);
-  EXPECT_EQ(flag_value->value.data, 1u | 2u);
+  ASSERT_THAT(flag_value, NotNull());
+  EXPECT_THAT(flag_value->value.data, Eq(1u | 2u));
 }
 
 TEST_F(ResourceParserTest, FailToParseEnumAttrWithNonUniqueKeys) {
-  std::string input =
-      "<attr name=\"foo\">\n"
-      "  <enum name=\"bar\" value=\"0\"/>\n"
-      "  <enum name=\"bat\" value=\"1\"/>\n"
-      "  <enum name=\"bat\" value=\"2\"/>\n"
-      "</attr>";
+  std::string input = R"(
+      <attr name="foo">
+        <enum name="bar" value="0"/>
+        <enum name="bat" value="1"/>
+        <enum name="bat" value="2"/>
+      </attr>)";
   ASSERT_FALSE(TestParse(input));
 }
 
 TEST_F(ResourceParserTest, ParseStyle) {
-  std::string input =
-      "<style name=\"foo\" parent=\"@style/fu\">\n"
-      "  <item name=\"bar\">#ffffffff</item>\n"
-      "  <item name=\"bat\">@string/hey</item>\n"
-      "  <item name=\"baz\"><b>hey</b></item>\n"
-      "</style>";
+  std::string input = R"(
+      <style name="foo" parent="@style/fu">
+        <item name="bar">#ffffffff</item>
+        <item name="bat">@string/hey</item>
+        <item name="baz"><b>hey</b></item>
+      </style>)";
   ASSERT_TRUE(TestParse(input));
 
   Style* style = test::GetValue<Style>(&table_, "style/foo");
-  ASSERT_NE(nullptr, style);
-  AAPT_ASSERT_TRUE(style->parent);
-  AAPT_ASSERT_TRUE(style->parent.value().name);
-  EXPECT_EQ(test::ParseNameOrDie("style/fu"),
-            style->parent.value().name.value());
-  ASSERT_EQ(3u, style->entries.size());
+  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 @@ TEST_F(ResourceParserTest, ParseElementWithNoValue) {
 
   String* str = test::GetValue<String>(&table_, "string/foo");
   ASSERT_THAT(str, NotNull());
-  EXPECT_THAT(*str->value, Eq(""));
+  EXPECT_THAT(*str, StrValueEq(""));
 }
 
 TEST_F(ResourceParserTest, ParsePlatformIndependentNewline) {
-  std::string input = R"(<string name="foo">%1$s %n %2$s</string>)";
-  ASSERT_TRUE(TestParse(input));
+  ASSERT_TRUE(TestParse(R"(<string name="foo">%1$s %n %2$s</string>)"));
 }
 
 }  // namespace aapt
diff --git a/tools/aapt2/ResourceTable_test.cpp b/tools/aapt2/ResourceTable_test.cpp
index e2b37be994ffb..2a3c131f7b4bf 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(ResourceTableTest, AddOneResource) {
       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 @@ TEST(ResourceTableTest, AddMultipleResources) {
           .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 @@ TEST(ResourceTableTest, OverrideWeakResourceValue) {
       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 @@ TEST(ResourceTableTest, OverrideWeakResourceValue) {
       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 @@ TEST(ResourceTableTest, ProductVaryingValues) {
                                 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 cdc34f1ec752f..3a5e685e6b948 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 @@ TEST(ResourceUtilsTest, FailToParseAutoCreateNonIdReference) {
   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, FailParseIncompleteReference) {
 }
 
 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 d465091d224e7..5cff0048c062b 100644
--- a/tools/aapt2/compile/IdAssigner_test.cpp
+++ b/tools/aapt2/compile/IdAssigner_test.cpp
@@ -64,12 +64,12 @@ TEST(IdAssignerTest, AssignIdsWithReservedIds) {
   // 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 @@ TEST(IdAssignerTest, AssignIdsWithReservedIds) {
 
   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 @@ TEST(IdAssignerTest, AssignIdsWithIdMap) {
   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 6d1350d433a48..4fdb2eced59b7 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 @@ TEST_F(TableFlattenerTest, FlattenMinMaxAttributes) {
   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 @@ TEST_F(TableFlattenerTest, FlattenSparseEntryWithMinSdkO) {
 
   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 @@ TEST_F(TableFlattenerTest, FlattenSharedLibrary) {
 
   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 @@ TEST_F(TableFlattenerTest, FlattenTableReferencingSharedLibraries) {
   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 @@ TEST_F(TableFlattenerTest, PackageWithNonStandardIdHasDynamicRefTable) {
   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 755af0a1c6cc9..49639f8ad5495 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 @@ TEST(AutoVersionerTest, VersionStylesForTable) {
   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 d8e33a42711a1..72a91689e3927 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 @@ TEST(ReferenceLinkerTest, LinkSimpleReferences) {
   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 @@ TEST(ReferenceLinkerTest, LinkStyleAttributes) {
 
   {
     // 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 @@ TEST(ReferenceLinkerTest, LinkStyleAttributes) {
   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 @@ TEST(ReferenceLinkerTest, LinkMangledReferencesAndAttributes) {
   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 @@ TEST(ReferenceLinkerTest, AppsWithSamePackageButDifferentIdAreVisibleNonPublic)
   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 @@ TEST(ReferenceLinkerTest, AppsWithDifferentPackageCanNotUseEachOthersAttribute)
   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 de81e73f613ed..228cfb9e3d663 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 @@ TEST_F(XmlReferenceLinkerTest, LinkBasicAttributes) {
   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 @@ TEST_F(XmlReferenceLinkerTest, LinkMangledAttributes) {
   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 @@ TEST_F(XmlReferenceLinkerTest, LinkAutoResReference) {
   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 @@ TEST_F(XmlReferenceLinkerTest, LinkViewWithShadowedPackageAlias) {
   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 @@ TEST_F(XmlReferenceLinkerTest, LinkViewWithLocalPackageAndAliasOfTheSameName) {
   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 e6ce6d37b8798..3ebb08eb791e0 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 @@ TEST(TableProtoSerializer, SerializeSinglePackage) {
 
   // 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 @@ TEST(TableProtoSerializer, SerializeSinglePackage) {
                                  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 @@ TEST(TableProtoSerializer, SerializeSinglePackage) {
   // 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 @@ TEST(TableProtoSerializer, SerializeFileHeader) {
 
   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 @@ TEST(TableProtoSerializer, SerializeFileHeader) {
   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 f3da780cacbdf..6b82076474717 100644
--- a/tools/aapt2/test/Builders.h
+++ b/tools/aapt2/test/Builders.h
@@ -212,8 +212,7 @@ class StyleBuilder {
   }
 
   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 @@ class StyleBuilder {
     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 05851485e2164..bc8d274a9c6ee 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 @@ MATCHER_P(ValueEq, a,
   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 12c0b3ee3214c..a7776e33ae74d 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 @@ TEST(BigBufferTest, ReturnSameBlockIfNextAllocationFits) {
   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, ReturnSameBlockIfNextAllocationFits) {
 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 @@ TEST(BigBufferTest, AppendAndMoveBlock) {
   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, AppendAndMoveBlock) {
 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 ca14793dd5c32..2057ddcc9e453 100644
--- a/tools/aapt2/util/Maybe_test.cpp
+++ b/tools/aapt2/util/Maybe_test.cpp
@@ -80,22 +80,22 @@ struct Dummy {
 
 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 e49aee5d50ed3..a09001a71efc6 100644
--- a/tools/aapt2/util/Util_test.cpp
+++ b/tools/aapt2/util/Util_test.cpp
@@ -147,54 +147,48 @@ TEST(UtilTest, IsJavaPackageName) {
 
 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 7110c90fa3a94..0fe7ab05ceb28 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(XmlActionExecutorTest, BuildsAccessibleNestedPattern) {
       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 @@ TEST(XmlActionExecutorTest, FailsWhenUndefinedHierarchyExists) {
   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 fb18ea316ca68..c1aa10b89a2fc 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 @@ TEST(XmlDomTest, Inflate) {
   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 @@ TEST(XmlDomTest, ForwardEscapes) {
       <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 5eecc8f5fb20c..cbded8ffac8ec 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);
 }