"""Tests for gmock.scripts.generator.cpp.gmock_class."""
-__author__ = 'nnorwitz@google.com (Neal Norwitz)'
-
-
import os
import sys
import unittest
class TestCase(unittest.TestCase):
"""Helper class that adds assert methods."""
- def StripLeadingWhitespace(self, lines):
+ @staticmethod
+ def StripLeadingWhitespace(lines):
"""Strip leading whitespace in each line in 'lines'."""
return '\n'.join([s.lstrip() for s in lines.split('\n')])
class GenerateMethodsTest(TestCase):
- def GenerateMethodSource(self, cpp_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.
};
"""
self.assertEqualIgnoreLeadingWhitespace(
- 'MOCK_METHOD0(Bar,\nint());',
+ 'MOCK_METHOD(int, Bar, (), (override));',
self.GenerateMethodSource(source))
def testSimpleConstructorsAndDestructor(self):
"""
# The constructors and destructor should be ignored.
self.assertEqualIgnoreLeadingWhitespace(
- 'MOCK_METHOD0(Bar,\nint());',
+ 'MOCK_METHOD(int, Bar, (), (override));',
self.GenerateMethodSource(source))
def testVirtualDestructor(self):
"""
# The destructor should be ignored.
self.assertEqualIgnoreLeadingWhitespace(
- 'MOCK_METHOD0(Bar,\nint());',
+ 'MOCK_METHOD(int, Bar, (), (override));',
self.GenerateMethodSource(source))
def testExplicitlyDefaultedConstructorsAndDestructor(self):
"""
# The constructors and destructor should be ignored.
self.assertEqualIgnoreLeadingWhitespace(
- 'MOCK_METHOD0(Bar,\nint());',
+ 'MOCK_METHOD(int, Bar, (), (override));',
self.GenerateMethodSource(source))
def testExplicitlyDeletedConstructorsAndDestructor(self):
"""
# The constructors and destructor should be ignored.
self.assertEqualIgnoreLeadingWhitespace(
- 'MOCK_METHOD0(Bar,\nint());',
+ 'MOCK_METHOD(int, Bar, (), (override));',
self.GenerateMethodSource(source))
def testSimpleOverrideMethod(self):
};
"""
self.assertEqualIgnoreLeadingWhitespace(
- 'MOCK_METHOD0(Bar,\nint());',
+ 'MOCK_METHOD(int, Bar, (), (override));',
self.GenerateMethodSource(source))
def testSimpleConstMethod(self):
};
"""
self.assertEqualIgnoreLeadingWhitespace(
- 'MOCK_CONST_METHOD1(Bar,\nvoid(bool flag));',
+ 'MOCK_METHOD(void, Bar, (bool flag), (const, override));',
self.GenerateMethodSource(source))
def testExplicitVoid(self):
};
"""
self.assertEqualIgnoreLeadingWhitespace(
- 'MOCK_METHOD0(Bar,\nint(void));',
+ 'MOCK_METHOD(int, Bar, (), (override));',
self.GenerateMethodSource(source))
def testStrangeNewlineInParameter(self):
};
"""
self.assertEqualIgnoreLeadingWhitespace(
- 'MOCK_METHOD1(Bar,\nvoid(int a));',
+ 'MOCK_METHOD(void, Bar, (int a), (override));',
self.GenerateMethodSource(source))
def testDefaultParameters(self):
};
"""
self.assertEqualIgnoreLeadingWhitespace(
- 'MOCK_METHOD2(Bar,\nvoid(int, char));',
+ 'MOCK_METHOD(void, Bar, (int a, char c), (override));',
self.GenerateMethodSource(source))
def testMultipleDefaultParameters(self):
source = """
class Foo {
public:
- virtual void Bar(int a = 42, char c = 'x') = 0;
+ virtual void Bar(
+ int a = 42,
+ char c = 'x',
+ const int* const p = nullptr,
+ const std::string& s = "42",
+ char tab[] = {'4','2'},
+ int const *& rp = aDefaultPointer) = 0;
};
"""
self.assertEqualIgnoreLeadingWhitespace(
- 'MOCK_METHOD2(Bar,\nvoid(int, char));',
+ '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 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;
+};
+"""
+ self.assertEqualIgnoreLeadingWhitespace(
+ 'MOCK_METHOD(bool, Bar, (const int test_arg), (override));',
+ self.GenerateMethodSource(source))
+
+ def testConstRefDefaultParameter(self):
+ source = """
+class Test {
+ public:
+ virtual bool Bar(const std::string& test_arg = "42" ) = 0;
+};
+"""
+ self.assertEqualIgnoreLeadingWhitespace(
+ 'MOCK_METHOD(bool, Bar, (const std::string& test_arg), (override));',
self.GenerateMethodSource(source))
def testRemovesCommentsWhenDefaultsArePresent(self):
};
"""
self.assertEqualIgnoreLeadingWhitespace(
- 'MOCK_METHOD2(Bar,\nvoid(int, char));',
+ 'MOCK_METHOD(void, Bar, (int a, char c), (override));',
self.GenerateMethodSource(source))
def testDoubleSlashCommentsInParameterListAreRemoved(self):
};
"""
self.assertEqualIgnoreLeadingWhitespace(
- 'MOCK_CONST_METHOD2(Bar,\nvoid(int a, int b));',
+ 'MOCK_METHOD(void, Bar, (int a, int b), (const, override));',
self.GenerateMethodSource(source))
def testCStyleCommentsInParameterListAreNotRemoved(self):
};
"""
self.assertEqualIgnoreLeadingWhitespace(
- 'MOCK_METHOD2(Bar,\nconst string&(int /* keeper */, int b));',
+ 'MOCK_METHOD(const string&, Bar, (int, int b), (override));',
self.GenerateMethodSource(source))
def testArgsOfTemplateTypes(self):
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));',
+ 'MOCK_METHOD(int, Bar, (const vector<int>& v, (map<int, string>* output)), (override));',
self.GenerateMethodSource(source))
def testReturnTypeWithOneTemplateArg(self):
virtual vector<int>* Bar(int n);
};"""
self.assertEqualIgnoreLeadingWhitespace(
- 'MOCK_METHOD1(Bar,\nvector<int>*(int n));',
+ 'MOCK_METHOD(vector<int>*, Bar, (int n), (override));',
self.GenerateMethodSource(source))
def testReturnTypeWithManyTemplateArgs(self):
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>());',
+ 'MOCK_METHOD((map<int, string>), Bar, (), (override));',
self.GenerateMethodSource(source))
def testSimpleMethodInTemplatedClass(self):
};
"""
self.assertEqualIgnoreLeadingWhitespace(
- 'MOCK_METHOD0_T(Bar,\nint());',
+ 'MOCK_METHOD(int, Bar, (), (override));',
self.GenerateMethodSource(source))
def testPointerArgWithoutNames(self):
};
"""
self.assertEqualIgnoreLeadingWhitespace(
- 'MOCK_METHOD1(Bar,\nint(C*));',
+ 'MOCK_METHOD(int, Bar, (C*), (override));',
self.GenerateMethodSource(source))
def testReferenceArgWithoutNames(self):
};
"""
self.assertEqualIgnoreLeadingWhitespace(
- 'MOCK_METHOD1(Bar,\nint(C&));',
+ 'MOCK_METHOD(int, Bar, (C&), (override));',
self.GenerateMethodSource(source))
def testArrayArgWithoutNames(self):
};
"""
self.assertEqualIgnoreLeadingWhitespace(
- 'MOCK_METHOD1(Bar,\nint(C[]));',
+ 'MOCK_METHOD(int, Bar, (C[]), (override));',
self.GenerateMethodSource(source))
class GenerateMocksTest(TestCase):
- def GenerateMocks(self, cpp_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>'
source = """
namespace Foo {
namespace Bar { class Forward; }
-namespace Baz {
+namespace Baz::Qux {
class Test {
public:
virtual void Foo();
};
-} // namespace Baz
+} // namespace Baz::Qux
} // namespace Foo
"""
expected = """\
namespace Foo {
-namespace Baz {
+namespace Baz::Qux {
class MockTest : public Test {
public:
-MOCK_METHOD0(Foo,
-void());
+MOCK_METHOD(void, Foo, (), (override));
};
-} // namespace Baz
+} // namespace Baz::Qux
} // namespace Foo
"""
- self.assertEqualIgnoreLeadingWhitespace(
- expected, self.GenerateMocks(source))
+ self.assertEqualIgnoreLeadingWhitespace(expected,
+ self.GenerateMocks(source))
def testClassWithStorageSpecifierMacro(self):
source = """
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 = """
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 = """
};
"""
expected = """\
-template <typename T0, typename T1>
-class MockTest : public Test<T0, T1> {
+template <typename S, typename T>
+class MockTest : public Test<S, T> {
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 = """
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 testTemplatedClassWithTemplatedArguments(self):
+ source = """
+template <typename S, typename T, typename U, typename V, typename W>
+class Test {
+ public:
+ virtual U Foo(T some_arg);
+};
+"""
+ expected = """\
+template <typename S, typename T, typename U, typename V, typename W>
+class MockTest : public Test<S, T, U, V, W> {
+public:
+MOCK_METHOD(U, Foo, (T some_arg), (override));
+};
+"""
+ self.assertEqualIgnoreLeadingWhitespace(expected,
+ self.GenerateMocks(source))
def testTemplateInATemplateTypedefWithComma(self):
source = """
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 testEnumClass(self):
+ def testParenthesizedCommaInArg(self):
source = """
class Test {
public:
- enum class Baz { BAZINGA };
- virtual void Bar(const FooType& test_arg);
+ 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 = """
+class Test {
+ public:
+ enum Bar {
+ BAZ, QUX, QUUX, QUUUX
+ };
+ virtual void Foo();
+};
+"""
+ expected = """\
+class MockTest : public Test {
+public:
+MOCK_METHOD(void, Foo, (), (override));
+};
+"""
+ self.assertEqualIgnoreLeadingWhitespace(expected,
+ self.GenerateMocks(source))
+
+ def testEnumClassType(self):
+ source = """
+class Test {
+ public:
+ enum class Bar {
+ BAZ, QUX, QUUX, QUUUX
+ };
+ virtual void Foo();
+};
+"""
+ expected = """\
+class MockTest : public Test {
+public:
+MOCK_METHOD(void, Foo, (), (override));
+};
+"""
+ self.assertEqualIgnoreLeadingWhitespace(expected,
+ self.GenerateMocks(source))
+
+ def testStdFunction(self):
+ source = """
+class Test {
+ public:
+ Test(std::function<int(std::string)> foo) : foo_(foo) {}
+
+ virtual std::function<int(std::string)> foo();
+
+ private:
+ std::function<int(std::string)> foo_;
+};
+"""
+ expected = """\
+class MockTest : public Test {
+public:
+MOCK_METHOD(std::function<int (std::string)>, foo, (), (override));
+};
+"""
+ self.assertEqualIgnoreLeadingWhitespace(expected,
+ self.GenerateMocks(source))
+
if __name__ == '__main__':
unittest.main()
projects / platform / upstream / gtest.git / blobdiff