Make syntax tree test print the line number when it fails

[gribozavr]

Summary

The syntax tree test uses a helper function that executes all testing
assertions. When an assertion fails, the only line number that gets
printed to the log refers to the helper function. After this change, we
would also get the line number of the EXPECT_TRUE macro invocation
(unfortunately, the line number of the last token of it, not the first
one, but there's not much I can do about it).

[hlopko]

Thanks!

clang/unittests/Tooling/Syntax/TreeTest.cpp

syntax::TranslationUnit *buildTree(llvm::StringRef Code,
     if (!Compiler.ExecuteAction(Recorder) &&
         Diags->getClient()->getNumErrors() == 0) {
       ADD_FAILURE() << "failed to run the frontend";
       std::abort();
     }
     return Root;
   }
 
-  void expectTreeDumpEqual(StringRef Code, StringRef Tree) {
+  ::testing::AssertionResult treeDumpEqual(StringRef Code, StringRef Tree) {
     SCOPED_TRACE(llvm::join(GetParam().getCommandLineArgs(), " "));
-    SCOPED_TRACE(Code);
 
     auto *Root = buildTree(Code, GetParam());
-    EXPECT_EQ(Diags->getClient()->getNumErrors(), 0u)
-        << "Source file has syntax errors, they were printed to the test log";
+    if (Diags->getClient()->getNumErrors() != 0) {
+      return ::testing::AssertionFailure()
+             << "Source file has syntax errors, they were printed to the test "
+                "log";
+    }
     std::string Actual = std::string(StringRef(Root->dump(*Arena)).trim());
+    // EXPECT_EQ shows the diff between the two strings if they are different.
     EXPECT_EQ(Tree.trim().str(), Actual);
+    if (Actual != Tree.trim().str()) {
+      return ::testing::AssertionFailure();
+    }
+    return ::testing::AssertionSuccess();
   }
 
   // Adds a file to the test VFS.
   void addFile(llvm::StringRef Path, llvm::StringRef Contents) {
     if (!FS->addFile(Path, time_t(),
                      llvm::MemoryBuffer::getMemBufferCopy(Contents))) {
       ADD_FAILURE() << "could not add a file to VFS: " << Path;
     }
protected:
   llvm::IntrusiveRefCntPtr<SourceManager> SourceMgr =
       new SourceManager(*Diags, *FileMgr);
   std::shared_ptr<CompilerInvocation> Invocation;
   // Set after calling buildTree().
   std::unique_ptr<syntax::Arena> Arena;
 };
 
 TEST_P(SyntaxTreeTest, Simple) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int main() {}
 void foo() {}
-    )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-int
 | |-SimpleDeclarator
 | | |-main
 | | `-ParametersAndQualifiers
 | |   |-(
 | |   `-)
 | `-CompoundStatement
 |   |-{
 |   `-}
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-foo
   | `-ParametersAndQualifiers
   |   |-(
   |   `-)
   `-CompoundStatement
     |-{
     `-}
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, SimpleVariable) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int a;
 int b = 42;
-    )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-int
 | |-SimpleDeclarator
 | | `-a
 | `-;
 `-SimpleDeclaration
   |-int
   |-SimpleDeclarator
   | |-b
   | |-=
   | `-UnknownExpression
   |   `-42
   `-;
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, SimpleFunction) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void foo(int a, int b) {}
-    )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-foo
   | `-ParametersAndQualifiers
   |   |-(
   |   |-SimpleDeclaration
   |   | |-int
   |   | `-SimpleDeclarator
   |   |   `-a
   |   |-,
   |   |-SimpleDeclaration
   |   | |-int
   |   | `-SimpleDeclarator
   |   |   `-b
   |   `-)
   `-CompoundStatement
     |-{
     `-}
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, If) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int main() {
   if (1) {}
   if (1) {} else if (0) {}
 }
-        )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-int
   |-SimpleDeclarator
   | |-main
   | `-ParametersAndQualifiers
   |   |-(
`-CompoundStatement
     |   |-(
     |   |-UnknownExpression
     |   | `-0
     |   |-)
     |   `-CompoundStatement
     |     |-{
     |     `-}
     `-}
-        )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, For) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test() {
   for (;;)  {}
 }
 )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
`-CompoundStatement
     | |-(
     | |-;
     | |-;
     | |-)
     | `-CompoundStatement
     |   |-{
     |   `-}
     `-}
