From d0930731d601e4a061886bd78ca3d438ca19451d Mon Sep 17 00:00:00 2001
From: Abseil Team <absl-team@google.com>
Date: Tue, 11 Feb 2020 10:33:54 -0500
Subject: Googletest export

Fix gmock_gen to use MOCK_METHOD instead of old style macros.  Fix several
related bugs in argument parsing and return types.
- handle commas more correctly in return types
- handle commas correctly in arguments
- handle default values more correctly

PiperOrigin-RevId: 294435093
---
 .../scripts/generator/cpp/gmock_class_test.py      | 456 +++++++++++----------
 1 file changed, 234 insertions(+), 222 deletions(-)

(limited to 'googlemock/scripts/generator/cpp/gmock_class_test.py')

diff --git a/googlemock/scripts/generator/cpp/gmock_class_test.py b/googlemock/scripts/generator/cpp/gmock_class_test.py
index 211a92dd..74655692 100755
--- a/googlemock/scripts/generator/cpp/gmock_class_test.py
+++ b/googlemock/scripts/generator/cpp/gmock_class_test.py
@@ -29,43 +29,43 @@ from cpp import gmock_class
 
 
 class TestCase(unittest.TestCase):
-    """Helper class that adds assert methods."""
+  """Helper class that adds assert methods."""
 
-    @staticmethod
-    def StripLeadingWhitespace(lines):
-        """Strip leading whitespace in each line in 'lines'."""
-        return '\n'.join([s.lstrip() for s in lines.split('\n')])
+  @staticmethod
+  def StripLeadingWhitespace(lines):
+    """Strip leading whitespace in each line in 'lines'."""
+    return '\n'.join([s.lstrip() for s in lines.split('\n')])
 
-    def assertEqualIgnoreLeadingWhitespace(self, expected_lines, lines):
-        """Specialized assert that ignores the indent level."""
-        self.assertEqual(expected_lines, self.StripLeadingWhitespace(lines))
+  def assertEqualIgnoreLeadingWhitespace(self, expected_lines, lines):
+    """Specialized assert that ignores the indent level."""
+    self.assertEqual(expected_lines, self.StripLeadingWhitespace(lines))
 
 
 class GenerateMethodsTest(TestCase):
 
-    @staticmethod
-    def GenerateMethodSource(cpp_source):
-        """Convert C++ source to Google Mock output source lines."""
-        method_source_lines = []
-        # <test> is a pseudo-filename, it is not read or written.
-        builder = ast.BuilderFromSource(cpp_source, '<test>')
-        ast_list = list(builder.Generate())
-        gmock_class._GenerateMethods(method_source_lines, cpp_source, ast_list[0])
-        return '\n'.join(method_source_lines)
-
-    def testSimpleMethod(self):
-        source = """
+  @staticmethod
+  def GenerateMethodSource(cpp_source):
+    """Convert C++ source to Google Mock output source lines."""
+    method_source_lines = []
+    # <test> is a pseudo-filename, it is not read or written.
+    builder = ast.BuilderFromSource(cpp_source, '<test>')
+    ast_list = list(builder.Generate())
+    gmock_class._GenerateMethods(method_source_lines, cpp_source, ast_list[0])
+    return '\n'.join(method_source_lines)
+
+  def testSimpleMethod(self):
+    source = """
 class Foo {
  public:
   virtual int Bar();
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            'MOCK_METHOD0(Bar,\nint());',
-            self.GenerateMethodSource(source))
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(int, Bar, (), (override));',
+        self.GenerateMethodSource(source))
 
-    def testSimpleConstructorsAndDestructor(self):
-        source = """
+  def testSimpleConstructorsAndDestructor(self):
+    source = """
 class Foo {
  public:
   Foo();
@@ -76,26 +76,26 @@ class Foo {
   virtual int Bar() = 0;
 };
 """
-        # The constructors and destructor should be ignored.
-        self.assertEqualIgnoreLeadingWhitespace(
-            'MOCK_METHOD0(Bar,\nint());',
-            self.GenerateMethodSource(source))
+    # The constructors and destructor should be ignored.
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(int, Bar, (), (override));',
+        self.GenerateMethodSource(source))
 
-    def testVirtualDestructor(self):
-        source = """
+  def testVirtualDestructor(self):
+    source = """
 class Foo {
  public:
   virtual ~Foo();
   virtual int Bar() = 0;
 };
 """
-        # The destructor should be ignored.
-        self.assertEqualIgnoreLeadingWhitespace(
-            'MOCK_METHOD0(Bar,\nint());',
-            self.GenerateMethodSource(source))
+    # The destructor should be ignored.
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(int, Bar, (), (override));',
+        self.GenerateMethodSource(source))
 
