3party/googletest
0
0
Fork 0
mirror of https://github.com/google/googletest.git synced 2025-03-20 10:53:47 +00:00
Code Projects Wiki

Googletest export

Browse Source 
Merge 65032e28cba171c000accc85ffaf6f1e62921b86 into 8c91ecef292e963d23cd5b25f01ea1579fbe9aaa

Closes #2470

COPYBARA_INTEGRATE_REVIEW=https://github.com/google/googletest/pull/2470 from hermas55:bugfix/default_const_param 65032e28cba171c000accc85ffaf6f1e62921b86
PiperOrigin-RevId: 277118535
This commit is contained in:
mhermas 2019-10-28 15:26:05 -04:00 committed by vslashg
parent 2bee6da24e
commit fff8dabbf6
3 changed files with 423 additions and 377 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
googlemock/scripts/generator/cpp/ast.py
View File

@ -1,19 +1,33 @@
#!/usr/bin/env python #!/usr/bin/env python
# #
# Copyright 2007 Neal Norwitz # Copyright 2008, Google Inc.
# Portions Copyright 2007 Google Inc. # All rights reserved.
# #
# Licensed under the Apache License, Version 2.0 (the "License"); # Redistribution and use in source and binary forms, with or without
# you may not use this file except in compliance with the License. # modification, are permitted provided that the following conditions are
# You may obtain a copy of the License at # met:
# #
# http://www.apache.org/licenses/LICENSE-2.0 # * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following disclaimer
# in the documentation and/or other materials provided with the
# distribution.
# * Neither the name of Google Inc. nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
# #
# Unless required by applicable law or agreed to in writing, software # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# distributed under the License is distributed on an "AS IS" BASIS, # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# See the License for the specific language governing permissions and # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# limitations under the License. # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""Generate an Abstract Syntax Tree (AST) for C++.""" """Generate an Abstract Syntax Tree (AST) for C++."""
@ -518,7 +532,7 @@ class TypeConverter(object):
elif token.name == '&': elif token.name == '&':
reference = True reference = True
elif token.name == '[': elif token.name == '[':
pointer = True pointer = True
elif token.name == ']': elif token.name == ']':
pass pass
else: else:
@ -576,7 +590,7 @@ class TypeConverter(object):
elif p.name not in ('*', '&', '>'): elif p.name not in ('*', '&', '>'):
# Ensure that names have a space between them. # Ensure that names have a space between them.
if (type_name and type_name[-1].token_type == tokenize.NAME and if (type_name and type_name[-1].token_type == tokenize.NAME and
p.token_type == tokenize.NAME): p.token_type == tokenize.NAME):
type_name.append(tokenize.Token(tokenize.SYNTAX, ' ', 0, 0)) type_name.append(tokenize.Token(tokenize.SYNTAX, ' ', 0, 0))
type_name.append(p) type_name.append(p)
else: else:
@ -652,7 +666,7 @@ class TypeConverter(object):
start = return_type_seq[0].start start = return_type_seq[0].start
end = return_type_seq[-1].end end = return_type_seq[-1].end
_, name, templated_types, modifiers, default, other_tokens = \ _, name, templated_types, modifiers, default, other_tokens = \
self.DeclarationToParts(return_type_seq, False) self.DeclarationToParts(return_type_seq, False)
names = [n.name for n in other_tokens] names = [n.name for n in other_tokens]
reference = '&' in names reference = '&' in names
pointer = '*' in names pointer = '*' in names
@ -816,7 +830,7 @@ class AstBuilder(object):
# self.in_class can contain A::Name, but the dtor will only # self.in_class can contain A::Name, but the dtor will only
# be Name. Make sure to compare against the right value. # be Name. Make sure to compare against the right value.
if (token.token_type == tokenize.NAME and if (token.token_type == tokenize.NAME and
token.name == self.in_class_name_only): token.name == self.in_class_name_only):
return self._GetMethod([token], FUNCTION_DTOR, None, True) return self._GetMethod([token], FUNCTION_DTOR, None, True)
# TODO(nnorwitz): handle a lot more syntax. # TODO(nnorwitz): handle a lot more syntax.
elif token.token_type == tokenize.PREPROCESSOR: elif token.token_type == tokenize.PREPROCESSOR:
@ -929,7 +943,10 @@ class AstBuilder(object):
def _GetNextToken(self): def _GetNextToken(self):
if self.token_queue: if self.token_queue:
return self.token_queue.pop() return self.token_queue.pop()
return next(self.tokens) try:
return next(self.tokens)
except StopIteration:
return
def _AddBackToken(self, token): def _AddBackToken(self, token):
if token.whence == tokenize.WHENCE_STREAM: if token.whence == tokenize.WHENCE_STREAM:
@ -1129,7 +1146,7 @@ class AstBuilder(object):
# Looks like we got a method, not a function. # Looks like we got a method, not a function.
if len(return_type) > 2 and return_type[-1].name == '::': if len(return_type) > 2 and return_type[-1].name == '::':
return_type, in_class = \ return_type, in_class = \
self._GetReturnTypeAndClassName(return_type) self._GetReturnTypeAndClassName(return_type)
return Method(indices.start, indices.end, name.name, in_class, return Method(indices.start, indices.end, name.name, in_class,
return_type, parameters, modifiers, templated_types, return_type, parameters, modifiers, templated_types,
body, self.namespace_stack) body, self.namespace_stack)
@ -1374,7 +1391,7 @@ class AstBuilder(object):
def handle_typedef(self): def handle_typedef(self):
token = self._GetNextToken() token = self._GetNextToken()
if (token.token_type == tokenize.NAME and if (token.token_type == tokenize.NAME and
keywords.IsKeyword(token.name)): keywords.IsKeyword(token.name)):
# Token must be struct/enum/union/class. # Token must be struct/enum/union/class.
method = getattr(self, 'handle_' + token.name) method = getattr(self, 'handle_' + token.name)
self._handling_typedef = True self._handling_typedef = True
@ -1397,7 +1414,7 @@ class AstBuilder(object):
if name.name == ')': if name.name == ')':
# HACK(nnorwitz): Handle pointers to functions "properly". # HACK(nnorwitz): Handle pointers to functions "properly".
if (len(tokens) >= 4 and if (len(tokens) >= 4 and
tokens[1].name == '(' and tokens[2].name == '*'): tokens[1].name == '(' and tokens[2].name == '*'):
tokens.append(name) tokens.append(name)
name = tokens[3] name = tokens[3]
elif name.name == ']': elif name.name == ']':