-        )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, RangeBasedFor) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test() {
   int a[3];
   for (int x : a)
     ;
 }
-      )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
`-CompoundStatement
     | | | `-x
     | | `-:
     | |-UnknownExpression
     | | `-a
     | |-)
     | `-EmptyStatement
     |   `-;
     `-}
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, DeclarationStatement) {
-  expectTreeDumpEqual("void test() { int a = 10; }",
-                      R"txt(
+  EXPECT_TRUE(treeDumpEqual(
+      R"cpp(
+void test() {
+  int a = 10;
+}
+)cpp",
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
   |   `-)
   `-CompoundStatement
     |-{
     |-DeclarationStatement
     | |-SimpleDeclaration
     | | |-int
     | | `-SimpleDeclarator
     | |   |-a
     | |   |-=
     | |   `-UnknownExpression
     | |     `-10
     | `-;
     `-}
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, Switch) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test() {
   switch (1) {
     case 0:
     default:;
   }
 }
 )cpp",
`-CompoundStatement
     |   | |-:
     |   | `-DefaultStatement
     |   |   |-default
     |   |   |-:
     |   |   `-EmptyStatement
     |   |     `-;
     |   `-}
     `-}
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, While) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test() {
   while (1) { continue; break; }
 }
 )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
`-CompoundStatement
     |   |-ContinueStatement
     |   | |-continue
     |   | `-;
     |   |-BreakStatement
     |   | |-break
     |   | `-;
     |   `-}
     `-}
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, UnhandledStatement) {
   // Unhandled statements should end up as 'unknown statement'.
   // This example uses a 'label statement', which does not yet have a syntax
   // counterpart.
-  expectTreeDumpEqual("int main() { foo: return 100; }",
-                      R"txt(
+  EXPECT_TRUE(treeDumpEqual(
+      R"cpp(
+int main() {
+  foo: return 100;
+}
+)cpp",
 *: TranslationUnit
 `-SimpleDeclaration
   |-int
   |-SimpleDeclarator
   | |-main
   | `-ParametersAndQualifiers
   |   |-(
   |   `-)
   `-CompoundStatement
     |-{
     |-UnknownStatement
     | |-foo
     | |-:
     | `-ReturnStatement
     |   |-return
     |   |-UnknownExpression
     |   | `-100
     |   `-;
     `-}
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, Expressions) {
   // expressions should be wrapped in 'ExpressionStatement' when they appear
   // in a statement position.
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test() {
   test();
   if (1) test(); else test();
 }
-    )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
`-CompoundStatement
     | `-ExpressionStatement
     |   |-UnknownExpression
     |   | |-UnknownExpression
     |   | | `-test
     |   | |-(
     |   | `-)
     |   `-;
     `-}
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, CxxNullPtrLiteral) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test() {
   nullptr;
 }
-    )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
   |   `-)
   `-CompoundStatement
     |-{
     |-ExpressionStatement
     | |-CxxNullPtrExpression
     | | `-nullptr
     | `-;
     `-}
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, PostfixUnaryOperator) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test(int a) {
   a++;
   a--;
 }
-    )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
`-CompoundStatement
     | `-;
     |-ExpressionStatement
     | |-PostfixUnaryOperatorExpression
     | | |-UnknownExpression
     | | | `-a
     | | `---
     | `-;
     `-}
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, PrefixUnaryOperator) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test(int a, int *ap) {
   --a; ++a;
   ~a;
   -a;
   +a;
   &a;
   *ap;
   !a;
   __real a; __imag a;
 }
-    )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
`-CompoundStatement
     | `-;
     |-ExpressionStatement
     | |-PrefixUnaryOperatorExpression
     | | |-__imag
     | | `-UnknownExpression
     | |   `-a
     | `-;
     `-}
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, PrefixUnaryOperatorCxx) {
   if (!GetParam().isCXX()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test(int a, bool b) {
   compl a;
   not b;
 }
-    )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
`-CompoundStatement
     | `-;
     |-ExpressionStatement
     | |-PrefixUnaryOperatorExpression
     | | |-not
     | | `-UnknownExpression
     | |   `-b
     | `-;
     `-}
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, BinaryOperator) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test(int a) {
   1 - 2;
   1 == 2;
   a = 1;
   a <<= 1;
   1 || 0;
   1 & 2;
   a ^= 3;
 }