-    def testExplicitlyDefaultedConstructorsAndDestructor(self):
-        source = """
+  def testExplicitlyDefaultedConstructorsAndDestructor(self):
+    source = """
 class Foo {
  public:
   Foo() = default;
@@ -105,13 +105,13 @@ class Foo {
   virtual int Bar() = 0;
 };
 """
-        # The constructors and destructor should be ignored.
-        self.assertEqualIgnoreLeadingWhitespace(
-            'MOCK_METHOD0(Bar,\nint());',
-            self.GenerateMethodSource(source))
+    # The constructors and destructor should be ignored.
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(int, Bar, (), (override));',
+        self.GenerateMethodSource(source))
 
-    def testExplicitlyDeletedConstructorsAndDestructor(self):
-        source = """
+  def testExplicitlyDeletedConstructorsAndDestructor(self):
+    source = """
 class Foo {
  public:
   Foo() = delete;
@@ -121,69 +121,69 @@ class Foo {
   virtual int Bar() = 0;
 };
 """
-        # The constructors and destructor should be ignored.
-        self.assertEqualIgnoreLeadingWhitespace(
-            'MOCK_METHOD0(Bar,\nint());',
-            self.GenerateMethodSource(source))
+    # The constructors and destructor should be ignored.
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(int, Bar, (), (override));',
+        self.GenerateMethodSource(source))
 
-    def testSimpleOverrideMethod(self):
-        source = """
+  def testSimpleOverrideMethod(self):
+    source = """
 class Foo {
  public:
   int Bar() override;
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            'MOCK_METHOD0(Bar,\nint());',
-            self.GenerateMethodSource(source))
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(int, Bar, (), (override));',
+        self.GenerateMethodSource(source))
 
-    def testSimpleConstMethod(self):
-        source = """
+  def testSimpleConstMethod(self):
+    source = """
 class Foo {
  public:
   virtual void Bar(bool flag) const;
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            'MOCK_CONST_METHOD1(Bar,\nvoid(bool flag));',
-            self.GenerateMethodSource(source))
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(void, Bar, (bool flag), (const, override));',
+        self.GenerateMethodSource(source))
 
-    def testExplicitVoid(self):
-        source = """
+  def testExplicitVoid(self):
+    source = """
 class Foo {
  public:
   virtual int Bar(void);
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            'MOCK_METHOD0(Bar,\nint(void));',
-            self.GenerateMethodSource(source))
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(int, Bar, (void), (override));',
+        self.GenerateMethodSource(source))
 
-    def testStrangeNewlineInParameter(self):
-        source = """
+  def testStrangeNewlineInParameter(self):
+    source = """
 class Foo {
  public:
   virtual void Bar(int
 a) = 0;
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            'MOCK_METHOD1(Bar,\nvoid(int a));',
-            self.GenerateMethodSource(source))
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(void, Bar, (int a), (override));',
+        self.GenerateMethodSource(source))
 
-    def testDefaultParameters(self):
-        source = """
+  def testDefaultParameters(self):
+    source = """
 class Foo {
  public:
   virtual void Bar(int a, char c = 'x') = 0;
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            'MOCK_METHOD2(Bar,\nvoid(int a, char c ));',
-            self.GenerateMethodSource(source))
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(void, Bar, (int a, char c), (override));',
+        self.GenerateMethodSource(source))
 
-    def testMultipleDefaultParameters(self):
-        source = """
+  def testMultipleDefaultParameters(self):
+    source = """
 class Foo {
  public:
   virtual void Bar(
@@ -195,47 +195,58 @@ class Foo {
         int const *& rp = aDefaultPointer) = 0;
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            "MOCK_METHOD7(Bar,\n"
-            "void(int a , char c , const int* const p , const std::string& s , char tab[] , int const *& rp ));",
-            self.GenerateMethodSource(source))
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(void, Bar, '
+        '(int a, char c, const int* const p, const std::string& s, char tab[], int const *& rp), '
+        '(override));', self.GenerateMethodSource(source))
 
-    def testConstDefaultParameter(self):
-        source = """
+  def testMultipleSingleLineDefaultParameters(self):
+    source = """
+class Foo {
+ public:
+  virtual void Bar(int a = 42, int b = 43, int c = 44) = 0;
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(void, Bar, (int a, int b, int c), (override));',
+        self.GenerateMethodSource(source))
+
+  def testConstDefaultParameter(self):
+    source = """
 class Test {
  public:
   virtual bool Bar(const int test_arg = 42) = 0;
 };
 """
-        expected = 'MOCK_METHOD1(Bar,\nbool(const int test_arg ));'
-        self.assertEqualIgnoreLeadingWhitespace(
-            expected, self.GenerateMethodSource(source))
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(bool, Bar, (const int test_arg), (override));',
+        self.GenerateMethodSource(source))
 