336
googlemock/scripts/generator/cpp/gmock_class.py
View File

@ -50,10 +50,11 @@ from cpp import utils
# Preserve compatibility with Python 2.3. # Preserve compatibility with Python 2.3.
try: try:
_dummy = set _dummy = set
except NameError: except NameError:
import sets import sets
set = sets.Set
set = sets.Set
_VERSION = (1, 0, 1) # The version of this script. _VERSION = (1, 0, 1) # The version of this script.
# How many spaces to indent. Can set me with the INDENT environment variable. # How many spaces to indent. Can set me with the INDENT environment variable.
@ -61,7 +62,7 @@ _INDENT = 2
def _RenderType(ast_type): def _RenderType(ast_type):
"""Renders the potentially recursively templated type into a string. """Renders the potentially recursively templated type into a string.
Args: Args:
ast_type: The AST of the type. ast_type: The AST of the type.
@ -70,198 +71,193 @@ def _RenderType(ast_type):
Rendered string and a boolean to indicate whether we have multiple args Rendered string and a boolean to indicate whether we have multiple args
(which is not handled correctly). (which is not handled correctly).
""" """
has_multiarg_error = False has_multiarg_error = False
# Add modifiers like 'const'. # Add modifiers like 'const'.
modifiers = '' modifiers = ''
if ast_type.modifiers: if ast_type.modifiers:
modifiers = ' '.join(ast_type.modifiers) + ' ' modifiers = ' '.join(ast_type.modifiers) + ' '
return_type = modifiers + ast_type.name return_type = modifiers + ast_type.name
if ast_type.templated_types: if ast_type.templated_types:
# Collect template args. # Collect template args.
template_args = [] template_args = []
for arg in ast_type.templated_types: for arg in ast_type.templated_types:
rendered_arg, e = _RenderType(arg) rendered_arg, e = _RenderType(arg)
if e: has_multiarg_error = True if e: has_multiarg_error = True
template_args.append(rendered_arg) template_args.append(rendered_arg)
return_type += '<' + ', '.join(template_args) + '>' return_type += '<' + ', '.join(template_args) + '>'
# We are actually not handling multi-template-args correctly. So mark it. # We are actually not handling multi-template-args correctly. So mark it.
if len(template_args) > 1: if len(template_args) > 1:
has_multiarg_error = True has_multiarg_error = True
if ast_type.pointer: if ast_type.pointer:
return_type += '*' return_type += '*'
if ast_type.reference: if ast_type.reference:
return_type += '&' return_type += '&'
return return_type, has_multiarg_error return return_type, has_multiarg_error
def _GetNumParameters(parameters, source): def _GetNumParameters(parameters, source):
num_parameters = len(parameters) num_parameters = len(parameters)
if num_parameters == 1: if num_parameters == 1:
first_param = parameters[0] first_param = parameters[0]
if source[first_param.start:first_param.end].strip() == 'void': if source[first_param.start:first_param.end].strip() == 'void':
# We must treat T(void) as a function with no parameters. # We must treat T(void) as a function with no parameters.
return 0 return 0
return num_parameters return num_parameters
def _GenerateMethods(output_lines, source, class_node): def _GenerateMethods(output_lines, source, class_node):
function_type = (ast.FUNCTION_VIRTUAL | ast.FUNCTION_PURE_VIRTUAL | function_type = (ast.FUNCTION_VIRTUAL | ast.FUNCTION_PURE_VIRTUAL |
ast.FUNCTION_OVERRIDE) ast.FUNCTION_OVERRIDE)
ctor_or_dtor = ast.FUNCTION_CTOR | ast.FUNCTION_DTOR ctor_or_dtor = ast.FUNCTION_CTOR | ast.FUNCTION_DTOR
indent = ' ' * _INDENT indent = ' ' * _INDENT
for node in class_node.body: for node in class_node.body:
# We only care about virtual functions. # We only care about virtual functions.
if (isinstance(node, ast.Function) and if (isinstance(node, ast.Function) and
node.modifiers & function_type and node.modifiers & function_type and
not node.modifiers & ctor_or_dtor): not node.modifiers & ctor_or_dtor):
# Pick out all the elements we need from the original function. # Pick out all the elements we need from the original function.
const = '' const = ''
if node.modifiers & ast.FUNCTION_CONST: if node.modifiers & ast.FUNCTION_CONST:
const = 'CONST_' const = 'CONST_'
num_parameters = _GetNumParameters(node.parameters, source) num_parameters = _GetNumParameters(node.parameters, source)
return_type = 'void' return_type = 'void'
if node.return_type: if node.return_type:
return_type, has_multiarg_error = _RenderType(node.return_type) return_type, has_multiarg_error = _RenderType(node.return_type)
if has_multiarg_error: if has_multiarg_error:
for line in [ for line in [
'// The following line won\'t really compile, as the return', '// The following line won\'t really compile, as the return',
'// type has multiple template arguments. To fix it, use a', '// type has multiple template arguments. To fix it, use a',
'// typedef for the return type.']: '// typedef for the return type.']:
output_lines.append(indent + line) output_lines.append(indent + line)
tmpl = '' tmpl = ''
if class_node.templated_types: if class_node.templated_types:
tmpl = '_T' tmpl = '_T'
mock_method_macro = 'MOCK_%sMETHOD%d%s' % (const, num_parameters, tmpl) mock_method_macro = 'MOCK_%sMETHOD%d%s' % (const, num_parameters, tmpl)
args = '' args = ''
if node.parameters: if node.parameters:
# Due to the parser limitations, it is impossible to keep comments # Get the full text of the parameters from the start
# while stripping the default parameters. When defaults are # of the first parameter to the end of the last parameter.
# present, we choose to strip them and comments (and produce start = node.parameters[0].start
# compilable code). end = node.parameters[-1].end
# TODO(nnorwitz@google.com): Investigate whether it is possible to # Remove // comments.
# preserve parameter name when reconstructing parameter text from args_strings = re.sub(r'//.*', '', source[start:end])
# the AST. # Remove /* comments */.
if len([param for param in node.parameters if param.default]) > 0: args_strings = re.sub(r'/\*.*\*/', '', args_strings)
args = ', '.join(param.type.name for param in node.parameters) # Remove default arguments.
else: args_strings = re.sub(r'=.*,', ',', args_strings)
# Get the full text of the parameters from the start args_strings = re.sub(r'=.*', '', args_strings)
# of the first parameter to the end of the last parameter. # Condense multiple spaces and eliminate newlines putting the
start = node.parameters[0].start # parameters together on a single line. Ensure there is a
end = node.parameters[-1].end # space in an argument which is split by a newline without
# Remove // comments. # intervening whitespace, e.g.: int\nBar
args_strings = re.sub(r'//.*', '', source[start:end]) args = re.sub(' +', ' ', args_strings.replace('\n', ' '))
# Condense multiple spaces and eliminate newlines putting the
# parameters together on a single line. Ensure there is a
# space in an argument which is split by a newline without
# intervening whitespace, e.g.: int\nBar
args = re.sub(' +', ' ', args_strings.replace('\n', ' '))
# Create the mock method definition. # Create the mock method definition.
output_lines.extend(['%s%s(%s,' % (indent, mock_method_macro, node.name), output_lines.extend(['%s%s(%s,' % (indent, mock_method_macro, node.name),
'%s%s(%s));' % (indent*3, return_type, args)]) '%s%s(%s));' % (indent * 3, return_type, args)])
def _GenerateMocks(filename, source, ast_list, desired_class_names): def _GenerateMocks(filename, source, ast_list, desired_class_names):
processed_class_names = set() processed_class_names = set()
lines = [] lines = []
for node in ast_list: for node in ast_list:
if (isinstance(node, ast.Class) and node.body and if (isinstance(node, ast.Class) and node.body and
# desired_class_names being None means that all classes are selected. # desired_class_names being None means that all classes are selected.
(not desired_class_names or node.name in desired_class_names)): (not desired_class_names or node.name in desired_class_names)):
class_name = node.name class_name = node.name
parent_name = class_name parent_name = class_name
processed_class_names.add(class_name) processed_class_names.add(class_name)
class_node = node class_node = node
# Add namespace before the class. # Add namespace before the class.
if class_node.namespace: if class_node.namespace:
lines.extend(['namespace %s {' % n for n in class_node.namespace]) # } lines.extend(['namespace %s {' % n for n in class_node.namespace]) # }
lines.append('') lines.append('')
# Add template args for templated classes. # Add template args for templated classes.
if class_node.templated_types: if class_node.templated_types:
# TODO(paulchang): The AST doesn't preserve template argument order, # TODO(paulchang): The AST doesn't preserve template argument order,
# so we have to make up names here. # so we have to make up names here.
# TODO(paulchang): Handle non-type template arguments (e.g. # TODO(paulchang): Handle non-type template arguments (e.g.
# template<typename T, int N>). # template<typename T, int N>).
template_arg_count = len(class_node.templated_types.keys()) template_arg_count = len(class_node.templated_types.keys())
template_args = ['T%d' % n for n in range(template_arg_count)] template_args = ['T%d' % n for n in range(template_arg_count)]
template_decls = ['typename ' + arg for arg in template_args] template_decls = ['typename ' + arg for arg in template_args]
lines.append('template <' + ', '.join(template_decls) + '>') lines.append('template <' + ', '.join(template_decls) + '>')
parent_name += '<' + ', '.join(template_args) + '>' parent_name += '<' + ', '.join(template_args) + '>'
# Add the class prolog. # Add the class prolog.
lines.append('class Mock%s : public %s {' # } lines.append('class Mock%s : public %s {' # }
% (class_name, parent_name)) % (class_name, parent_name))
lines.append('%spublic:' % (' ' * (_INDENT // 2))) lines.append('%spublic:' % (' ' * (_INDENT // 2)))
# Add all the methods. # Add all the methods.
_GenerateMethods(lines, source, class_node) _GenerateMethods(lines, source, class_node)
# Close the class. # Close the class.
if lines: if lines:
# If there are no virtual methods, no need for a public label. # If there are no virtual methods, no need for a public label.
if len(lines) == 2: if len(lines) == 2:
del lines[-1] del lines[-1]
# Only close the class if there really is a class. # Only close the class if there really is a class.
lines.append('};') lines.append('};')
lines.append('') # Add an extra newline. lines.append('') # Add an extra newline.
# Close the namespace. # Close the namespace.
if class_node.namespace: if class_node.namespace:
for i in range(len(class_node.namespace)-1, -1, -1): for i in range(len(class_node.namespace) - 1, -1, -1):
lines.append('} // namespace %s' % class_node.namespace[i]) lines.append('} // namespace %s' % class_node.namespace[i])
lines.append('') # Add an extra newline. lines.append('') # Add an extra newline.
if desired_class_names: if desired_class_names:
missing_class_name_list = list(desired_class_names - processed_class_names) missing_class_name_list = list(desired_class_names - processed_class_names)
if missing_class_name_list: if missing_class_name_list:
missing_class_name_list.sort() missing_class_name_list.sort()
sys.stderr.write('Class(es) not found in %s: %s\n' % sys.stderr.write('Class(es) not found in %s: %s\n' %
(filename, ', '.join(missing_class_name_list))) (filename, ', '.join(missing_class_name_list)))
elif not processed_class_names: elif not processed_class_names:
sys.stderr.write('No class found in %s\n' % filename) sys.stderr.write('No class found in %s\n' % filename)
return lines return lines
def main(argv=sys.argv): def main(argv=sys.argv):
if len(argv) < 2: if len(argv) < 2:
sys.stderr.write('Google Mock Class Generator v%s\n\n' % sys.stderr.write('Google Mock Class Generator v%s\n\n' %
'.'.join(map(str, _VERSION))) '.'.join(map(str, _VERSION)))
sys.stderr.write(__doc__) sys.stderr.write(__doc__)
return 1 return 1
global _INDENT global _INDENT
try: try:
_INDENT = int(os.environ['INDENT']) _INDENT = int(os.environ['INDENT'])
except KeyError: except KeyError:
pass pass
except: except:
sys.stderr.write('Unable to use indent of %s\n' % os.environ.get('INDENT')) sys.stderr.write('Unable to use indent of %s\n' % os.environ.get('INDENT'))
filename = argv[1] filename = argv[1]
desired_class_names = None # None means all classes in the source file. desired_class_names = None # None means all classes in the source file.
if len(argv) >= 3: if len(argv) >= 3:
desired_class_names = set(argv[2:]) desired_class_names = set(argv[2:])
source = utils.ReadFile(filename) source = utils.ReadFile(filename)
if source is None: if source is None:
return 1 return 1
builder = ast.BuilderFromSource(source, filename) builder = ast.BuilderFromSource(source, filename)
try: try:
entire_ast = filter(None, builder.Generate()) entire_ast = filter(None, builder.Generate())
except KeyboardInterrupt: except KeyboardInterrupt:
return return
except: except:
# An error message was already printed since we couldn't parse. # An error message was already printed since we couldn't parse.
sys.exit(1) sys.exit(1)
else: else:
lines = _GenerateMocks(filename, source, entire_ast, desired_class_names) lines = _GenerateMocks(filename, source, entire_ast, desired_class_names)
sys.stdout.write('\n'.join(lines)) sys.stdout.write('\n'.join(lines))
if __name__ == '__main__': if __name__ == '__main__':
main(sys.argv) main(sys.argv)

409
googlemock/scripts/generator/cpp/gmock_class_test.py
View File

@ -43,41 +43,43 @@ from cpp import gmock_class
class TestCase(unittest.TestCase): class TestCase(unittest.TestCase):
"""Helper class that adds assert methods.""" """Helper class that adds assert methods."""
def StripLeadingWhitespace(self, lines): @staticmethod
"""Strip leading whitespace in each line in 'lines'.""" def StripLeadingWhitespace(lines):
return '\n'.join([s.lstrip() for s in lines.split('\n')]) """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): def assertEqualIgnoreLeadingWhitespace(self, expected_lines, lines):
"""Specialized assert that ignores the indent level.""" """Specialized assert that ignores the indent level."""
self.assertEqual(expected_lines, self.StripLeadingWhitespace(lines)) self.assertEqual(expected_lines, self.StripLeadingWhitespace(lines))
class GenerateMethodsTest(TestCase): class GenerateMethodsTest(TestCase):
def GenerateMethodSource(self, cpp_source): @staticmethod
"""Convert C++ source to Google Mock output source lines.""" def GenerateMethodSource(cpp_source):
method_source_lines = [] """Convert C++ source to Google Mock output source lines."""
# <test> is a pseudo-filename, it is not read or written. method_source_lines = []
builder = ast.BuilderFromSource(cpp_source, '<test>') # <test> is a pseudo-filename, it is not read or written.
ast_list = list(builder.Generate()) builder = ast.BuilderFromSource(cpp_source, '<test>')
gmock_class._GenerateMethods(method_source_lines, cpp_source, ast_list[0]) ast_list = list(builder.Generate())
return '\n'.join(method_source_lines) gmock_class._GenerateMethods(method_source_lines, cpp_source, ast_list[0])
return '\n'.join(method_source_lines)
def testSimpleMethod(self): def testSimpleMethod(self):
source = """ source = """
class Foo { class Foo {
public: public:
virtual int Bar(); virtual int Bar();
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_METHOD0(Bar,\nint());', 'MOCK_METHOD0(Bar,\nint());',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
def testSimpleConstructorsAndDestructor(self): def testSimpleConstructorsAndDestructor(self):
source = """ source = """
class Foo { class Foo {
public: public:
Foo(); Foo();
@ -88,26 +90,26 @@ class Foo {
virtual int Bar() = 0; virtual int Bar() = 0;
}; };
""" """
# The constructors and destructor should be ignored. # The constructors and destructor should be ignored.
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_METHOD0(Bar,\nint());', 'MOCK_METHOD0(Bar,\nint());',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
def testVirtualDestructor(self): def testVirtualDestructor(self):
source = """ source = """
class Foo { class Foo {
public: public:
virtual ~Foo(); virtual ~Foo();
virtual int Bar() = 0; virtual int Bar() = 0;
}; };
""" """
# The destructor should be ignored. # The destructor should be ignored.
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_METHOD0(Bar,\nint());', 'MOCK_METHOD0(Bar,\nint());',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
def testExplicitlyDefaultedConstructorsAndDestructor(self): def testExplicitlyDefaultedConstructorsAndDestructor(self):
source = """ source = """
class Foo { class Foo {
public: public:
Foo() = default; Foo() = default;
@ -117,13 +119,13 @@ class Foo {
virtual int Bar() = 0; virtual int Bar() = 0;
}; };
""" """
# The constructors and destructor should be ignored. # The constructors and destructor should be ignored.
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_METHOD0(Bar,\nint());', 'MOCK_METHOD0(Bar,\nint());',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
def testExplicitlyDeletedConstructorsAndDestructor(self): def testExplicitlyDeletedConstructorsAndDestructor(self):
source = """ source = """
class Foo { class Foo {
public: public:
Foo() = delete; Foo() = delete;
@ -133,92 +135,121 @@ class Foo {
virtual int Bar() = 0; virtual int Bar() = 0;
}; };
""" """
# The constructors and destructor should be ignored. # The constructors and destructor should be ignored.
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_METHOD0(Bar,\nint());', 'MOCK_METHOD0(Bar,\nint());',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
def testSimpleOverrideMethod(self): def testSimpleOverrideMethod(self):
source = """ source = """
class Foo { class Foo {
public: public:
int Bar() override; int Bar() override;
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_METHOD0(Bar,\nint());', 'MOCK_METHOD0(Bar,\nint());',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
def testSimpleConstMethod(self): def testSimpleConstMethod(self):
source = """ source = """
class Foo { class Foo {
public: public:
virtual void Bar(bool flag) const; virtual void Bar(bool flag) const;
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_CONST_METHOD1(Bar,\nvoid(bool flag));', 'MOCK_CONST_METHOD1(Bar,\nvoid(bool flag));',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
def testExplicitVoid(self): def testExplicitVoid(self):
source = """ source = """
class Foo { class Foo {
public: public:
virtual int Bar(void); virtual int Bar(void);
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_METHOD0(Bar,\nint(void));', 'MOCK_METHOD0(Bar,\nint(void));',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
def testStrangeNewlineInParameter(self): def testStrangeNewlineInParameter(self):
source = """ source = """
class Foo { class Foo {
public: public:
virtual void Bar(int virtual void Bar(int
a) = 0; a) = 0;
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_METHOD1(Bar,\nvoid(int a));', 'MOCK_METHOD1(Bar,\nvoid(int a));',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
def testDefaultParameters(self): def testDefaultParameters(self):
source = """ source = """
class Foo { class Foo {
public: public:
virtual void Bar(int a, char c = 'x') = 0; virtual void Bar(int a, char c = 'x') = 0;
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_METHOD2(Bar,\nvoid(int, char));', 'MOCK_METHOD2(Bar,\nvoid(int a, char c ));',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
def testMultipleDefaultParameters(self): def testMultipleDefaultParameters(self):
source = """ source = """
class Foo { class Foo {
public: 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( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_METHOD2(Bar,\nvoid(int, char));', "MOCK_METHOD7(Bar,\n"
self.GenerateMethodSource(source)) "void(int a , char c , const int* const p , const std::string& s , char tab[] , int const *& rp ));",
self.GenerateMethodSource(source))
def testRemovesCommentsWhenDefaultsArePresent(self): def testConstDefaultParameter(self):
source = """ 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))
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))
def testRemovesCommentsWhenDefaultsArePresent(self):
source = """
class Foo { class Foo {
public: public:
virtual void Bar(int a = 42 /* a comment */, virtual void Bar(int a = 42 /* a comment */,
char /* other comment */ c= 'x') = 0; char /* other comment */ c= 'x') = 0;
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_METHOD2(Bar,\nvoid(int, char));', 'MOCK_METHOD2(Bar,\nvoid(int a , char c));',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
def testDoubleSlashCommentsInParameterListAreRemoved(self): def testDoubleSlashCommentsInParameterListAreRemoved(self):
source = """ source = """
class Foo { class Foo {
public: public:
virtual void Bar(int a, // inline comments should be elided. virtual void Bar(int a, // inline comments should be elided.
@ -226,116 +257,117 @@ class Foo {
) const = 0; ) const = 0;
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_CONST_METHOD2(Bar,\nvoid(int a, int b));', 'MOCK_CONST_METHOD2(Bar,\nvoid(int a, int b));',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
def testCStyleCommentsInParameterListAreNotRemoved(self): def testCStyleCommentsInParameterListAreNotRemoved(self):
# NOTE(nnorwitz): I'm not sure if it's the best behavior to keep these # 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 # comments. Also note that C style comments after the last parameter
# are still elided. # are still elided.
source = """ source = """
class Foo { class Foo {
public: public:
virtual const string& Bar(int /* keeper */, int b); virtual const string& Bar(int /* keeper */, int b);
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_METHOD2(Bar,\nconst string&(int /* keeper */, int b));', 'MOCK_METHOD2(Bar,\nconst string&(int , int b));',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
def testArgsOfTemplateTypes(self): def testArgsOfTemplateTypes(self):
source = """ source = """
class Foo { class Foo {
public: public:
virtual int Bar(const vector<int>& v, map<int, string>* output); virtual int Bar(const vector<int>& v, map<int, string>* output);
};""" };"""
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_METHOD2(Bar,\n' 'MOCK_METHOD2(Bar,\n'
'int(const vector<int>& v, map<int, string>* output));', 'int(const vector<int>& v, map<int, string>* output));',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
def testReturnTypeWithOneTemplateArg(self): def testReturnTypeWithOneTemplateArg(self):
source = """ source = """
class Foo { class Foo {
public: public:
virtual vector<int>* Bar(int n); virtual vector<int>* Bar(int n);
};""" };"""
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_METHOD1(Bar,\nvector<int>*(int n));', 'MOCK_METHOD1(Bar,\nvector<int>*(int n));',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
def testReturnTypeWithManyTemplateArgs(self): def testReturnTypeWithManyTemplateArgs(self):
source = """ source = """
class Foo { class Foo {
public: public:
virtual map<int, string> Bar(); virtual map<int, string> Bar();
};""" };"""
# Comparing the comment text is brittle - we'll think of something # 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. # better in case this gets annoying, but for now let's keep it simple.
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'// The following line won\'t really compile, as the return\n' '// The following line won\'t really compile, as the return\n'
'// type has multiple template arguments. To fix it, use a\n' '// type has multiple template arguments. To fix it, use a\n'
'// typedef for the return type.\n' '// typedef for the return type.\n'
'MOCK_METHOD0(Bar,\nmap<int, string>());', 'MOCK_METHOD0(Bar,\nmap<int, string>());',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
def testSimpleMethodInTemplatedClass(self): def testSimpleMethodInTemplatedClass(self):
source = """ source = """
template<class T> template<class T>
class Foo { class Foo {
public: public:
virtual int Bar(); virtual int Bar();
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_METHOD0_T(Bar,\nint());', 'MOCK_METHOD0_T(Bar,\nint());',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
def testPointerArgWithoutNames(self): def testPointerArgWithoutNames(self):
source = """ source = """
class Foo { class Foo {
virtual int Bar(C*); virtual int Bar(C*);
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_METHOD1(Bar,\nint(C*));', 'MOCK_METHOD1(Bar,\nint(C*));',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
def testReferenceArgWithoutNames(self): def testReferenceArgWithoutNames(self):
source = """ source = """
class Foo { class Foo {
virtual int Bar(C&); virtual int Bar(C&);
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_METHOD1(Bar,\nint(C&));', 'MOCK_METHOD1(Bar,\nint(C&));',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
def testArrayArgWithoutNames(self): def testArrayArgWithoutNames(self):
source = """ source = """
class Foo { class Foo {
virtual int Bar(C[]); virtual int Bar(C[]);
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
'MOCK_METHOD1(Bar,\nint(C[]));', 'MOCK_METHOD1(Bar,\nint(C[]));',
self.GenerateMethodSource(source)) self.GenerateMethodSource(source))
class GenerateMocksTest(TestCase): class GenerateMocksTest(TestCase):
def GenerateMocks(self, cpp_source): @staticmethod
"""Convert C++ source to complete Google Mock output source.""" def GenerateMocks(cpp_source):
# <test> is a pseudo-filename, it is not read or written. """Convert C++ source to complete Google Mock output source."""
filename = '<test>' # <test> is a pseudo-filename, it is not read or written.
builder = ast.BuilderFromSource(cpp_source, filename) filename = '<test>'
ast_list = list(builder.Generate()) builder = ast.BuilderFromSource(cpp_source, filename)
lines = gmock_class._GenerateMocks(filename, cpp_source, ast_list, None) ast_list = list(builder.Generate())
return '\n'.join(lines) lines = gmock_class._GenerateMocks(filename, cpp_source, ast_list, None)
return '\n'.join(lines)
def testNamespaces(self): def testNamespaces(self):
source = """ source = """
namespace Foo { namespace Foo {
namespace Bar { class Forward; } namespace Bar { class Forward; }
namespace Baz { namespace Baz {
@ -348,7 +380,7 @@ class Test {
} // namespace Baz } // namespace Baz
} // namespace Foo } // namespace Foo
""" """
expected = """\ expected = """\
namespace Foo { namespace Foo {
namespace Baz { namespace Baz {
@ -361,53 +393,53 @@ void());
} // namespace Baz } // namespace Baz
} // namespace Foo } // namespace Foo
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
expected, self.GenerateMocks(source)) expected, self.GenerateMocks(source))
def testClassWithStorageSpecifierMacro(self): def testClassWithStorageSpecifierMacro(self):
source = """ source = """
class STORAGE_SPECIFIER Test { class STORAGE_SPECIFIER Test {
public: public:
virtual void Foo(); virtual void Foo();
}; };
""" """
expected = """\ expected = """\
class MockTest : public Test { class MockTest : public Test {
public: public:
MOCK_METHOD0(Foo, MOCK_METHOD0(Foo,
void()); void());
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
expected, self.GenerateMocks(source)) expected, self.GenerateMocks(source))
def testTemplatedForwardDeclaration(self): def testTemplatedForwardDeclaration(self):
source = """ source = """
template <class T> class Forward; // Forward declaration should be ignored. template <class T> class Forward; // Forward declaration should be ignored.
class Test { class Test {
public: public:
virtual void Foo(); virtual void Foo();
}; };
""" """
expected = """\ expected = """\
class MockTest : public Test { class MockTest : public Test {
public: public:
MOCK_METHOD0(Foo, MOCK_METHOD0(Foo,
void()); void());
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
expected, self.GenerateMocks(source)) expected, self.GenerateMocks(source))
def testTemplatedClass(self): def testTemplatedClass(self):
source = """ source = """
template <typename S, typename T> template <typename S, typename T>
class Test { class Test {
public: public:
virtual void Foo(); virtual void Foo();
}; };
""" """
expected = """\ expected = """\
template <typename T0, typename T1> template <typename T0, typename T1>
class MockTest : public Test<T0, T1> { class MockTest : public Test<T0, T1> {
public: public:
@ -415,29 +447,29 @@ MOCK_METHOD0_T(Foo,
void()); void());
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
expected, self.GenerateMocks(source)) expected, self.GenerateMocks(source))
def testTemplateInATemplateTypedef(self): def testTemplateInATemplateTypedef(self):
source = """ source = """
class Test { class Test {
public: public:
typedef std::vector<std::list<int>> FooType; typedef std::vector<std::list<int>> FooType;
virtual void Bar(const FooType& test_arg); virtual void Bar(const FooType& test_arg);
}; };
""" """
expected = """\ expected = """\
class MockTest : public Test { class MockTest : public Test {
public: public:
MOCK_METHOD1(Bar, MOCK_METHOD1(Bar,
void(const FooType& test_arg)); void(const FooType& test_arg));
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
expected, self.GenerateMocks(source)) expected, self.GenerateMocks(source))
def testTemplateInATemplateTypedefWithComma(self): def testTemplateInATemplateTypedefWithComma(self):
source = """ source = """
class Test { class Test {
public: public:
typedef std::function<void( typedef std::function<void(
@ -445,18 +477,18 @@ class Test {
virtual void Bar(const FooType& test_arg); virtual void Bar(const FooType& test_arg);
}; };
""" """
expected = """\ expected = """\
class MockTest : public Test { class MockTest : public Test {
public: public:
MOCK_METHOD1(Bar, MOCK_METHOD1(Bar,
void(const FooType& test_arg)); void(const FooType& test_arg));
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
expected, self.GenerateMocks(source)) expected, self.GenerateMocks(source))
def testEnumType(self): def testEnumType(self):
source = """ source = """
class Test { class Test {
public: public:
enum Bar { enum Bar {
@ -465,18 +497,18 @@ class Test {
virtual void Foo(); virtual void Foo();
}; };
""" """
expected = """\ expected = """\
class MockTest : public Test { class MockTest : public Test {
public: public:
MOCK_METHOD0(Foo, MOCK_METHOD0(Foo,
void()); void());
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
expected, self.GenerateMocks(source)) expected, self.GenerateMocks(source))
def testEnumClassType(self): def testEnumClassType(self):
source = """ source = """
class Test { class Test {
public: public:
enum class Bar { enum class Bar {
@ -485,18 +517,18 @@ class Test {
virtual void Foo(); virtual void Foo();
}; };
""" """
expected = """\ expected = """\
class MockTest : public Test { class MockTest : public Test {
public: public:
MOCK_METHOD0(Foo, MOCK_METHOD0(Foo,
void()); void());
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
expected, self.GenerateMocks(source)) expected, self.GenerateMocks(source))
def testStdFunction(self): def testStdFunction(self):
source = """ source = """
class Test { class Test {
public: public:
Test(std::function<int(std::string)> foo) : foo_(foo) {} Test(std::function<int(std::string)> foo) : foo_(foo) {}
@ -507,15 +539,16 @@ class Test {
std::function<int(std::string)> foo_; std::function<int(std::string)> foo_;
}; };
""" """
expected = """\ expected = """\
class MockTest : public Test { class MockTest : public Test {
public: public:
MOCK_METHOD0(foo, MOCK_METHOD0(foo,
std::function<int (std::string)>()); std::function<int (std::string)>());
}; };
""" """
self.assertEqualIgnoreLeadingWhitespace( self.assertEqualIgnoreLeadingWhitespace(
expected, self.GenerateMocks(source)) expected, self.GenerateMocks(source))
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()