-    )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
`-CompoundStatement
     | |-BinaryOperatorExpression
     | | |-UnknownExpression
     | | | `-a
     | | |-^=
     | | `-UnknownExpression
     | |   `-3
     | `-;
     `-}
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, BinaryOperatorCxx) {
   if (!GetParam().isCXX()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test(int a) {
   true || false;
   true or false;
   1 bitand 2;
   a xor_eq 3;
 }
-    )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
`-CompoundStatement
     | |-BinaryOperatorExpression
     | | |-UnknownExpression
     | | | `-a
     | | |-xor_eq
     | | `-UnknownExpression
     | |   `-3
     | `-;
     `-}
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, NestedBinaryOperator) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void test(int a, int b) {
   (1 + 2) * (4 / 2);
   a + b + 42;
   a = b = 42;
   a + b * 4 + 2;
   a % 2 + b * 42;
 }
-    )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-test
   | `-ParametersAndQualifiers
   |   |-(
`-CompoundStatement
     | | `-BinaryOperatorExpression
     | |   |-UnknownExpression
     | |   | `-b
     | |   |-*
     | |   `-UnknownExpression
     | |     `-42
     | `-;
     `-}
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, UserDefinedBinaryOperator) {
   if (!GetParam().isCXX()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct X {
   X& operator=(const X&);
   friend X operator+(X, const X&);
   friend bool operator<(const X&, const X&);
 };
 void test(X x, X y) {
   x = y;
   x + y;
   x < y;
 }
-      )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-struct
 | |-X
 | |-{
 | |-SimpleDeclaration
 | | |-X
`-CompoundStatement
     | | |-UnknownExpression
     | | | `-x
     | | |-UnknownExpression
     | | | `-<
     | | `-UnknownExpression
     | |   `-y
     | `-;
     `-}
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, MultipleDeclaratorsGrouping) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
-      int *a, b; int *c, d;
-  )cpp",
+int *a, b;
+int *c, d;
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-int
 | |-SimpleDeclarator
 | | |-*
 | | `-a
 | |-,
 | |-SimpleDeclarator
 | | `-b
 | `-;
 `-SimpleDeclaration
   |-int
   |-SimpleDeclarator
   | |-*
   | `-c
   |-,
   |-SimpleDeclarator
   | `-d
   `-;
-  )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, MultipleDeclaratorsGroupingTypedef) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
-    typedef int *a, b;
-  )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-typedef
   |-int
   |-SimpleDeclarator
   | |-*
   | `-a
   |-,
   |-SimpleDeclarator
   | `-b
   `-;
-  )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, MultipleDeclaratorsInsideStatement) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void foo() {
-      int *a, b;
-      typedef int *ta, tb;
 }
-  )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-foo
   | `-ParametersAndQualifiers
   |   |-(
`-CompoundStatement
     | | |-SimpleDeclarator
     | | | |-*
     | | | `-ta
     | | |-,
     | | `-SimpleDeclarator
     | |   `-tb
     | `-;
     `-}