-    def testConstRefDefaultParameter(self):
-        source = """
+  def testConstRefDefaultParameter(self):
+    source = """
 class Test {
  public:
   virtual bool Bar(const std::string& test_arg = "42" ) = 0;
 };
 """
-        expected = 'MOCK_METHOD1(Bar,\nbool(const std::string& test_arg ));'
-        self.assertEqualIgnoreLeadingWhitespace(
-            expected, self.GenerateMethodSource(source))
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(bool, Bar, (const std::string& test_arg), (override));',
+        self.GenerateMethodSource(source))
 
-    def testRemovesCommentsWhenDefaultsArePresent(self):
-        source = """
+  def testRemovesCommentsWhenDefaultsArePresent(self):
+    source = """
 class Foo {
  public:
   virtual void Bar(int a = 42 /* a comment */,
                    char /* other comment */ c= 'x') = 0;
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            'MOCK_METHOD2(Bar,\nvoid(int a , char c));',
-            self.GenerateMethodSource(source))
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(void, Bar, (int a, char c), (override));',
+        self.GenerateMethodSource(source))
 
-    def testDoubleSlashCommentsInParameterListAreRemoved(self):
-        source = """
+  def testDoubleSlashCommentsInParameterListAreRemoved(self):
+    source = """
 class Foo {
  public:
   virtual void Bar(int a,  // inline comments should be elided.
@@ -243,117 +254,111 @@ class Foo {
                    ) const = 0;
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            'MOCK_CONST_METHOD2(Bar,\nvoid(int a, int b));',
-            self.GenerateMethodSource(source))
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(void, Bar, (int a, int b), (const, override));',
+        self.GenerateMethodSource(source))
 
-    def testCStyleCommentsInParameterListAreNotRemoved(self):
-        # NOTE(nnorwitz): I'm not sure if it's the best behavior to keep these
-        # comments.  Also note that C style comments after the last parameter
-        # are still elided.
-        source = """
+  def testCStyleCommentsInParameterListAreNotRemoved(self):
+    # NOTE(nnorwitz): I'm not sure if it's the best behavior to keep these
+    # comments.  Also note that C style comments after the last parameter
+    # are still elided.
+    source = """
 class Foo {
  public:
   virtual const string& Bar(int /* keeper */, int b);
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            'MOCK_METHOD2(Bar,\nconst string&(int , int b));',
-            self.GenerateMethodSource(source))
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(const string&, Bar, (int, int b), (override));',
+        self.GenerateMethodSource(source))
 
-    def testArgsOfTemplateTypes(self):
-        source = """
+  def testArgsOfTemplateTypes(self):
+    source = """
 class Foo {
  public:
   virtual int Bar(const vector<int>& v, map<int, string>* output);
 };"""
-        self.assertEqualIgnoreLeadingWhitespace(
-            'MOCK_METHOD2(Bar,\n'
-            'int(const vector<int>& v, map<int, string>* output));',
-            self.GenerateMethodSource(source))
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(int, Bar, (const vector<int>& v, (map<int, string>* output)), (override));',
+        self.GenerateMethodSource(source))
 
-    def testReturnTypeWithOneTemplateArg(self):
-        source = """
+  def testReturnTypeWithOneTemplateArg(self):
+    source = """
 class Foo {
  public:
   virtual vector<int>* Bar(int n);
 };"""
-        self.assertEqualIgnoreLeadingWhitespace(
-            'MOCK_METHOD1(Bar,\nvector<int>*(int n));',
-            self.GenerateMethodSource(source))
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(vector<int>*, Bar, (int n), (override));',
+        self.GenerateMethodSource(source))
 
-    def testReturnTypeWithManyTemplateArgs(self):
-        source = """
+  def testReturnTypeWithManyTemplateArgs(self):
+    source = """
 class Foo {
  public:
   virtual map<int, string> Bar();
 };"""
