f6ec81ffe7
This change updates gMock to the new release, 1.7.0. This is necessary for Android, as Android Master has updated their gTest to 1.7.0, and we must always use the matching version of gMock. This should not break any existing tests, as 1.7.0 is backwards-compatible with 1.6.0 code in nearly all cases. There are a few bugfixes around being too generous with type coercion in EXPECT_THAT() and ASSERT_THAT() that could break code that was accepted by the compiler before but was never technically safe. For a full list of changes, including all the awesome new matchers you can now use in your tests, see CHANGES, which is included from gMock unchanged. For a full list of modifications made to allow this to work on Android Master, see the updated README.android. No changes to the GYP files were necessary as part of this upgrade. Change-Id: Ib1445044e78c9fe0cf16031d544577d65ebbf6df
227 lines
8.0 KiB
Python
Executable File
227 lines
8.0 KiB
Python
Executable File
#!/usr/bin/env python
|
|
#
|
|
# Copyright 2008 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.
|
|
|
|
"""Generate Google Mock classes from base classes.
|
|
|
|
This program will read in a C++ source file and output the Google Mock
|
|
classes for the specified classes. If no class is specified, all
|
|
classes in the source file are emitted.
|
|
|
|
Usage:
|
|
gmock_class.py header-file.h [ClassName]...
|
|
|
|
Output is sent to stdout.
|
|
"""
|
|
|
|
__author__ = 'nnorwitz@google.com (Neal Norwitz)'
|
|
|
|
|
|
import os
|
|
import re
|
|
import sys
|
|
|
|
from cpp import ast
|
|
from cpp import utils
|
|
|
|
# Preserve compatibility with Python 2.3.
|
|
try:
|
|
_dummy = set
|
|
except NameError:
|
|
import sets
|
|
set = sets.Set
|
|
|
|
_VERSION = (1, 0, 1) # The version of this script.
|
|
# How many spaces to indent. Can set me with the INDENT environment variable.
|
|
_INDENT = 2
|
|
|
|
|
|
def _GenerateMethods(output_lines, source, class_node):
|
|
function_type = ast.FUNCTION_VIRTUAL | ast.FUNCTION_PURE_VIRTUAL
|
|
ctor_or_dtor = ast.FUNCTION_CTOR | ast.FUNCTION_DTOR
|
|
indent = ' ' * _INDENT
|
|
|
|
for node in class_node.body:
|
|
# We only care about virtual functions.
|
|
if (isinstance(node, ast.Function) and
|
|
node.modifiers & function_type and
|
|
not node.modifiers & ctor_or_dtor):
|
|
# Pick out all the elements we need from the original function.
|
|
const = ''
|
|
if node.modifiers & ast.FUNCTION_CONST:
|
|
const = 'CONST_'
|
|
return_type = 'void'
|
|
if node.return_type:
|
|
# Add modifiers like 'const'.
|
|
modifiers = ''
|
|
if node.return_type.modifiers:
|
|
modifiers = ' '.join(node.return_type.modifiers) + ' '
|
|
return_type = modifiers + node.return_type.name
|
|
template_args = [arg.name for arg in node.return_type.templated_types]
|
|
if template_args:
|
|
return_type += '<' + ', '.join(template_args) + '>'
|
|
if len(template_args) > 1:
|
|
for line in [
|
|
'// The following line won\'t really compile, as the return',
|
|
'// type has multiple template arguments. To fix it, use a',
|
|
'// typedef for the return type.']:
|
|
output_lines.append(indent + line)
|
|
if node.return_type.pointer:
|
|
return_type += '*'
|
|
if node.return_type.reference:
|
|
return_type += '&'
|
|
num_parameters = len(node.parameters)
|
|
if len(node.parameters) == 1:
|
|
first_param = node.parameters[0]
|
|
if source[first_param.start:first_param.end].strip() == 'void':
|
|
# We must treat T(void) as a function with no parameters.
|
|
num_parameters = 0
|
|
tmpl = ''
|
|
if class_node.templated_types:
|
|
tmpl = '_T'
|
|
mock_method_macro = 'MOCK_%sMETHOD%d%s' % (const, num_parameters, tmpl)
|
|
|
|
args = ''
|
|
if node.parameters:
|
|
# Due to the parser limitations, it is impossible to keep comments
|
|
# while stripping the default parameters. When defaults are
|
|
# present, we choose to strip them and comments (and produce
|
|
# compilable code).
|
|
# TODO(nnorwitz@google.com): Investigate whether it is possible to
|
|
# preserve parameter name when reconstructing parameter text from
|
|
# the AST.
|
|
if len([param for param in node.parameters if param.default]) > 0:
|
|
args = ', '.join(param.type.name for param in node.parameters)
|
|
else:
|
|
# Get the full text of the parameters from the start
|
|
# of the first parameter to the end of the last parameter.
|
|
start = node.parameters[0].start
|
|
end = node.parameters[-1].end
|
|
# Remove // comments.
|
|
args_strings = re.sub(r'//.*', '', source[start:end])
|
|
# 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.
|
|
output_lines.extend(['%s%s(%s,' % (indent, mock_method_macro, node.name),
|
|
'%s%s(%s));' % (indent*3, return_type, args)])
|
|
|
|
|
|
def _GenerateMocks(filename, source, ast_list, desired_class_names):
|
|
processed_class_names = set()
|
|
lines = []
|
|
for node in ast_list:
|
|
if (isinstance(node, ast.Class) and node.body and
|
|
# desired_class_names being None means that all classes are selected.
|
|
(not desired_class_names or node.name in desired_class_names)):
|
|
class_name = node.name
|
|
parent_name = class_name
|
|
processed_class_names.add(class_name)
|
|
class_node = node
|
|
# Add namespace before the class.
|
|
if class_node.namespace:
|
|
lines.extend(['namespace %s {' % n for n in class_node.namespace]) # }
|
|
lines.append('')
|
|
|
|
# Add template args for templated classes.
|
|
if class_node.templated_types:
|
|
# TODO(paulchang): The AST doesn't preserve template argument order,
|
|
# so we have to make up names here.
|
|
# TODO(paulchang): Handle non-type template arguments (e.g.
|
|
# template<typename T, int N>).
|
|
template_arg_count = len(class_node.templated_types.keys())
|
|
template_args = ['T%d' % n for n in range(template_arg_count)]
|
|
template_decls = ['typename ' + arg for arg in template_args]
|
|
lines.append('template <' + ', '.join(template_decls) + '>')
|
|
parent_name += '<' + ', '.join(template_args) + '>'
|
|
|
|
# Add the class prolog.
|
|
lines.append('class Mock%s : public %s {' # }
|
|
% (class_name, parent_name))
|
|
lines.append('%spublic:' % (' ' * (_INDENT // 2)))
|
|
|
|
# Add all the methods.
|
|
_GenerateMethods(lines, source, class_node)
|
|
|
|
# Close the class.
|
|
if lines:
|
|
# If there are no virtual methods, no need for a public label.
|
|
if len(lines) == 2:
|
|
del lines[-1]
|
|
|
|
# Only close the class if there really is a class.
|
|
lines.append('};')
|
|
lines.append('') # Add an extra newline.
|
|
|
|
# Close the namespace.
|
|
if class_node.namespace:
|
|
for i in range(len(class_node.namespace)-1, -1, -1):
|
|
lines.append('} // namespace %s' % class_node.namespace[i])
|
|
lines.append('') # Add an extra newline.
|
|
|
|
if desired_class_names:
|
|
missing_class_name_list = list(desired_class_names - processed_class_names)
|
|
if missing_class_name_list:
|
|
missing_class_name_list.sort()
|
|
sys.stderr.write('Class(es) not found in %s: %s\n' %
|
|
(filename, ', '.join(missing_class_name_list)))
|
|
elif not processed_class_names:
|
|
sys.stderr.write('No class found in %s\n' % filename)
|
|
|
|
return lines
|
|
|
|
|
|
def main(argv=sys.argv):
|
|
if len(argv) < 2:
|
|
sys.stderr.write('Google Mock Class Generator v%s\n\n' %
|
|
'.'.join(map(str, _VERSION)))
|
|
sys.stderr.write(__doc__)
|
|
return 1
|
|
|
|
global _INDENT
|
|
try:
|
|
_INDENT = int(os.environ['INDENT'])
|
|
except KeyError:
|
|
pass
|
|
except:
|
|
sys.stderr.write('Unable to use indent of %s\n' % os.environ.get('INDENT'))
|
|
|
|
filename = argv[1]
|
|
desired_class_names = None # None means all classes in the source file.
|
|
if len(argv) >= 3:
|
|
desired_class_names = set(argv[2:])
|
|
source = utils.ReadFile(filename)
|
|
if source is None:
|
|
return 1
|
|
|
|
builder = ast.BuilderFromSource(source, filename)
|
|
try:
|
|
entire_ast = filter(None, builder.Generate())
|
|
except KeyboardInterrupt:
|
|
return
|
|
except:
|
|
# An error message was already printed since we couldn't parse.
|
|
pass
|
|
else:
|
|
lines = _GenerateMocks(filename, source, entire_ast, desired_class_names)
|
|
sys.stdout.write('\n'.join(lines))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main(sys.argv)
|