-  )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, Namespaces) {
   if (!GetParam().isCXX()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 namespace a { namespace b {} }
 namespace a::b {}
 namespace {}
 
 namespace foo = a;
-    )cpp",
       R"txt(
 *: TranslationUnit
 |-NamespaceDefinition
 | |-namespace
 | |-a
 | |-{
 | |-NamespaceDefinition
 | | |-namespace

 | |-{
 | `-}
 `-NamespaceAliasDefinition
   |-namespace
   |-foo
   |-=
   |-a
   `-;
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, UsingDirective) {
   if (!GetParam().isCXX()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 namespace ns {}
 using namespace ::ns;
-    )cpp",
       R"txt(
 *: TranslationUnit
 |-NamespaceDefinition
 | |-namespace
 | |-ns
 | |-{
 | `-}
 `-UsingNamespaceDirective
   |-using
   |-namespace
   |-::
   |-ns
   `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, UsingDeclaration) {
   if (!GetParam().isCXX()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 namespace ns { int a; }
 using ns::a;
-    )cpp",
       R"txt(
 *: TranslationUnit
 |-NamespaceDefinition
 | |-namespace
 | |-ns
 | |-{
 | |-SimpleDeclaration
 | | |-int
 | | |-SimpleDeclarator
 | | | `-a
 | | `-;
 | `-}
 `-UsingDeclaration
   |-using
   |-ns
   |-::
   |-a
   `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, FreeStandingClasses) {
   // Free-standing classes, must live inside a SimpleDeclaration.
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct X;
 struct X {};
 
 struct Y *y1;
 struct Y {} *y2;
 
 struct {} *a1;
-    )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-struct
 | |-X
 | `-;
 |-SimpleDeclaration
 | |-struct

 `-SimpleDeclaration
   |-struct
   |-{
   |-}
   |-SimpleDeclarator
   | |-*
   | `-a1
   `-;
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, Templates) {
   if (!GetParam().isCXX()) {
     return;
   }
   if (GetParam().hasDelayedTemplateParsing()) {
     // FIXME: Make this test work on Windows by generating the expected syntax
     // tree when `-fdelayed-template-parsing` is active.
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 template <class T> struct cls {};
 template <class T> int var = 10;
 template <class T> int fun() {}
-    )cpp",
       R"txt(
 *: TranslationUnit
 |-TemplateDeclaration
 | |-template
 | |-<
 | |-UnknownDeclaration
 | | |-class
 | | `-T
`-SimpleDeclaration
     |-SimpleDeclarator
     | |-fun
     | `-ParametersAndQualifiers
     |   |-(
     |   `-)
     `-CompoundStatement
       |-{
       `-}
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, NestedTemplates) {
   if (!GetParam().isCXX()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 template <class T>
 struct X {
   template <class U>
   U foo();
 };
-    )cpp",
       R"txt(
 *: TranslationUnit
 `-TemplateDeclaration
   |-template
   |-<
   |-UnknownDeclaration
   | |-class
   | `-T
`-SimpleDeclaration
     |   |-SimpleDeclarator
     |   | |-foo
     |   | `-ParametersAndQualifiers
     |   |   |-(
     |   |   `-)
     |   `-;
     |-}
     `-;
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, Templates2) {
   if (!GetParam().isCXX()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 template <class T> struct X { struct Y; };
 template <class T> struct X<T>::Y {};
-    )cpp",
       R"txt(
 *: TranslationUnit
 |-TemplateDeclaration
 | |-template
 | |-<
 | |-UnknownDeclaration
 | | |-class
 | | `-T
`-SimpleDeclaration
     |-<
     |-T
     |->
     |-::
     |-Y
     |-{
     |-}
     `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, TemplatesUsingUsing) {
   if (!GetParam().isCXX()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 template <class T> struct X {
   using T::foo;
   using typename T::bar;
 };
-    )cpp",
       R"txt(
 *: TranslationUnit
 `-TemplateDeclaration
   |-template
   |-<
   |-UnknownDeclaration
   | |-class
   | `-T
`-SimpleDeclaration
     | |-using
     | |-typename
     | |-T
     | |-::
     | |-bar
     | `-;
     |-}
     `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, ExplicitTemplateInstantations) {
   if (!GetParam().isCXX()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 template <class T> struct X {};
 template <class T> struct X<T*> {};
 template <> struct X<int> {};
 
 template struct X<double>;
 extern template struct X<float>;
 )cpp",
`-ExplicitTemplateInstantiation
   |-template
   `-SimpleDeclaration
     |-struct
     |-X
     |-<
     |-float
     |->
     `-;
-)txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, UsingType) {
   if (!GetParam().isCXX()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 using type = int;
-    )cpp",
       R"txt(
 *: TranslationUnit
 `-TypeAliasDeclaration
   |-using
   |-type
   |-=
   |-int
   `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, EmptyDeclaration) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 ;
-    )cpp",
       R"txt(
 *: TranslationUnit
 `-EmptyDeclaration
   `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, StaticAssert) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 static_assert(true, "message");
 static_assert(true);
-    )cpp",
       R"txt(
 *: TranslationUnit
 |-StaticAssertDeclaration
 | |-static_assert
 | |-(
 | |-UnknownExpression
 | | `-true
 | |-,
 | |-UnknownExpression
 | | `-"message"
 | |-)
 | `-;
 `-StaticAssertDeclaration
   |-static_assert
   |-(
   |-UnknownExpression
   | `-true
   |-)
   `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, ExternC) {
   if (!GetParam().isCXX()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 extern "C" int a;
 extern "C" { int b; int c; }
-    )cpp",
       R"txt(
 *: TranslationUnit
 |-LinkageSpecificationDeclaration
 | |-extern
 | |-"C"
 | `-SimpleDeclaration
 |   |-int
 |   |-SimpleDeclarator
`-LinkageSpecificationDeclaration
   | | `-b
   | `-;
   |-SimpleDeclaration
   | |-int
   | |-SimpleDeclarator
   | | `-c
   | `-;
   `-}
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, NonModifiableNodes) {
   // Some nodes are non-modifiable, they are marked with 'I:'.
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 #define HALF_IF if (1+
 #define HALF_IF_2 1) {}
 void test() {
   HALF_IF HALF_IF_2 else {}
 })cpp",
       R"txt(
 *: TranslationUnit
`-CompoundStatement
     | |-I: CompoundStatement
     | | |-I: {
     | | `-I: }
     | |-else
     | `-CompoundStatement
     |   |-{
     |   `-}
     `-}
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, ModifiableNodes) {
   // All nodes can be mutated.
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 #define OPEN {
 #define CLOSE }
 
 void test() {
   OPEN
     1;
   CLOSE
`-CompoundStatement
     |-CompoundStatement
     | |-{
     | |-ExpressionStatement
     | | |-UnknownExpression
     | | | `-2
     | | `-;
     | `-}
     `-}
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, ArraySubscriptsInDeclarators) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int a[10];
 int b[1][2][3];
 int c[] = {1,2,3};
