From c2ad46a5df4414fc2b804c53525f4578f01a3dfe Mon Sep 17 00:00:00 2001 From: "zhanyong.wan" Date: Tue, 2 Jun 2009 20:41:21 +0000 Subject: Improves gmock generator and adds a test for it (by Neal Norwitz). --- scripts/generator/cpp/gmock_class_test.py | 137 ++++++++++++++++++++++++++++++ 1 file changed, 137 insertions(+) create mode 100755 scripts/generator/cpp/gmock_class_test.py (limited to 'scripts/generator/cpp/gmock_class_test.py') diff --git a/scripts/generator/cpp/gmock_class_test.py b/scripts/generator/cpp/gmock_class_test.py new file mode 100755 index 00000000..0132eef4 --- /dev/null +++ b/scripts/generator/cpp/gmock_class_test.py @@ -0,0 +1,137 @@ +#!/usr/bin/env python +# +# Copyright 2009 Neal Norwitz All Rights Reserved. +# Portions Copyright 2009 Google Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for gmock.scripts.generator.cpp.gmock_class.""" + +__author__ = 'nnorwitz@google.com (Neal Norwitz)' + + +import os +import sys +import unittest + +# Allow the cpp imports below to work when run as a standalone script. +sys.path.append(os.path.dirname(os.path.dirname(__file__))) + +from cpp import ast +from cpp import gmock_class + + +class TestCase(unittest.TestCase): + """Helper class that adds assert methods.""" + + def assertEqualIgnoreLeadingWhitespace(self, expected_lines, lines): + """Specialized assert that ignores the indent level.""" + stripped_lines = '\n'.join([s.lstrip() for s in lines.split('\n')]) + self.assertEqual(expected_lines, stripped_lines) + + +class GenerateMethodsTest(TestCase): + + def GenerateMethodSource(self, cpp_source): + """Helper method to convert C++ source to gMock output source lines.""" + method_source_lines = [] + # is a pseudo-filename, it is not read or written. + builder = ast.BuilderFromSource(cpp_source, '') + ast_list = list(builder.Generate()) + gmock_class._GenerateMethods(method_source_lines, cpp_source, ast_list[0]) + return ''.join(method_source_lines) + + def testStrangeNewlineInParameter(self): + source = """ +class Foo { + public: + virtual void Bar(int +a) = 0; +}; +""" + self.assertEqualIgnoreLeadingWhitespace( + 'MOCK_METHOD1(Bar,\nvoid(int a));', + self.GenerateMethodSource(source)) + + def testDoubleSlashCommentsInParameterListAreRemoved(self): + source = """ +class Foo { + public: + virtual void Bar(int a, // inline comments should be elided. + int b // inline comments should be elided. + ) const = 0; +}; +""" + self.assertEqualIgnoreLeadingWhitespace( + 'MOCK_CONST_METHOD2(Bar,\nvoid(int a, int b));', + 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 = """ +class Foo { + public: + virtual const string& Bar(int /* keeper */, int b); +}; +""" + self.assertEqualIgnoreLeadingWhitespace( + 'MOCK_METHOD2(Bar,\nconst string&(int /* keeper */, int b));', + self.GenerateMethodSource(source)) + + +class GenerateMocksTest(TestCase): + + def GenerateMocks(self, cpp_source): + """Helper method to convert C++ source to complete gMock output source.""" + # is a pseudo-filename, it is not read or written. + filename = '' + 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 { + +class Test { + public: + virtual void Foo(); +}; + +} // namespace Baz +} // namespace Foo +""" + expected = """\ +namespace Foo { +namespace Baz { + +class MockTest : public Test { +public: +MOCK_METHOD0(Foo, +void()); +}; + +} // namespace Baz +} // namespace Foo +""" + self.assertEqualIgnoreLeadingWhitespace( + expected, self.GenerateMocks(source)) + + +if __name__ == '__main__': + unittest.main() -- cgit v1.2.3 From b82431625d1842d1498f3c0e6f1923ce81837c6e Mon Sep 17 00:00:00 2001 From: "zhanyong.wan" Date: Thu, 4 Jun 2009 05:48:20 +0000 Subject: Makes all container matchers work with (possibly multi-dimensional) native arrays; makes Contains() accept a matcher; adds Value(x, m); improves gmock doctor to diagnose the Type in Template Base disease. --- scripts/generator/cpp/gmock_class_test.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'scripts/generator/cpp/gmock_class_test.py') diff --git a/scripts/generator/cpp/gmock_class_test.py b/scripts/generator/cpp/gmock_class_test.py index 0132eef4..ae00800f 100755 --- a/scripts/generator/cpp/gmock_class_test.py +++ b/scripts/generator/cpp/gmock_class_test.py @@ -25,7 +25,7 @@ import sys import unittest # Allow the cpp imports below to work when run as a standalone script. -sys.path.append(os.path.dirname(os.path.dirname(__file__))) +sys.path.append(os.path.join(os.path.dirname(__file__), '..')) from cpp import ast from cpp import gmock_class -- cgit v1.2.3 From d8e15d9c4a05553daa13dbfeaa1ed4bca899d079 Mon Sep 17 00:00:00 2001 From: "zhanyong.wan" Date: Tue, 5 Oct 2010 19:21:38 +0000 Subject: Adds more tests for the gmock generator. --- scripts/generator/cpp/gmock_class_test.py | 71 ++++++++++++++++++++++++++++--- 1 file changed, 66 insertions(+), 5 deletions(-) (limited to 'scripts/generator/cpp/gmock_class_test.py') diff --git a/scripts/generator/cpp/gmock_class_test.py b/scripts/generator/cpp/gmock_class_test.py index ae00800f..607d5cf7 100755 --- a/scripts/generator/cpp/gmock_class_test.py +++ b/scripts/generator/cpp/gmock_class_test.py @@ -34,22 +34,47 @@ from cpp import gmock_class class TestCase(unittest.TestCase): """Helper class that adds assert methods.""" + def StripLeadingWhitespace(self, 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.""" - stripped_lines = '\n'.join([s.lstrip() for s in lines.split('\n')]) - self.assertEqual(expected_lines, stripped_lines) + self.assertEqual(expected_lines, self.StripLeadingWhitespace(lines)) class GenerateMethodsTest(TestCase): def GenerateMethodSource(self, cpp_source): - """Helper method to convert C++ source to gMock output source lines.""" + """Convert C++ source to Google Mock output source lines.""" method_source_lines = [] # is a pseudo-filename, it is not read or written. builder = ast.BuilderFromSource(cpp_source, '') ast_list = list(builder.Generate()) gmock_class._GenerateMethods(method_source_lines, cpp_source, ast_list[0]) - return ''.join(method_source_lines) + 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)) + + 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)) def testStrangeNewlineInParameter(self): source = """ @@ -90,11 +115,47 @@ class Foo { 'MOCK_METHOD2(Bar,\nconst string&(int /* keeper */, int b));', self.GenerateMethodSource(source)) + def testArgsOfTemplateTypes(self): + source = """ +class Foo { + public: + virtual int Bar(const vector& v, map* output); +};""" + self.assertEqualIgnoreLeadingWhitespace( + 'MOCK_METHOD2(Bar,\n' + 'int(const vector& v, map* output));', + self.GenerateMethodSource(source)) + + def testReturnTypeWithOneTemplateArg(self): + source = """ +class Foo { + public: + virtual vector* Bar(int n); +};""" + self.assertEqualIgnoreLeadingWhitespace( + 'MOCK_METHOD1(Bar,\nvector*(int n));', + self.GenerateMethodSource(source)) + + def testReturnTypeWithManyTemplateArgs(self): + source = """ +class Foo { + public: + virtual map 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());', + self.GenerateMethodSource(source)) + class GenerateMocksTest(TestCase): def GenerateMocks(self, cpp_source): - """Helper method to convert C++ source to complete gMock output source.""" + """Convert C++ source to complete Google Mock output source.""" # is a pseudo-filename, it is not read or written. filename = '' builder = ast.BuilderFromSource(cpp_source, filename) -- cgit v1.2.3 From 5b61ce3ee5b15e6356487dd97236bf663a96a391 Mon Sep 17 00:00:00 2001 From: "zhanyong.wan" Date: Tue, 1 Feb 2011 00:00:03 +0000 Subject: Picks up gtest r536; renames implicit_cast and down_cast to reduce the chance of clash (by Roman Perepelitsa); enables gmock_gen.py to handle storage specifiers (by Steve Fox). --- scripts/generator/cpp/gmock_class_test.py | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) (limited to 'scripts/generator/cpp/gmock_class_test.py') diff --git a/scripts/generator/cpp/gmock_class_test.py b/scripts/generator/cpp/gmock_class_test.py index 607d5cf7..494720cd 100755 --- a/scripts/generator/cpp/gmock_class_test.py +++ b/scripts/generator/cpp/gmock_class_test.py @@ -193,6 +193,22 @@ void()); self.assertEqualIgnoreLeadingWhitespace( expected, self.GenerateMocks(source)) + def testClassWithStorageSpecifierMacro(self): + source = """ +class STORAGE_SPECIFIER Test { + public: + virtual void Foo(); +}; +""" + expected = """\ +class MockTest : public Test { +public: +MOCK_METHOD0(Foo, +void()); +}; +""" + self.assertEqualIgnoreLeadingWhitespace( + expected, self.GenerateMocks(source)) if __name__ == '__main__': unittest.main() -- cgit v1.2.3 From f4eeaedb39b6935f6236fe55a52bd9af0b8390ef Mon Sep 17 00:00:00 2001 From: vladlosev Date: Fri, 20 May 2011 21:44:14 +0000 Subject: Fixes issue 139 and issue 140. --- scripts/generator/cpp/gmock_class_test.py | 45 +++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) (limited to 'scripts/generator/cpp/gmock_class_test.py') diff --git a/scripts/generator/cpp/gmock_class_test.py b/scripts/generator/cpp/gmock_class_test.py index 494720cd..7aa70276 100755 --- a/scripts/generator/cpp/gmock_class_test.py +++ b/scripts/generator/cpp/gmock_class_test.py @@ -76,6 +76,17 @@ class Foo { 'MOCK_CONST_METHOD1(Bar,\nvoid(bool flag));', self.GenerateMethodSource(source)) + def testExplicitVoid(self): + source = """ +class Foo { + public: + virtual int Bar(void); +}; +""" + self.assertEqualIgnoreLeadingWhitespace( + 'MOCK_METHOD0(Bar,\nint(void));', + self.GenerateMethodSource(source)) + def testStrangeNewlineInParameter(self): source = """ class Foo { @@ -88,6 +99,40 @@ a) = 0; 'MOCK_METHOD1(Bar,\nvoid(int a));', self.GenerateMethodSource(source)) + def testDefaultParameters(self): + source = """ +class Foo { + public: + virtual void Bar(int a, char c = 'x') = 0; +}; +""" + self.assertEqualIgnoreLeadingWhitespace( + 'MOCK_METHOD2(Bar,\nvoid(int, char));', + self.GenerateMethodSource(source)) + + def testMultipleDefaultParameters(self): + source = """ +class Foo { + public: + virtual void Bar(int a = 42, char c = 'x') = 0; +}; +""" + self.assertEqualIgnoreLeadingWhitespace( + 'MOCK_METHOD2(Bar,\nvoid(int, char));', + self.GenerateMethodSource(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, char));', + self.GenerateMethodSource(source)) + def testDoubleSlashCommentsInParameterListAreRemoved(self): source = """ class Foo { -- cgit v1.2.3 From 45fef502fac471efa4bf25b3d4104943463912eb Mon Sep 17 00:00:00 2001 From: "zhanyong.wan" Date: Fri, 6 Sep 2013 22:52:14 +0000 Subject: makes googlemock generator handle some class templates; pulls in gtest r662 --- scripts/generator/cpp/gmock_class_test.py | 50 +++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) (limited to 'scripts/generator/cpp/gmock_class_test.py') diff --git a/scripts/generator/cpp/gmock_class_test.py b/scripts/generator/cpp/gmock_class_test.py index 7aa70276..07d59571 100755 --- a/scripts/generator/cpp/gmock_class_test.py +++ b/scripts/generator/cpp/gmock_class_test.py @@ -196,6 +196,18 @@ class Foo { 'MOCK_METHOD0(Bar,\nmap());', self.GenerateMethodSource(source)) + def testSimpleMethodInTemplatedClass(self): + source = """ +template +class Foo { + public: + virtual int Bar(); +}; +""" + self.assertEqualIgnoreLeadingWhitespace( + 'MOCK_METHOD0_T(Bar,\nint());', + self.GenerateMethodSource(source)) + class GenerateMocksTest(TestCase): @@ -255,5 +267,43 @@ void()); self.assertEqualIgnoreLeadingWhitespace( expected, self.GenerateMocks(source)) + def testTemplatedForwardDeclaration(self): + source = """ +template class Forward; // Forward declaration should be ignored. +class Test { + public: + virtual void Foo(); +}; +""" + expected = """\ +class MockTest : public Test { +public: +MOCK_METHOD0(Foo, +void()); +}; +""" + self.assertEqualIgnoreLeadingWhitespace( + expected, self.GenerateMocks(source)) + + def testTemplatedClass(self): + source = """ +template +class Test { + public: + virtual void Foo(); +}; +""" + expected = """\ +template +class MockTest : public Test { +public: +MOCK_METHOD0_T(Foo, +void()); +}; +""" + self.assertEqualIgnoreLeadingWhitespace( + expected, self.GenerateMocks(source)) + + if __name__ == '__main__': unittest.main() -- cgit v1.2.3 From c26f969579d62444ae7d422b37e0037ceca97a7a Mon Sep 17 00:00:00 2001 From: kosak Date: Wed, 12 Mar 2014 23:27:35 +0000 Subject: Make the gmock generator work with the 'override' keyword. Also pull in gtest 680. --- scripts/generator/cpp/gmock_class_test.py | 11 +++++++++++ 1 file changed, 11 insertions(+) (limited to 'scripts/generator/cpp/gmock_class_test.py') diff --git a/scripts/generator/cpp/gmock_class_test.py b/scripts/generator/cpp/gmock_class_test.py index 07d59571..361dad7f 100755 --- a/scripts/generator/cpp/gmock_class_test.py +++ b/scripts/generator/cpp/gmock_class_test.py @@ -60,6 +60,17 @@ class Foo { public: virtual int Bar(); }; +""" + self.assertEqualIgnoreLeadingWhitespace( + 'MOCK_METHOD0(Bar,\nint());', + self.GenerateMethodSource(source)) + + def testSimpleOverrideMethod(self): + source = """ +class Foo { + public: + int Bar() override; +}; """ self.assertEqualIgnoreLeadingWhitespace( 'MOCK_METHOD0(Bar,\nint());', -- cgit v1.2.3 From f58b49a2b14f9903d3118ffdd1485cbbe7a230d7 Mon Sep 17 00:00:00 2001 From: kosak Date: Mon, 17 Nov 2014 02:42:33 +0000 Subject: Handle parameters without variable names when the type includes *, & or []. --- scripts/generator/cpp/gmock_class_test.py | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) (limited to 'scripts/generator/cpp/gmock_class_test.py') diff --git a/scripts/generator/cpp/gmock_class_test.py b/scripts/generator/cpp/gmock_class_test.py index 361dad7f..ae3739af 100755 --- a/scripts/generator/cpp/gmock_class_test.py +++ b/scripts/generator/cpp/gmock_class_test.py @@ -219,6 +219,36 @@ class Foo { 'MOCK_METHOD0_T(Bar,\nint());', self.GenerateMethodSource(source)) + def testPointerArgWithoutNames(self): + source = """ +class Foo { + virtual int Bar(C*); +}; +""" + self.assertEqualIgnoreLeadingWhitespace( + 'MOCK_METHOD1(Bar,\nint(C*));', + self.GenerateMethodSource(source)) + + def testReferenceArgWithoutNames(self): + source = """ +class Foo { + virtual int Bar(C&); +}; +""" + self.assertEqualIgnoreLeadingWhitespace( + 'MOCK_METHOD1(Bar,\nint(C&));', + self.GenerateMethodSource(source)) + + def testArrayArgWithoutNames(self): + source = """ +class Foo { + virtual int Bar(C[]); +}; +""" + self.assertEqualIgnoreLeadingWhitespace( + 'MOCK_METHOD1(Bar,\nint(C[]));', + self.GenerateMethodSource(source)) + class GenerateMocksTest(TestCase): -- cgit v1.2.3 From 61adbcc5c6b8e0385e3e2bf4262771d20a375002 Mon Sep 17 00:00:00 2001 From: kosak Date: Mon, 17 Nov 2014 02:49:22 +0000 Subject: Add support for C++11 explicitly defaulted and deleted special member functions in the gmock generator. --- scripts/generator/cpp/gmock_class_test.py | 62 +++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) (limited to 'scripts/generator/cpp/gmock_class_test.py') diff --git a/scripts/generator/cpp/gmock_class_test.py b/scripts/generator/cpp/gmock_class_test.py index ae3739af..27eb86c8 100755 --- a/scripts/generator/cpp/gmock_class_test.py +++ b/scripts/generator/cpp/gmock_class_test.py @@ -65,6 +65,68 @@ class Foo { 'MOCK_METHOD0(Bar,\nint());', self.GenerateMethodSource(source)) + def testSimpleConstructorsAndDestructor(self): + source = """ +class Foo { + public: + Foo(); + Foo(int x); + Foo(const Foo& f); + Foo(Foo&& f); + ~Foo(); + virtual int Bar() = 0; +}; +""" + # The constructors and destructor should be ignored. + self.assertEqualIgnoreLeadingWhitespace( + 'MOCK_METHOD0(Bar,\nint());', + self.GenerateMethodSource(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)) + + def testExplicitlyDefaultedConstructorsAndDestructor(self): + source = """ +class Foo { + public: + Foo() = default; + Foo(const Foo& f) = default; + Foo(Foo&& f) = default; + ~Foo() = default; + virtual int Bar() = 0; +}; +""" + # The constructors and destructor should be ignored. + self.assertEqualIgnoreLeadingWhitespace( + 'MOCK_METHOD0(Bar,\nint());', + self.GenerateMethodSource(source)) + + def testExplicitlyDeletedConstructorsAndDestructor(self): + source = """ +class Foo { + public: + Foo() = delete; + Foo(const Foo& f) = delete; + Foo(Foo&& f) = delete; + ~Foo() = delete; + virtual int Bar() = 0; +}; +""" + # The constructors and destructor should be ignored. + self.assertEqualIgnoreLeadingWhitespace( + 'MOCK_METHOD0(Bar,\nint());', + self.GenerateMethodSource(source)) + def testSimpleOverrideMethod(self): source = """ class Foo { -- cgit v1.2.3 From 8e838ce0fd145431b433f534c71bdb7f5d6b11ac Mon Sep 17 00:00:00 2001 From: kosak Date: Thu, 8 Jan 2015 02:48:08 +0000 Subject: Adding support to gmock_gen for nested templates. --- scripts/generator/cpp/gmock_class_test.py | 36 +++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) (limited to 'scripts/generator/cpp/gmock_class_test.py') diff --git a/scripts/generator/cpp/gmock_class_test.py b/scripts/generator/cpp/gmock_class_test.py index 27eb86c8..018f90a6 100755 --- a/scripts/generator/cpp/gmock_class_test.py +++ b/scripts/generator/cpp/gmock_class_test.py @@ -407,6 +407,42 @@ void()); self.assertEqualIgnoreLeadingWhitespace( expected, self.GenerateMocks(source)) + def testTemplateInATemplateTypedef(self): + source = """ +class Test { + public: + typedef std::vector> FooType; + virtual void Bar(const FooType& test_arg); +}; +""" + expected = """\ +class MockTest : public Test { +public: +MOCK_METHOD1(Bar, +void(const FooType& test_arg)); +}; +""" + self.assertEqualIgnoreLeadingWhitespace( + expected, self.GenerateMocks(source)) + + def testTemplateInATemplateTypedefWithComma(self): + source = """ +class Test { + public: + typedef std::function>&, int> FooType; + virtual void Bar(const FooType& test_arg); +}; +""" + expected = """\ +class MockTest : public Test { +public: +MOCK_METHOD1(Bar, +void(const FooType& test_arg)); +}; +""" + self.assertEqualIgnoreLeadingWhitespace( + expected, self.GenerateMocks(source)) if __name__ == '__main__': unittest.main() -- cgit v1.2.3