3 files changed, 27 insertions, 25 deletions
diff --git a/googlemock/docs/for_dummies.md b/googlemock/docs/for_dummies.md
index 93cf06f3..327e6cc3 100644
--- a/googlemock/docs/for_dummies.md
+++ b/googlemock/docs/for_dummies.md
@@ -374,7 +374,7 @@ convenient way of saying "any value".
 In the above examples, `100` and `50` are also matchers; implicitly, they are
 the same as `Eq(100)` and `Eq(50)`, which specify that the argument must be
 equal (using `operator==`) to the matcher argument. There are many
-[built-in matchers](#MatcherList) for common types (as well as
+[built-in matchers](cheat_sheet.md#MatcherList) for common types (as well as
 [custom matchers](cook_book.md#NewMatchers)); for example:
 
 ```cpp
diff --git a/googlemock/include/gmock/gmock-spec-builders.h b/googlemock/include/gmock/gmock-spec-builders.h
index 30a75ce3..4b5fc661 100644
--- a/googlemock/include/gmock/gmock-spec-builders.h
+++ b/googlemock/include/gmock/gmock-spec-builders.h
@@ -1814,8 +1814,7 @@ class MockFunction<R(Args...)> {
     return mock_.With(std::move(m)...);
   }
 
-  MockSpec<R(Args...)> gmock_Call(const WithoutMatchers&,
-                                  R (*)(Args...)) {
+  MockSpec<R(Args...)> gmock_Call(const WithoutMatchers&, R (*)(Args...)) {
     return this->gmock_Call(::testing::A<Args>()...);
   }
 
@@ -1918,6 +1917,7 @@ using SignatureOfT = typename SignatureOf<F>::type;
 template <typename F>
 class MockFunction : public internal::MockFunction<internal::SignatureOfT<F>> {
   using Base = internal::MockFunction<internal::SignatureOfT<F>>;
+
  public:
   using Base::Base;
 };
diff --git a/googlemock/test/gmock-function-mocker_test.cc b/googlemock/test/gmock-function-mocker_test.cc
index 920b097f..94aaafba 100644
--- a/googlemock/test/gmock-function-mocker_test.cc
+++ b/googlemock/test/gmock-function-mocker_test.cc
@@ -779,55 +779,57 @@ TEST(MockMethodMockFunctionTest, AsStdFunctionWithReferenceParameter) {
   EXPECT_EQ(-1, call(foo.AsStdFunction(), i));
 }
 
-
 namespace {
 
 template <typename Expected, typename F>
-static constexpr bool IsMockFunctionTemplateArgumentDeducedTo(const MockFunction<F>&) {
+static constexpr bool IsMockFunctionTemplateArgumentDeducedTo(
+    const MockFunction<F>&) {
   return std::is_same<F, Expected>::value;
 }
 
-} // namespace
+}  // namespace
 
 template <typename F>
-class MockMethodMockFunctionSignatureTest : public Test {
-};
+class MockMethodMockFunctionSignatureTest : public Test {};
 
-using MockMethodMockFunctionSignatureTypes = Types<
-  void(),
-  int(),
-  void(int),
-  int(int),
-  int(bool, int),
-  int(bool, char, int, int, int, int, int, char, int, bool)
->;
-TYPED_TEST_SUITE(MockMethodMockFunctionSignatureTest, MockMethodMockFunctionSignatureTypes);
-
-TYPED_TEST(MockMethodMockFunctionSignatureTest, IsMockFunctionTemplateArgumentDeducedForRawSignature) {
+using MockMethodMockFunctionSignatureTypes =
+    Types<void(), int(), void(int), int(int), int(bool, int),
+          int(bool, char, int, int, int, int, int, char, int, bool)>;
+TYPED_TEST_SUITE(MockMethodMockFunctionSignatureTest,
+                 MockMethodMockFunctionSignatureTypes);
+
+TYPED_TEST(MockMethodMockFunctionSignatureTest,
+           IsMockFunctionTemplateArgumentDeducedForRawSignature) {
   using Argument = TypeParam;
   MockFunction<Argument> foo;
   EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<Argument>(foo));
 }
 
-TYPED_TEST(MockMethodMockFunctionSignatureTest, IsMockFunctionTemplateArgumentDeducedForStdFunction) {
+TYPED_TEST(MockMethodMockFunctionSignatureTest,
+           IsMockFunctionTemplateArgumentDeducedForStdFunction) {
   using Argument = std::function<TypeParam>;
   MockFunction<Argument> foo;
   EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<Argument>(foo));
 }
 
-TYPED_TEST(MockMethodMockFunctionSignatureTest, IsMockFunctionCallMethodSignatureTheSameForRawSignatureAndStdFunction) {
+TYPED_TEST(
+    MockMethodMockFunctionSignatureTest,
+    IsMockFunctionCallMethodSignatureTheSameForRawSignatureAndStdFunction) {
   using ForRawSignature = decltype(&MockFunction<TypeParam>::Call);
-  using ForStdFunction = decltype(&MockFunction<std::function<TypeParam>>::Call);
+  using ForStdFunction =
+      decltype(&MockFunction<std::function<TypeParam>>::Call);
   EXPECT_TRUE((std::is_same<ForRawSignature, ForStdFunction>::value));
 }
 
-TYPED_TEST(MockMethodMockFunctionSignatureTest, IsMockFunctionAsStdFunctionMethodSignatureTheSameForRawSignatureAndStdFunction) {
+TYPED_TEST(
+    MockMethodMockFunctionSignatureTest,
+    IsMockFunctionAsStdFunctionMethodSignatureTheSameForRawSignatureAndStdFunction) {
   using ForRawSignature = decltype(&MockFunction<TypeParam>::AsStdFunction);
-  using ForStdFunction = decltype(&MockFunction<std::function<TypeParam>>::AsStdFunction);
+  using ForStdFunction =
+      decltype(&MockFunction<std::function<TypeParam>>::AsStdFunction);
   EXPECT_TRUE((std::is_same<ForRawSignature, ForStdFunction>::value));
 }
 
-
 struct MockMethodSizes0 {
   MOCK_METHOD(void, func, ());
 };