-        # Comparing the comment text is brittle - we'll think of something
-        # better in case this gets annoying, but for now let's keep it simple.
-        self.assertEqualIgnoreLeadingWhitespace(
-            '// The following line won\'t really compile, as the return\n'
-            '// type has multiple template arguments.  To fix it, use a\n'
-            '// typedef for the return type.\n'
-            'MOCK_METHOD0(Bar,\nmap<int, string>());',
-            self.GenerateMethodSource(source))
-
-    def testSimpleMethodInTemplatedClass(self):
-        source = """
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD((map<int, string>), Bar, (), (override));',
+        self.GenerateMethodSource(source))
+
+  def testSimpleMethodInTemplatedClass(self):
+    source = """
 template<class T>
 class Foo {
  public:
   virtual int Bar();
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            'MOCK_METHOD0_T(Bar,\nint());',
-            self.GenerateMethodSource(source))
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(int, Bar, (), (override));',
+        self.GenerateMethodSource(source))
 
-    def testPointerArgWithoutNames(self):
-        source = """
+  def testPointerArgWithoutNames(self):
+    source = """
 class Foo {
   virtual int Bar(C*);
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            'MOCK_METHOD1(Bar,\nint(C*));',
-            self.GenerateMethodSource(source))
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(int, Bar, (C*), (override));',
+        self.GenerateMethodSource(source))
 
-    def testReferenceArgWithoutNames(self):
-        source = """
+  def testReferenceArgWithoutNames(self):
+    source = """
 class Foo {
   virtual int Bar(C&);
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            'MOCK_METHOD1(Bar,\nint(C&));',
-            self.GenerateMethodSource(source))
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(int, Bar, (C&), (override));',
+        self.GenerateMethodSource(source))
 
-    def testArrayArgWithoutNames(self):
-        source = """
+  def testArrayArgWithoutNames(self):
+    source = """
 class Foo {
   virtual int Bar(C[]);
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            'MOCK_METHOD1(Bar,\nint(C[]));',
-            self.GenerateMethodSource(source))
+    self.assertEqualIgnoreLeadingWhitespace(
+        'MOCK_METHOD(int, Bar, (C[]), (override));',
+        self.GenerateMethodSource(source))
 
 
 class GenerateMocksTest(TestCase):
 