-    )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-int
 | |-SimpleDeclarator
 | | |-a
 | | `-ArraySubscript
 | |   |-[
`-SimpleDeclaration
   |     | `-1
   |     |-,
   |     |-UnknownExpression
   |     | `-2
   |     |-,
   |     |-UnknownExpression
   |     | `-3
   |     `-}
-  `-;       )txt");
+  `-;
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, StaticArraySubscriptsInDeclarators) {
   if (!GetParam().isC99OrLater()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void f(int xs[static 10]);
-    )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-f
   | `-ParametersAndQualifiers
   |   |-(
   |   |-SimpleDeclaration
   |   | |-int
   |   | `-SimpleDeclarator
   |   |   |-xs
   |   |   `-ArraySubscript
   |   |     |-[
   |   |     |-static
   |   |     |-UnknownExpression
   |   |     | `-10
   |   |     `-]
   |   `-)
-  `-;       )txt");
+  `-;
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, ParametersAndQualifiersInFreeFunctions) {
   if (!GetParam().isCXX()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int func1();
 int func2a(int a);
 int func2b(int);
 int func3a(int *ap);
 int func3b(int *);
 int func4a(int a, float b);
 int func4b(int, float);
-      )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-int
 | |-SimpleDeclarator
 | | |-func1
 | | `-ParametersAndQualifiers
 | |   |-(
`-SimpleDeclaration
   |   |-(
   |   |-SimpleDeclaration
   |   | `-int
   |   |-,
   |   |-SimpleDeclaration
   |   | `-float
   |   `-)
   `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, ParametersAndQualifiersInFreeFunctionsCxx) {
   if (!GetParam().isCXX()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int func1(const int a, volatile int b, const volatile int c);
 int func2(int& a);
-      )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-int
 | |-SimpleDeclarator
 | | |-func1
 | | `-ParametersAndQualifiers
 | |   |-(
`-SimpleDeclaration
   |   |-(
   |   |-SimpleDeclaration
   |   | |-int
   |   | `-SimpleDeclarator
   |   |   |-&
   |   |   `-a
   |   `-)
   `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, ParametersAndQualifiersInFreeFunctionsCxx11) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int func1(int&& a);
-      )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-int
   |-SimpleDeclarator
   | |-func1
   | `-ParametersAndQualifiers
   |   |-(
   |   |-SimpleDeclaration
   |   | |-int
   |   | `-SimpleDeclarator
   |   |   |-&&
   |   |   `-a
   |   `-)
   `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, ParametersAndQualifiersInMemberFunctions) {
   if (!GetParam().isCXX()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct Test {
   int a();
   int b() const;
   int c() volatile;
   int d() const volatile;
   int e() &;
   int f() &&;
 };
-      )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-struct
   |-Test
   |-{
   |-SimpleDeclaration
   | |-int
`-SimpleDeclaration
   | | |-f
   | | `-ParametersAndQualifiers
   | |   |-(
   | |   |-)
   | |   `-&&
   | `-;
   |-}
   `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, TrailingReturn) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 auto foo() -> int;
