741 lines
24 KiB
Python
741 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()
|