aboutsummaryrefslogtreecommitdiffstats
path: root/googlemock/scripts/generator/cpp/gmock_class_test.py
diff options
context:
space:
mode:
Diffstat (limited to 'googlemock/scripts/generator/cpp/gmock_class_test.py')
-rwxr-xr-xgooglemock/scripts/generator/cpp/gmock_class_test.py429
1 files changed, 207 insertions, 222 deletions
diff --git a/googlemock/scripts/generator/cpp/gmock_class_test.py b/googlemock/scripts/generator/cpp/gmock_class_test.py
index 211a92dd..4e18a850 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,47 @@ 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 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 +243,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 +360,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 +452,17 @@ class Test {
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 testEnumType(self):
- source = """
+ def testEnumType(self):
+ source = """
class Test {
public:
enum Bar {
@@ -483,18 +471,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 +490,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 +511,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()
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-01 15:53:42 +0000