Running clang-format over all of GoogleTest

A few tests are examining code locations and looking af the resulting line
numbers to verify that GoogleTest shows those to users correctly. Some of those
locations change when clang-format is run. For those locations, I've wrapped
portions in:
// clang-format off
...
// clang-format on

There may be other locations that are currently not tickled by running
clang-format.

PiperOrigin-RevId: 434844712
Change-Id: I3a9f0a6f39eff741c576b6de389bef9b1d11139d

1 files changed, 50 insertions, 58 deletions

diff --git a/googlemock/test/gmock-cardinalities_test.cc b/googlemock/test/gmock-cardinalities_test.cc
index ca97cae..e7efd97 100644
--- a/googlemock/test/gmock-cardinalities_test.cc
+++ b/googlemock/test/gmock-cardinalities_test.cc
@@ -27,14 +27,13 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file tests the built-in cardinalities.
 
 #include "gmock/gmock.h"
-#include "gtest/gtest.h"
 #include "gtest/gtest-spi.h"
+#include "gtest/gtest.h"
 
 namespace {
 
@@ -59,9 +58,7 @@ class MockFoo {
 };
 
 // Tests that Cardinality objects can be default constructed.
-TEST(CardinalityTest, IsDefaultConstructable) {
-  Cardinality c;
-}
+TEST(CardinalityTest, IsDefaultConstructable) { Cardinality c; }
 
 // Tests that Cardinality objects are copyable.
 TEST(CardinalityTest, IsCopyable) {
@@ -119,8 +116,7 @@ TEST(AnyNumber, Works) {
 
   stringstream ss;
   c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called any number of times",
-                      ss.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called any number of times", ss.str());
 }
 
 TEST(AnyNumberTest, HasCorrectBounds) {
@@ -132,9 +128,11 @@ TEST(AnyNumberTest, HasCorrectBounds) {
 // Tests AtLeast(n).
 
 TEST(AtLeastTest, OnNegativeNumber) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    AtLeast(-1);
-  }, "The invocation lower bound must be >= 0");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        AtLeast(-1);
+      },
+      "The invocation lower bound must be >= 0");
 }
 
 TEST(AtLeastTest, OnZero) {
@@ -147,8 +145,7 @@ TEST(AtLeastTest, OnZero) {
 
   stringstream ss;
   c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "any number of times",
-                      ss.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "any number of times", ss.str());
 }
 
 TEST(AtLeastTest, OnPositiveNumber) {
@@ -164,18 +161,15 @@ TEST(AtLeastTest, OnPositiveNumber) {
 
   stringstream ss1;
   AtLeast(1).DescribeTo(&ss1);
-  EXPECT_PRED_FORMAT2(IsSubstring, "at least once",
-                      ss1.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "at least once", ss1.str());
 
   stringstream ss2;
   c.DescribeTo(&ss2);
-  EXPECT_PRED_FORMAT2(IsSubstring, "at least twice",
-                      ss2.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "at least twice", ss2.str());
 
   stringstream ss3;
   AtLeast(3).DescribeTo(&ss3);
-  EXPECT_PRED_FORMAT2(IsSubstring, "at least 3 times",
-                      ss3.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "at least 3 times", ss3.str());
 }
 
 TEST(AtLeastTest, HasCorrectBounds) {
@@ -187,9 +181,11 @@ TEST(AtLeastTest, HasCorrectBounds) {
 // Tests AtMost(n).
 
 TEST(AtMostTest, OnNegativeNumber) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    AtMost(-1);
-  }, "The invocation upper bound must be >= 0");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        AtMost(-1);
+      },
+      "The invocation upper bound must be >= 0");
 }
 
 TEST(AtMostTest, OnZero) {
@@ -202,8 +198,7 @@ TEST(AtMostTest, OnZero) {
 
   stringstream ss;
   c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "never called",
-                      ss.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "never called", ss.str());
 }
 
 TEST(AtMostTest, OnPositiveNumber) {
@@ -219,18 +214,15 @@ TEST(AtMostTest, OnPositiveNumber) {
 
   stringstream ss1;
   AtMost(1).DescribeTo(&ss1);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called at most once",
-                      ss1.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called at most once", ss1.str());
 
   stringstream ss2;
   c.DescribeTo(&ss2);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice",
-                      ss2.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice", ss2.str());
 
   stringstream ss3;
   AtMost(3).DescribeTo(&ss3);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called at most 3 times",
-                      ss3.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called at most 3 times", ss3.str());
 }
 
 TEST(AtMostTest, HasCorrectBounds) {
@@ -242,22 +234,28 @@ TEST(AtMostTest, HasCorrectBounds) {
 // Tests Between(m, n).
 
 TEST(BetweenTest, OnNegativeStart) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    Between(-1, 2);
-  }, "The invocation lower bound must be >= 0, but is actually -1");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        Between(-1, 2);
+      },
+      "The invocation lower bound must be >= 0, but is actually -1");
 }
 
 TEST(BetweenTest, OnNegativeEnd) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    Between(1, -2);