-    @staticmethod
-    def GenerateMocks(cpp_source):
-        """Convert C++ source to complete Google Mock output source."""
-        # <test> is a pseudo-filename, it is not read or written.
-        filename = '<test>'
-        builder = ast.BuilderFromSource(cpp_source, filename)
-        ast_list = list(builder.Generate())
-        lines = gmock_class._GenerateMocks(filename, cpp_source, ast_list, None)
-        return '\n'.join(lines)
-
-    def testNamespaces(self):
-        source = """
+  @staticmethod
+  def GenerateMocks(cpp_source):
+    """Convert C++ source to complete Google Mock output source."""
+    # <test> is a pseudo-filename, it is not read or written.
+    filename = '<test>'
+    builder = ast.BuilderFromSource(cpp_source, filename)
+    ast_list = list(builder.Generate())
+    lines = gmock_class._GenerateMocks(filename, cpp_source, ast_list, None)
+    return '\n'.join(lines)
+
+  def testNamespaces(self):
+    source = """
 namespace Foo {
 namespace Bar { class Forward; }
 namespace Baz {
@@ -366,96 +371,91 @@ class Test {
 }  // namespace Baz
 }  // namespace Foo
 """
-        expected = """\
+    expected = """\
 namespace Foo {
 namespace Baz {
 
 class MockTest : public Test {
 public:
-MOCK_METHOD0(Foo,
-void());
+MOCK_METHOD(void, Foo, (), (override));
 };
 
 }  // namespace Baz
 }  // namespace Foo
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            expected, self.GenerateMocks(source))
+    self.assertEqualIgnoreLeadingWhitespace(expected,
+                                            self.GenerateMocks(source))
 
-    def testClassWithStorageSpecifierMacro(self):
-        source = """
+  def testClassWithStorageSpecifierMacro(self):
+    source = """
 class STORAGE_SPECIFIER Test {
  public:
   virtual void Foo();
 };
 """
-        expected = """\
+    expected = """\
 class MockTest : public Test {
 public:
-MOCK_METHOD0(Foo,
-void());
+MOCK_METHOD(void, Foo, (), (override));
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            expected, self.GenerateMocks(source))
+    self.assertEqualIgnoreLeadingWhitespace(expected,
+                                            self.GenerateMocks(source))
 
-    def testTemplatedForwardDeclaration(self):
-        source = """
+  def testTemplatedForwardDeclaration(self):
+    source = """
 template <class T> class Forward;  // Forward declaration should be ignored.
 class Test {
  public:
   virtual void Foo();
 };
 """
-        expected = """\
+    expected = """\
 class MockTest : public Test {
 public:
-MOCK_METHOD0(Foo,
-void());
+MOCK_METHOD(void, Foo, (), (override));
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            expected, self.GenerateMocks(source))
+    self.assertEqualIgnoreLeadingWhitespace(expected,
+                                            self.GenerateMocks(source))
 
-    def testTemplatedClass(self):
-        source = """
+  def testTemplatedClass(self):
+    source = """
 template <typename S, typename T>
 class Test {
  public:
   virtual void Foo();
 };
 """
-        expected = """\
+    expected = """\
 template <typename T0, typename T1>
 class MockTest : public Test<T0, T1> {
 public:
-MOCK_METHOD0_T(Foo,
-void());
+MOCK_METHOD(void, Foo, (), (override));
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            expected, self.GenerateMocks(source))
+    self.assertEqualIgnoreLeadingWhitespace(expected,
+                                            self.GenerateMocks(source))
 
-    def testTemplateInATemplateTypedef(self):
-        source = """
+  def testTemplateInATemplateTypedef(self):
+    source = """
 class Test {
  public:
   typedef std::vector<std::list<int>> FooType;
   virtual void Bar(const FooType& test_arg);
 };
 """
-        expected = """\
+    expected = """\
 class MockTest : public Test {
 public:
-MOCK_METHOD1(Bar,
-void(const FooType& test_arg));
+MOCK_METHOD(void, Bar, (const FooType& test_arg), (override));
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            expected, self.GenerateMocks(source))
+    self.assertEqualIgnoreLeadingWhitespace(expected,
+                                            self.GenerateMocks(source))
 
-    def testTemplateInATemplateTypedefWithComma(self):
-        source = """
+  def testTemplateInATemplateTypedefWithComma(self):
+    source = """
 class Test {
  public:
   typedef std::function<void(
@@ -463,18 +463,33 @@ class Test {
   virtual void Bar(const FooType& test_arg);
 };
 """
-        expected = """\
+    expected = """\
+class MockTest : public Test {
+public:
+MOCK_METHOD(void, Bar, (const FooType& test_arg), (override));
+};
+"""
+    self.assertEqualIgnoreLeadingWhitespace(expected,
+                                            self.GenerateMocks(source))
+
+  def testParenthesizedCommaInArg(self):
+    source = """
+class Test {
+ public:
+   virtual void Bar(std::function<void(int, int)> f);
+};
+"""
+    expected = """\
 class MockTest : public Test {
 public:
-MOCK_METHOD1(Bar,
-void(const FooType& test_arg));
+MOCK_METHOD(void, Bar, (std::function<void(int, int)> f), (override));
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            expected, self.GenerateMocks(source))
+    self.assertEqualIgnoreLeadingWhitespace(expected,
+                                            self.GenerateMocks(source))
 
-    def testEnumType(self):
-        source = """
+  def testEnumType(self):
+    source = """
 class Test {
  public:
   enum Bar {
@@ -483,18 +498,17 @@ class Test {
   virtual void Foo();
 };
 """
-        expected = """\
+    expected = """\
 class MockTest : public Test {
 public:
-MOCK_METHOD0(Foo,
-void());
+MOCK_METHOD(void, Foo, (), (override));
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            expected, self.GenerateMocks(source))
+    self.assertEqualIgnoreLeadingWhitespace(expected,
+                                            self.GenerateMocks(source))
 
-    def testEnumClassType(self):
-        source = """
+  def testEnumClassType(self):
+    source = """
 class Test {
  public:
   enum class Bar {
@@ -503,18 +517,17 @@ class Test {
   virtual void Foo();
 };
 """
-        expected = """\
+    expected = """\
 class MockTest : public Test {
 public:
-MOCK_METHOD0(Foo,
-void());
+MOCK_METHOD(void, Foo, (), (override));
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            expected, self.GenerateMocks(source))
+    self.assertEqualIgnoreLeadingWhitespace(expected,
+                                            self.GenerateMocks(source))
 
-    def testStdFunction(self):
-        source = """
+  def testStdFunction(self):
+    source = """
 class Test {
  public:
   Test(std::function<int(std::string)> foo) : foo_(foo) {}
@@ -525,16 +538,15 @@ class Test {
   std::function<int(std::string)> foo_;
 };
 """
-        expected = """\
+    expected = """\
 class MockTest : public Test {
 public:
-MOCK_METHOD0(foo,
-std::function<int (std::string)>());
+MOCK_METHOD(std::function<int (std::string)>, foo, (), (override));
 };
 """
-        self.assertEqualIgnoreLeadingWhitespace(
-            expected, self.GenerateMocks(source))
+    self.assertEqualIgnoreLeadingWhitespace(expected,
+                                            self.GenerateMocks(source))
 
 
 if __name__ == '__main__':
-    unittest.main()
+  unittest.main()
-- 
cgit v1.2.3