641 lines
24 KiB
Python
641 lines
24 KiB
Python
#!/usr/bin/env python
|
|
#
|
|
# Copyright 2008, Google Inc.
|
|
# All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions are
|
|
# met:
|
|
#
|
|
# * 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.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
# 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.
|
|
|
|
"""Converts compiler's errors in code using Google Mock to plain English."""
|
|
|
|
__author__ = 'wan@google.com (Zhanyong Wan)'
|
|
|
|
import re
|
|
import sys
|
|
|
|
_VERSION = '1.0.3'
|
|
|
|
_EMAIL = 'googlemock@googlegroups.com'
|
|
|
|
_COMMON_GMOCK_SYMBOLS = [
|
|
# Matchers
|
|
'_',
|
|
'A',
|
|
'AddressSatisfies',
|
|
'AllOf',
|
|
'An',
|
|
'AnyOf',
|
|
'ContainerEq',
|
|
'Contains',
|
|
'ContainsRegex',
|
|
'DoubleEq',
|
|
'ElementsAre',
|
|
'ElementsAreArray',
|
|
'EndsWith',
|
|
'Eq',
|
|
'Field',
|
|
'FloatEq',
|
|
'Ge',
|
|
'Gt',
|
|
'HasSubstr',
|
|
'IsInitializedProto',
|
|
'Le',
|
|
'Lt',
|
|
'MatcherCast',
|
|
'Matches',
|
|
'MatchesRegex',
|
|
'NanSensitiveDoubleEq',
|
|
'NanSensitiveFloatEq',
|
|
'Ne',
|
|
'Not',
|
|
'NotNull',
|
|
'Pointee',
|
|
'Property',
|
|
'Ref',
|
|
'ResultOf',
|
|
'SafeMatcherCast',
|
|
'StartsWith',
|
|
'StrCaseEq',
|
|
'StrCaseNe',
|
|
'StrEq',
|
|
'StrNe',
|
|
'Truly',
|
|
'TypedEq',
|
|
'Value',
|
|
|
|
# Actions
|
|
'Assign',
|
|
'ByRef',
|
|
'DeleteArg',
|
|
'DoAll',
|
|
'DoDefault',
|
|
'IgnoreResult',
|
|
'Invoke',
|
|
'InvokeArgument',
|
|
'InvokeWithoutArgs',
|
|
'Return',
|
|
'ReturnNew',
|
|
'ReturnNull',
|
|
'ReturnRef',
|
|
'SaveArg',
|
|
'SetArgReferee',
|
|
'SetArgPointee',
|
|
'SetArgumentPointee',
|
|
'SetArrayArgument',
|
|
'SetErrnoAndReturn',
|
|
'Throw',
|
|
'WithArg',
|
|
'WithArgs',
|
|
'WithoutArgs',
|
|
|
|
# Cardinalities
|
|
'AnyNumber',
|
|
'AtLeast',
|
|
'AtMost',
|
|
'Between',
|
|
'Exactly',
|
|
|
|
# Sequences
|
|
'InSequence',
|
|
'Sequence',
|
|
|
|
# Misc
|
|
'DefaultValue',
|
|
'Mock',
|
|
]
|
|
|
|
# Regex for matching source file path and line number in the compiler's errors.
|
|
_GCC_FILE_LINE_RE = r'(?P<file>.*):(?P<line>\d+):(\d+:)?\s+'
|
|
_CLANG_FILE_LINE_RE = r'(?P<file>.*):(?P<line>\d+):(?P<column>\d+):\s+'
|
|
_CLANG_NON_GMOCK_FILE_LINE_RE = (
|
|
r'(?P<file>.*[/\\^](?!gmock-)[^/\\]+):(?P<line>\d+):(?P<column>\d+):\s+')
|
|
|
|
|
|
def _FindAllMatches(regex, s):
|
|
"""Generates all matches of regex in string s."""
|
|
|
|
r = re.compile(regex)
|
|
return r.finditer(s)
|
|
|
|
|
|
def _GenericDiagnoser(short_name, long_name, diagnoses, msg):
|
|
"""Diagnoses the given disease by pattern matching.
|
|
|
|
Can provide different diagnoses for different patterns.
|
|
|
|
Args:
|
|
short_name: Short name of the disease.
|
|
long_name: Long name of the disease.
|
|
diagnoses: A list of pairs (regex, pattern for formatting the diagnosis
|
|
for matching regex).
|
|
msg: Compiler's error messages.
|
|
Yields:
|
|
Tuples of the form
|
|
(short name of disease, long name of disease, diagnosis).
|
|
"""
|
|
for regex, diagnosis in diagnoses:
|
|
if re.search(regex, msg):
|
|
diagnosis = '%(file)s:%(line)s:' + diagnosis
|
|
for m in _FindAllMatches(regex, msg):
|
|
yield (short_name, long_name, diagnosis % m.groupdict())
|
|
|
|
|
|
def _NeedToReturnReferenceDiagnoser(msg):
|
|
"""Diagnoses the NRR disease, given the error messages by the compiler."""
|
|
|
|
gcc_regex = (r'In member function \'testing::internal::ReturnAction<R>.*\n'
|
|
+ _GCC_FILE_LINE_RE + r'instantiated from here\n'
|
|
r'.*gmock-actions\.h.*error: creating array with negative size')
|
|
clang_regex = (r'error:.*array.*negative.*\r?\n'
|
|
r'(.*\n)*?' +
|
|
_CLANG_NON_GMOCK_FILE_LINE_RE +
|
|
r'note: in instantiation of function template specialization '
|
|
r'\'testing::internal::ReturnAction<(?P<type>.*)>'
|
|
r'::operator Action<.*>\' requested here')
|
|
clang11_re = (r'use_ReturnRef_instead_of_Return_to_return_a_reference.*'
|
|
r'(.*\n)*?' + _CLANG_NON_GMOCK_FILE_LINE_RE)
|
|
|
|
diagnosis = """
|
|
You are using a Return() action in a function that returns a reference to
|
|
%(type)s. Please use ReturnRef() instead."""
|
|
return _GenericDiagnoser('NRR', 'Need to Return Reference',
|
|
[(clang_regex, diagnosis),
|
|
(clang11_re, diagnosis % {'type': 'a type'}),
|
|
(gcc_regex, diagnosis % {'type': 'a type'})],
|
|
msg)
|
|
|
|
|
|
def _NeedToReturnSomethingDiagnoser(msg):
|
|
"""Diagnoses the NRS disease, given the error messages by the compiler."""
|
|
|
|
gcc_regex = (_GCC_FILE_LINE_RE + r'(instantiated from here\n.'
|
|
r'*gmock.*actions\.h.*error: void value not ignored)'
|
|
r'|(error: control reaches end of non-void function)')
|
|
clang_regex1 = (_CLANG_FILE_LINE_RE +
|
|
r'error: cannot initialize return object '
|
|
r'of type \'Result\' \(aka \'(?P<return_type>.*)\'\) '
|
|
r'with an rvalue of type \'void\'')
|
|
clang_regex2 = (_CLANG_FILE_LINE_RE +
|
|
r'error: cannot initialize return object '
|
|
r'of type \'(?P<return_type>.*)\' '
|
|
r'with an rvalue of type \'void\'')
|
|
diagnosis = """
|
|
You are using an action that returns void, but it needs to return
|
|
%(return_type)s. Please tell it *what* to return. Perhaps you can use
|
|
the pattern DoAll(some_action, Return(some_value))?"""
|
|
return _GenericDiagnoser(
|
|
'NRS',
|
|
'Need to Return Something',
|
|
[(gcc_regex, diagnosis % {'return_type': '*something*'}),
|
|
(clang_regex1, diagnosis),
|
|
(clang_regex2, diagnosis)],
|
|
msg)
|
|
|
|
|
|
def _NeedToReturnNothingDiagnoser(msg):
|
|
"""Diagnoses the NRN disease, given the error messages by the compiler."""
|
|
|
|
gcc_regex = (_GCC_FILE_LINE_RE + r'instantiated from here\n'
|
|
r'.*gmock-actions\.h.*error: instantiation of '
|
|
r'\'testing::internal::ReturnAction<R>::Impl<F>::value_\' '
|
|
r'as type \'void\'')
|
|
clang_regex1 = (r'error: field has incomplete type '
|
|
r'\'Result\' \(aka \'void\'\)(\r)?\n'
|
|
r'(.*\n)*?' +
|
|
_CLANG_NON_GMOCK_FILE_LINE_RE + r'note: in instantiation '
|
|
r'of function template specialization '
|
|
r'\'testing::internal::ReturnAction<(?P<return_type>.*)>'
|
|
r'::operator Action<void \(.*\)>\' requested here')
|
|
clang_regex2 = (r'error: field has incomplete type '
|
|
r'\'Result\' \(aka \'void\'\)(\r)?\n'
|
|
r'(.*\n)*?' +
|
|
_CLANG_NON_GMOCK_FILE_LINE_RE + r'note: in instantiation '
|
|
r'of function template specialization '
|
|
r'\'testing::internal::DoBothAction<.*>'
|
|
r'::operator Action<(?P<return_type>.*) \(.*\)>\' '
|
|
r'requested here')
|
|
diagnosis = """
|
|
You are using an action that returns %(return_type)s, but it needs to return
|
|
void. Please use a void-returning action instead.
|
|
|
|
All actions but the last in DoAll(...) must return void. Perhaps you need
|
|
to re-arrange the order of actions in a DoAll(), if you are using one?"""
|
|
return _GenericDiagnoser(
|
|
'NRN',
|
|
'Need to Return Nothing',
|
|
[(gcc_regex, diagnosis % {'return_type': '*something*'}),
|
|
(clang_regex1, diagnosis),
|
|
(clang_regex2, diagnosis)],
|
|
msg)
|
|
|
|
|
|
def _IncompleteByReferenceArgumentDiagnoser(msg):
|
|
"""Diagnoses the IBRA disease, given the error messages by the compiler."""
|
|
|
|
gcc_regex = (_GCC_FILE_LINE_RE + r'instantiated from here\n'
|
|
r'.*gtest-printers\.h.*error: invalid application of '
|
|
r'\'sizeof\' to incomplete type \'(?P<type>.*)\'')
|
|
|
|
clang_regex = (r'.*gtest-printers\.h.*error: invalid application of '
|
|
r'\'sizeof\' to an incomplete type '
|
|
r'\'(?P<type>.*)( const)?\'\r?\n'
|
|
r'(.*\n)*?' +
|
|
_CLANG_NON_GMOCK_FILE_LINE_RE +
|
|
r'note: in instantiation of member function '
|
|
r'\'testing::internal2::TypeWithoutFormatter<.*>::'
|
|
r'PrintValue\' requested here')
|
|
diagnosis = """
|
|
In order to mock this function, Google Mock needs to see the definition
|
|
of type "%(type)s" - declaration alone is not enough. Either #include
|
|
the header that defines it, or change the argument to be passed
|
|
by pointer."""
|
|
|
|
return _GenericDiagnoser('IBRA', 'Incomplete By-Reference Argument Type',
|
|
[(gcc_regex, diagnosis),
|
|
(clang_regex, diagnosis)],
|
|
msg)
|
|
|
|
|
|
def _OverloadedFunctionMatcherDiagnoser(msg):
|
|
"""Diagnoses the OFM disease, given the error messages by the compiler."""
|
|
|
|
gcc_regex = (_GCC_FILE_LINE_RE + r'error: no matching function for '
|
|
r'call to \'Truly\(<unresolved overloaded function type>\)')
|
|
clang_regex = (_CLANG_FILE_LINE_RE + r'error: no matching function for '
|
|
r'call to \'Truly')
|
|
diagnosis = """
|
|
The argument you gave to Truly() is an overloaded function. Please tell
|
|
your compiler which overloaded version you want to use.
|
|
|
|
For example, if you want to use the version whose signature is
|
|
bool Foo(int n);
|
|
you should write
|
|
Truly(static_cast<bool (*)(int n)>(Foo))"""
|
|
return _GenericDiagnoser('OFM', 'Overloaded Function Matcher',
|
|
[(gcc_regex, diagnosis),
|
|
(clang_regex, diagnosis)],
|
|
msg)
|
|
|
|
|
|
def _OverloadedFunctionActionDiagnoser(msg):
|
|
"""Diagnoses the OFA disease, given the error messages by the compiler."""
|
|
|
|
gcc_regex = (_GCC_FILE_LINE_RE + r'error: no matching function for call to '
|
|
r'\'Invoke\(<unresolved overloaded function type>')
|
|
clang_regex = (_CLANG_FILE_LINE_RE + r'error: no matching '
|
|
r'function for call to \'Invoke\'\r?\n'
|
|
r'(.*\n)*?'
|
|
r'.*\bgmock-generated-actions\.h:\d+:\d+:\s+'
|
|
r'note: candidate template ignored:\s+'
|
|
r'couldn\'t infer template argument \'FunctionImpl\'')
|
|
diagnosis = """
|
|
Function you are passing to Invoke is overloaded. Please tell your compiler
|
|
which overloaded version you want to use.
|
|
|
|
For example, if you want to use the version whose signature is
|
|
bool MyFunction(int n, double x);
|
|
you should write something like
|
|
Invoke(static_cast<bool (*)(int n, double x)>(MyFunction))"""
|
|
return _GenericDiagnoser('OFA', 'Overloaded Function Action',
|
|
[(gcc_regex, diagnosis),
|
|
(clang_regex, diagnosis)],
|
|
msg)
|
|
|
|
|
|
def _OverloadedMethodActionDiagnoser(msg):
|
|
"""Diagnoses the OMA disease, given the error messages by the compiler."""
|
|
|
|
gcc_regex = (_GCC_FILE_LINE_RE + r'error: no matching function for '
|
|
r'call to \'Invoke\(.+, <unresolved overloaded function '
|
|
r'type>\)')
|
|
clang_regex = (_CLANG_FILE_LINE_RE + r'error: no matching function '
|
|
r'for call to \'Invoke\'\r?\n'
|
|
r'(.*\n)*?'
|
|
r'.*\bgmock-generated-actions\.h:\d+:\d+: '
|
|
r'note: candidate function template not viable: '
|
|
r'requires .*, but 2 (arguments )?were provided')
|
|
diagnosis = """
|
|
The second argument you gave to Invoke() is an overloaded method. Please
|
|
tell your compiler which overloaded version you want to use.
|
|
|
|
For example, if you want to use the version whose signature is
|
|
class Foo {
|
|
...
|
|
bool Bar(int n, double x);
|
|
};
|
|
you should write something like
|
|
Invoke(foo, static_cast<bool (Foo::*)(int n, double x)>(&Foo::Bar))"""
|
|
return _GenericDiagnoser('OMA', 'Overloaded Method Action',
|
|
[(gcc_regex, diagnosis),
|
|
(clang_regex, diagnosis)],
|
|
msg)
|
|
|
|
|
|
def _MockObjectPointerDiagnoser(msg):
|
|
"""Diagnoses the MOP disease, given the error messages by the compiler."""
|
|
|
|
gcc_regex = (_GCC_FILE_LINE_RE + r'error: request for member '
|
|
r'\'gmock_(?P<method>.+)\' in \'(?P<mock_object>.+)\', '
|
|
r'which is of non-class type \'(.*::)*(?P<class_name>.+)\*\'')
|
|
clang_regex = (_CLANG_FILE_LINE_RE + r'error: member reference type '
|
|
r'\'(?P<class_name>.*?) *\' is a pointer; '
|
|
r'(did you mean|maybe you meant) to use \'->\'\?')
|
|
diagnosis = """
|
|
The first argument to ON_CALL() and EXPECT_CALL() must be a mock *object*,
|
|
not a *pointer* to it. Please write '*(%(mock_object)s)' instead of
|
|
'%(mock_object)s' as your first argument.
|
|
|
|
For example, given the mock class:
|
|
|
|
class %(class_name)s : public ... {
|
|
...
|
|
MOCK_METHOD0(%(method)s, ...);
|
|
};
|
|
|
|
and the following mock instance:
|
|
|
|
%(class_name)s* mock_ptr = ...
|
|
|
|
you should use the EXPECT_CALL like this:
|
|
|
|
EXPECT_CALL(*mock_ptr, %(method)s(...));"""
|
|
|
|
return _GenericDiagnoser(
|
|
'MOP',
|
|
'Mock Object Pointer',
|
|
[(gcc_regex, diagnosis),
|
|
(clang_regex, diagnosis % {'mock_object': 'mock_object',
|
|
'method': 'method',
|
|
'class_name': '%(class_name)s'})],
|
|
msg)
|
|
|
|
|
|
def _NeedToUseSymbolDiagnoser(msg):
|
|
"""Diagnoses the NUS disease, given the error messages by the compiler."""
|
|
|
|
gcc_regex = (_GCC_FILE_LINE_RE + r'error: \'(?P<symbol>.+)\' '
|
|
r'(was not declared in this scope|has not been declared)')
|
|
clang_regex = (_CLANG_FILE_LINE_RE +
|
|
r'error: (use of undeclared identifier|unknown type name|'
|
|
r'no template named) \'(?P<symbol>[^\']+)\'')
|
|
diagnosis = """
|
|
'%(symbol)s' is defined by Google Mock in the testing namespace.
|
|
Did you forget to write
|
|
using testing::%(symbol)s;
|
|
?"""
|
|
for m in (list(_FindAllMatches(gcc_regex, msg)) +
|
|
list(_FindAllMatches(clang_regex, msg))):
|
|
symbol = m.groupdict()['symbol']
|
|
if symbol in _COMMON_GMOCK_SYMBOLS:
|
|
yield ('NUS', 'Need to Use Symbol', diagnosis % m.groupdict())
|
|
|
|
|
|
def _NeedToUseReturnNullDiagnoser(msg):
|
|
"""Diagnoses the NRNULL disease, given the error messages by the compiler."""
|
|
|
|
gcc_regex = ('instantiated from \'testing::internal::ReturnAction<R>'
|
|
'::operator testing::Action<Func>\(\) const.*\n' +
|
|
_GCC_FILE_LINE_RE + r'instantiated from here\n'
|
|
r'.*error: no matching function for call to \'ImplicitCast_\('
|
|
r'(:?long )?int&\)')
|
|
clang_regex = (r'\bgmock-actions.h:.* error: no matching function for '
|
|
r'call to \'ImplicitCast_\'\r?\n'
|
|
r'(.*\n)*?' +
|
|
_CLANG_NON_GMOCK_FILE_LINE_RE + r'note: in instantiation '
|
|
r'of function template specialization '
|
|
r'\'testing::internal::ReturnAction<(int|long)>::operator '
|
|
r'Action<(?P<type>.*)\(\)>\' requested here')
|
|
diagnosis = """
|
|
You are probably calling Return(NULL) and the compiler isn't sure how to turn
|
|
NULL into %(type)s. Use ReturnNull() instead.
|
|
Note: the line number may be off; please fix all instances of Return(NULL)."""
|
|
return _GenericDiagnoser(
|
|
'NRNULL', 'Need to use ReturnNull',
|
|
[(clang_regex, diagnosis),
|
|
(gcc_regex, diagnosis % {'type': 'the right type'})],
|
|
msg)
|
|
|
|
|
|
def _TypeInTemplatedBaseDiagnoser(msg):
|
|
"""Diagnoses the TTB disease, given the error messages by the compiler."""
|
|
|
|
# This version works when the type is used as the mock function's return
|
|
# type.
|
|
gcc_4_3_1_regex_type_in_retval = (
|
|
r'In member function \'int .*\n' + _GCC_FILE_LINE_RE +
|
|
r'error: a function call cannot appear in a constant-expression')
|
|
gcc_4_4_0_regex_type_in_retval = (
|
|
r'error: a function call cannot appear in a constant-expression'
|
|
+ _GCC_FILE_LINE_RE + r'error: template argument 1 is invalid\n')
|
|
# This version works when the type is used as the mock function's sole
|
|
# parameter type.
|
|
gcc_regex_type_of_sole_param = (
|
|
_GCC_FILE_LINE_RE +
|
|
r'error: \'(?P<type>.+)\' was not declared in this scope\n'
|
|
r'.*error: template argument 1 is invalid\n')
|
|
# This version works when the type is used as a parameter of a mock
|
|
# function that has multiple parameters.
|
|
gcc_regex_type_of_a_param = (
|
|
r'error: expected `;\' before \'::\' token\n'
|
|
+ _GCC_FILE_LINE_RE +
|
|
r'error: \'(?P<type>.+)\' was not declared in this scope\n'
|
|
r'.*error: template argument 1 is invalid\n'
|
|
r'.*error: \'.+\' was not declared in this scope')
|
|
clang_regex_type_of_retval_or_sole_param = (
|
|
_CLANG_FILE_LINE_RE +
|
|
r'error: use of undeclared identifier \'(?P<type>.*)\'\n'
|
|
r'(.*\n)*?'
|
|
r'(?P=file):(?P=line):\d+: error: '
|
|
r'non-friend class member \'Result\' cannot have a qualified name'
|
|
)
|
|
clang_regex_type_of_a_param = (
|
|
_CLANG_FILE_LINE_RE +
|
|
r'error: C\+\+ requires a type specifier for all declarations\n'
|
|
r'(.*\n)*?'
|
|
r'(?P=file):(?P=line):(?P=column): error: '
|
|
r'C\+\+ requires a type specifier for all declarations'
|
|
)
|
|
clang_regex_unknown_type = (
|
|
_CLANG_FILE_LINE_RE +
|
|
r'error: unknown type name \'(?P<type>[^\']+)\''
|
|
)
|
|
|
|
diagnosis = """
|
|
In a mock class template, types or typedefs defined in the base class
|
|
template are *not* automatically visible. This is how C++ works. Before
|
|
you can use a type or typedef named %(type)s defined in base class Base<T>, you
|
|
need to make it visible. One way to do it is:
|
|
|
|
typedef typename Base<T>::%(type)s %(type)s;"""
|
|
|
|
for diag in _GenericDiagnoser(
|
|
'TTB', 'Type in Template Base',
|
|
[(gcc_4_3_1_regex_type_in_retval, diagnosis % {'type': 'Foo'}),
|
|
(gcc_4_4_0_regex_type_in_retval, diagnosis % {'type': 'Foo'}),
|
|
(gcc_regex_type_of_sole_param, diagnosis),
|
|
(gcc_regex_type_of_a_param, diagnosis),
|
|
(clang_regex_type_of_retval_or_sole_param, diagnosis),
|
|
(clang_regex_type_of_a_param, diagnosis % {'type': 'Foo'})],
|
|
msg):
|
|
yield diag
|
|
# Avoid overlap with the NUS pattern.
|
|
for m in _FindAllMatches(clang_regex_unknown_type, msg):
|
|
type_ = m.groupdict()['type']
|
|
if type_ not in _COMMON_GMOCK_SYMBOLS:
|
|
yield ('TTB', 'Type in Template Base', diagnosis % m.groupdict())
|
|
|
|
|
|
def _WrongMockMethodMacroDiagnoser(msg):
|
|
"""Diagnoses the WMM disease, given the error messages by the compiler."""
|
|
|
|
gcc_regex = (_GCC_FILE_LINE_RE +
|
|
r'.*this_method_does_not_take_(?P<wrong_args>\d+)_argument.*\n'
|
|
r'.*\n'
|
|
r'.*candidates are.*FunctionMocker<[^>]+A(?P<args>\d+)\)>')
|
|
clang_regex = (_CLANG_NON_GMOCK_FILE_LINE_RE +
|
|
r'error:.*array.*negative.*r?\n'
|
|
r'(.*\n)*?'
|
|
r'(?P=file):(?P=line):(?P=column): error: too few arguments '
|
|
r'to function call, expected (?P<args>\d+), '
|
|
r'have (?P<wrong_args>\d+)')
|
|
clang11_re = (_CLANG_NON_GMOCK_FILE_LINE_RE +
|
|
r'.*this_method_does_not_take_'
|
|
r'(?P<wrong_args>\d+)_argument.*')
|
|
diagnosis = """
|
|
You are using MOCK_METHOD%(wrong_args)s to define a mock method that has
|
|
%(args)s arguments. Use MOCK_METHOD%(args)s (or MOCK_CONST_METHOD%(args)s,
|
|
MOCK_METHOD%(args)s_T, MOCK_CONST_METHOD%(args)s_T as appropriate) instead."""
|
|
return _GenericDiagnoser('WMM', 'Wrong MOCK_METHODn Macro',
|
|
[(gcc_regex, diagnosis),
|
|
(clang11_re, diagnosis % {'wrong_args': 'm',
|
|
'args': 'n'}),
|
|
(clang_regex, diagnosis)],
|
|
msg)
|
|
|
|
|
|
def _WrongParenPositionDiagnoser(msg):
|
|
"""Diagnoses the WPP disease, given the error messages by the compiler."""
|
|
|
|
gcc_regex = (_GCC_FILE_LINE_RE +
|
|
r'error:.*testing::internal::MockSpec<.* has no member named \''
|
|
r'(?P<method>\w+)\'')
|
|
clang_regex = (_CLANG_NON_GMOCK_FILE_LINE_RE +
|
|
r'error: no member named \'(?P<method>\w+)\' in '
|
|
r'\'testing::internal::MockSpec<.*>\'')
|
|
diagnosis = """
|
|
The closing parenthesis of ON_CALL or EXPECT_CALL should be *before*
|
|
".%(method)s". For example, you should write:
|
|
EXPECT_CALL(my_mock, Foo(_)).%(method)s(...);
|
|
instead of:
|
|
EXPECT_CALL(my_mock, Foo(_).%(method)s(...));"""
|
|
return _GenericDiagnoser('WPP', 'Wrong Parenthesis Position',
|
|
[(gcc_regex, diagnosis),
|
|
(clang_regex, diagnosis)],
|
|
msg)
|
|
|
|
|
|
_DIAGNOSERS = [
|
|
_IncompleteByReferenceArgumentDiagnoser,
|
|
_MockObjectPointerDiagnoser,
|
|
_NeedToReturnNothingDiagnoser,
|
|
_NeedToReturnReferenceDiagnoser,
|
|
_NeedToReturnSomethingDiagnoser,
|
|
_NeedToUseReturnNullDiagnoser,
|
|
_NeedToUseSymbolDiagnoser,
|
|
_OverloadedFunctionActionDiagnoser,
|
|
_OverloadedFunctionMatcherDiagnoser,
|
|
_OverloadedMethodActionDiagnoser,
|
|
_TypeInTemplatedBaseDiagnoser,
|
|
_WrongMockMethodMacroDiagnoser,
|
|
_WrongParenPositionDiagnoser,
|
|
]
|
|
|
|
|
|
def Diagnose(msg):
|
|
"""Generates all possible diagnoses given the compiler error message."""
|
|
|
|
msg = re.sub(r'\x1b\[[^m]*m', '', msg) # Strips all color formatting.
|
|
# Assuming the string is using the UTF-8 encoding, replaces the left and
|
|
# the right single quote characters with apostrophes.
|
|
msg = re.sub(r'(\xe2\x80\x98|\xe2\x80\x99)', "'", msg)
|
|
|
|
diagnoses = []
|
|
for diagnoser in _DIAGNOSERS:
|
|
for diag in diagnoser(msg):
|
|
diagnosis = '[%s - %s]\n%s' % diag
|
|
if not diagnosis in diagnoses:
|
|
diagnoses.append(diagnosis)
|
|
return diagnoses
|
|
|
|
|
|
def main():
|
|
print ('Google Mock Doctor v%s - '
|
|
'diagnoses problems in code using Google Mock.' % _VERSION)
|
|
|
|
if sys.stdin.isatty():
|
|
print ('Please copy and paste the compiler errors here. Press c-D when '
|
|
'you are done:')
|
|
else:
|
|
print ('Waiting for compiler errors on stdin . . .')
|
|
|
|
msg = sys.stdin.read().strip()
|
|
diagnoses = Diagnose(msg)
|
|
count = len(diagnoses)
|
|
if not count:
|
|
print ("""
|
|
Your compiler complained:
|
|
8<------------------------------------------------------------
|
|
%s
|
|
------------------------------------------------------------>8
|
|
|
|
Uh-oh, I'm not smart enough to figure out what the problem is. :-(
|
|
However...
|
|
If you send your source code and the compiler's error messages to
|
|
%s, you can be helped and I can get smarter --
|
|
win-win for us!""" % (msg, _EMAIL))
|
|
else:
|
|
print ('------------------------------------------------------------')
|
|
print ('Your code appears to have the following',)
|
|
if count > 1:
|
|
print ('%s diseases:' % (count,))
|
|
else:
|
|
print ('disease:')
|
|
i = 0
|
|
for d in diagnoses:
|
|
i += 1
|
|
if count > 1:
|
|
print ('\n#%s:' % (i,))
|
|
print (d)
|
|
print ("""
|
|
How did I do? If you think I'm wrong or unhelpful, please send your
|
|
source code and the compiler's error messages to %s.
|
|
Then you can be helped and I can get smarter -- I promise I won't be upset!""" %
|
|
_EMAIL)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|