-  }, "The invocation upper bound must be >= 0, but is actually -2");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        Between(1, -2);
+      },
+      "The invocation upper bound must be >= 0, but is actually -2");
 }
 
 TEST(BetweenTest, OnStartBiggerThanEnd) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    Between(2, 1);
-  }, "The invocation upper bound (1) must be >= "
-     "the invocation lower bound (2)");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        Between(2, 1);
+      },
+      "The invocation upper bound (1) must be >= "
+      "the invocation lower bound (2)");
 }
 
 TEST(BetweenTest, OnZeroStartAndZeroEnd) {
@@ -271,8 +269,7 @@ TEST(BetweenTest, OnZeroStartAndZeroEnd) {
 
   stringstream ss;
   c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "never called",
-                      ss.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "never called", ss.str());
 }
 
 TEST(BetweenTest, OnZeroStartAndNonZeroEnd) {
@@ -289,8 +286,7 @@ TEST(BetweenTest, OnZeroStartAndNonZeroEnd) {
 
   stringstream ss;
   c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice",
-                      ss.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called at most twice", ss.str());
 }
 
 TEST(BetweenTest, OnSameStartAndEnd) {
@@ -307,8 +303,7 @@ TEST(BetweenTest, OnSameStartAndEnd) {
 
   stringstream ss;
   c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times",
-                      ss.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times", ss.str());
 }
 
 TEST(BetweenTest, OnDifferentStartAndEnd) {
@@ -328,8 +323,7 @@ TEST(BetweenTest, OnDifferentStartAndEnd) {
 
   stringstream ss;
   c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called between 3 and 5 times",
-                      ss.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called between 3 and 5 times", ss.str());
 }
 
 TEST(BetweenTest, HasCorrectBounds) {
@@ -341,9 +335,11 @@ TEST(BetweenTest, HasCorrectBounds) {
 // Tests Exactly(n).
 
 TEST(ExactlyTest, OnNegativeNumber) {
-  EXPECT_NONFATAL_FAILURE({  // NOLINT
-    Exactly(-1);
-  }, "The invocation lower bound must be >= 0");
+  EXPECT_NONFATAL_FAILURE(
+      {  // NOLINT
+        Exactly(-1);
+      },
+      "The invocation lower bound must be >= 0");
 }
 
 TEST(ExactlyTest, OnZero) {
@@ -356,8 +352,7 @@ TEST(ExactlyTest, OnZero) {
 
   stringstream ss;
   c.DescribeTo(&ss);
-  EXPECT_PRED_FORMAT2(IsSubstring, "never called",
-                      ss.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "never called", ss.str());
 }
 
 TEST(ExactlyTest, OnPositiveNumber) {
@@ -370,18 +365,15 @@ TEST(ExactlyTest, OnPositiveNumber) {
 
   stringstream ss1;
   Exactly(1).DescribeTo(&ss1);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called once",
-                      ss1.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called once", ss1.str());
 
   stringstream ss2;
   c.DescribeTo(&ss2);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called twice",
-                      ss2.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called twice", ss2.str());
 
   stringstream ss3;
   Exactly(3).DescribeTo(&ss3);
-  EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times",
-                      ss3.str());
+  EXPECT_PRED_FORMAT2(IsSubstring, "called 3 times", ss3.str());
 }
 
 TEST(ExactlyTest, HasCorrectBounds) {