-    )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-auto
   |-SimpleDeclarator
   | |-foo
   | `-ParametersAndQualifiers
   |   |-(
   |   |-)
   |   `-TrailingReturnType
   |     |-->
   |     `-int
   `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, DynamicExceptionSpecification) {
   if (!GetParam().supportsCXXDynamicExceptionSpecification()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct MyException1 {};
 struct MyException2 {};
 int a() throw();
 int b() throw(...);
 int c() throw(MyException1);
 int d() throw(MyException1, MyException2);
-    )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-struct
 | |-MyException1
 | |-{
 | |-}
 | `-;
`-SimpleDeclaration
   |   |-)
   |   |-throw
   |   |-(
   |   |-MyException1
   |   |-,
   |   |-MyException2
   |   `-)
   `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, NoexceptExceptionSpecification) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int a() noexcept;
 int b() noexcept(true);
-    )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-int
 | |-SimpleDeclarator
 | | |-a
 | | `-ParametersAndQualifiers
 | |   |-(
 | |   |-)
 | |   `-noexcept
 | `-;
 `-SimpleDeclaration
   |-int
   |-SimpleDeclarator
   | |-b
   | `-ParametersAndQualifiers
   |   |-(
   |   |-)
   |   |-noexcept
   |   |-(
   |   |-UnknownExpression
   |   | `-true
   |   `-)
   `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, DeclaratorsInParentheses) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 int (a);
 int *(b);
 int (*c)(int);
 int *(d)(int);
-    )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-int
 | |-SimpleDeclarator
 | | `-ParenDeclarator
 | |   |-(
 | |   |-a
`-SimpleDeclaration
   | | |-d
   | | `-)
   | `-ParametersAndQualifiers
   |   |-(
   |   |-SimpleDeclaration
   |   | `-int
   |   `-)
   `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, ConstVolatileQualifiers) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 const int west = -1;
 int const east = 1;
 const int const universal = 0;
 const int const *const *volatile b;
-    )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-const
 | |-int
 | |-SimpleDeclarator
 | | |-west
 | | |-=
`-SimpleDeclaration
   |-const
   |-SimpleDeclarator
   | |-*
   | |-const
   | |-*
   | |-volatile
   | `-b
   `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, RangesOfDeclaratorsWithTrailingReturnTypes) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 auto foo() -> auto(*)(int) -> double*;
-    )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-auto
   |-SimpleDeclarator
   | |-foo
   | `-ParametersAndQualifiers
   |   |-(
`-SimpleDeclaration
   |         | `-int
   |         |-)
   |         `-TrailingReturnType
   |           |-->
   |           |-double
   |           `-SimpleDeclarator
   |             `-*
   `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, MemberPointers) {
   if (!GetParam().isCXX()) {
     return;
   }
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 struct X {};
 int X::* a;
 const int X::* b;
-    )cpp",
       R"txt(
 *: TranslationUnit
 |-SimpleDeclaration
 | |-struct
 | |-X
 | |-{
 | |-}
 | `-;
`-SimpleDeclaration
   |-int
   |-SimpleDeclarator
   | |-MemberPointer
   | | |-X
   | | |-::
   | | `-*
   | `-b
   `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, ComplexDeclarator) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void x(char a, short (*b)(int));
-    )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-x
   | `-ParametersAndQualifiers
   |   |-(
`-SimpleDeclaration
   |   |   | `-)
   |   |   `-ParametersAndQualifiers
   |   |     |-(
   |   |     |-SimpleDeclaration
   |   |     | `-int
   |   |     `-)
   |   `-)
   `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, ComplexDeclarator2) {
-  expectTreeDumpEqual(
+  EXPECT_TRUE(treeDumpEqual(
       R"cpp(
 void x(char a, short (*b)(int), long (**c)(long long));
-    )cpp",
       R"txt(
 *: TranslationUnit
 `-SimpleDeclaration
   |-void
   |-SimpleDeclarator
   | |-x
   | `-ParametersAndQualifiers
   |   |-(
`-SimpleDeclaration
   |   |   `-ParametersAndQualifiers
   |   |     |-(
   |   |     |-SimpleDeclaration
   |   |     | |-long
   |   |     | `-long
   |   |     `-)
   |   `-)
   `-;
-       )txt");
+)txt"));
 }
 
 TEST_P(SyntaxTreeTest, Mutations) {
   if (!GetParam().isCXX11OrLater()) {
     return;
   }
 
   using Transformation = std::function<void(