gmock_doctor.py 21.7 KB
Newer Older
1
#!/usr/bin/env python
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#
# 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.

32
"""Converts compiler's errors in code using Google Mock to plain English."""
33
34
35
36
37
38

__author__ = 'wan@google.com (Zhanyong Wan)'

import re
import sys

39
_VERSION = '1.0.3'
40
41
42
43
44
45
46
47
48

_COMMON_GMOCK_SYMBOLS = [
    # Matchers
    '_',
    'A',
    'AddressSatisfies',
    'AllOf',
    'An',
    'AnyOf',
49
50
    'ContainerEq',
    'Contains',
51
52
    'ContainsRegex',
    'DoubleEq',
53
54
    'ElementsAre',
    'ElementsAreArray',
55
56
57
58
59
60
61
    'EndsWith',
    'Eq',
    'Field',
    'FloatEq',
    'Ge',
    'Gt',
    'HasSubstr',
62
    'IsInitializedProto',
63
64
65
    'Le',
    'Lt',
    'MatcherCast',
66
    'Matches',
67
    'MatchesRegex',
68
69
    'NanSensitiveDoubleEq',
    'NanSensitiveFloatEq',
70
71
72
73
74
75
    'Ne',
    'Not',
    'NotNull',
    'Pointee',
    'Property',
    'Ref',
76
77
    'ResultOf',
    'SafeMatcherCast',
78
79
80
81
82
83
84
    'StartsWith',
    'StrCaseEq',
    'StrCaseNe',
    'StrEq',
    'StrNe',
    'Truly',
    'TypedEq',
85
    'Value',
86
87

    # Actions
88
    'Assign',
89
    'ByRef',
90
    'DeleteArg',
91
92
93
94
95
96
97
    'DoAll',
    'DoDefault',
    'IgnoreResult',
    'Invoke',
    'InvokeArgument',
    'InvokeWithoutArgs',
    'Return',
98
    'ReturnNew',
99
100
    'ReturnNull',
    'ReturnRef',
101
102
    'SaveArg',
    'SetArgReferee',
103
104
    'SetArgumentPointee',
    'SetArrayArgument',
105
106
107
    'SetErrnoAndReturn',
    'Throw',
    'WithArg',
108
    'WithArgs',
109
    'WithoutArgs',
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

    # Cardinalities
    'AnyNumber',
    'AtLeast',
    'AtMost',
    'Between',
    'Exactly',

    # Sequences
    'InSequence',
    'Sequence',

    # Misc
    'DefaultValue',
    'Mock',
    ]

127
128
129
130
131
# Regex for matching source file path and line number in the compiler's errors.
_GCC_FILE_LINE_RE = r'(?P<file>.*):(?P<line>\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+')
132

133
134
135
136
137
138
139
140

def _FindAllMatches(regex, s):
  """Generates all matches of regex in string s."""

  r = re.compile(regex)
  return r.finditer(s)


141
def _GenericDiagnoser(short_name, long_name, diagnoses, msg):
142
143
  """Diagnoses the given disease by pattern matching.

144
145
  Can provide different diagnoses for different patterns.

146
147
148
  Args:
    short_name: Short name of the disease.
    long_name:  Long name of the disease.
149
150
151
    diagnoses:  A list of pairs (regex, pattern for formatting the diagnosis
                for matching regex).
    msg:        Compiler's error messages.
152
153
154
155
  Yields:
    Tuples of the form
      (short name of disease, long name of disease, diagnosis).
  """
156
157
158
159
160
  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())
161
162
163


def _NeedToReturnReferenceDiagnoser(msg):
164
165
166
167
168
169
170
171
172
173
174
  """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 size is 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')
175
  diagnosis = """
176
177
You are using a Return() action in a function that returns a reference to
%(type)s.  Please use ReturnRef() instead."""
178
  return _GenericDiagnoser('NRR', 'Need to Return Reference',
179
180
181
                           [(clang_regex, diagnosis),
                            (gcc_regex, diagnosis % {'type': 'a type'})],
                           msg)
182
183
184


def _NeedToReturnSomethingDiagnoser(msg):
185
186
187
188
189
190
191
192
193
194
195
196
197
  """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\'')
198
  diagnosis = """
199
You are using an action that returns void, but it needs to return
200
%(return_type)s.  Please tell it *what* to return.  Perhaps you can use
201
the pattern DoAll(some_action, Return(some_value))?"""
202
203
204
205
206
207
208
  return _GenericDiagnoser(
      'NRS',
      'Need to Return Something',
      [(gcc_regex, diagnosis % {'return_type': '*something*'}),
       (clang_regex1, diagnosis),
       (clang_regex2, diagnosis)],
      msg)
209
210
211


def _NeedToReturnNothingDiagnoser(msg):
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
  """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')
233
  diagnosis = """
234
You are using an action that returns %(return_type)s, but it needs to return
235
236
237
238
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?"""
239
240
241
242
243
244
245
  return _GenericDiagnoser(
      'NRN',
      'Need to Return Nothing',
      [(gcc_regex, diagnosis % {'return_type': '*something*'}),
       (clang_regex1, diagnosis),
       (clang_regex2, diagnosis)],
      msg)
246
247
248


def _IncompleteByReferenceArgumentDiagnoser(msg):
249
250
251
252
253
254
255
256
257
258
259
260
261
262
  """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::internal::FunctionMocker<.*>::Invoke\' '
                 r'requested here')
263
  diagnosis = """
264
265
266
267
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."""
268

269
  return _GenericDiagnoser('IBRA', 'Incomplete By-Reference Argument Type',
270
271
272
                           [(gcc_regex, diagnosis),
                            (clang_regex, diagnosis)],
                           msg)
273
274
275


def _OverloadedFunctionMatcherDiagnoser(msg):
276
  """Diagnoses the OFM disease, given the error messages by the compiler."""
277

278
279
280
281
  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')
282
  diagnosis = """
283
The argument you gave to Truly() is an overloaded function.  Please tell
284
your compiler which overloaded version you want to use.
285
286
287
288
289
290

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',
291
292
293
                           [(gcc_regex, diagnosis),
                            (clang_regex, diagnosis)],
                           msg)
294
295
296


def _OverloadedFunctionActionDiagnoser(msg):
297
298
299
300
301
302
303
304
305
306
  """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-\w+-actions\.h:\d+:\d+:\s+'
                 r'note: candidate template ignored:\s+'
                 r'couldn\'t infer template argument \'FunctionImpl\'')
307
  diagnosis = """
308
Function you are passing to Invoke is overloaded.  Please tell your compiler
309
310
311
312
313
314
315
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',
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
                           [(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-\w+-actions\.h:\d+:\d+: '
                 r'note: candidate function template not viable: '
                 r'requires 1 argument, but 2 were provided')
333
  diagnosis = """
334
The second argument you gave to Invoke() is an overloaded method.  Please
335
tell your compiler which overloaded version you want to use.
336
337
338
339
340
341
342
343
344

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',
345
346
347
                           [(gcc_regex, diagnosis),
                            (clang_regex, diagnosis)],
                           msg)
348
349
350


def _MockObjectPointerDiagnoser(msg):
351
352
353
354
355
356
357
358
  """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'maybe you meant to use \'->\'\?')
359
  diagnosis = """
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
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(...));"""

379
380
381
382
383
384
385
386
  return _GenericDiagnoser(
      'MOP',
      'Mock Object Pointer',
      [(gcc_regex, diagnosis),
       (clang_regex, diagnosis % {'mock_object': 'mock_object',
                                  'method': 'method',
                                  'class_name': '%(class_name)s'})],
       msg)
387
388
389


def _NeedToUseSymbolDiagnoser(msg):
390
  """Diagnoses the NUS disease, given the error messages by the compiler."""
391

392
393
394
395
  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 '
                 r'\'(?P<symbol>.+)\'')
396
  diagnosis = """
397
398
399
400
'%(symbol)s' is defined by Google Mock in the testing namespace.
Did you forget to write
  using testing::%(symbol)s;
?"""
401
402
  for m in (list(_FindAllMatches(gcc_regex, msg)) +
            list(_FindAllMatches(clang_regex, msg))):
403
404
405
406
407
    symbol = m.groupdict()['symbol']
    if symbol in _COMMON_GMOCK_SYMBOLS:
      yield ('NUS', 'Need to Use Symbol', diagnosis % m.groupdict())


408
def _NeedToUseReturnNullDiagnoser(msg):
409
410
411
412
413
414
415
416
417
418
419
420
421
422
  """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 \'implicit_cast\('
               r'long int&\)')
  clang_regex = (r'\bgmock-actions.h:.* error: no matching function for '
                 r'call to \'implicit_cast\'\r?\n'
                 r'(.*\n)*?' +
                 _CLANG_NON_GMOCK_FILE_LINE_RE + r'note: in instantiation '
                 r'of function template specialization '
                 r'\'testing::internal::ReturnAction<long>::operator '
                 r'Action<(?P<type>.*)\(\)>\' requested here')
423
  diagnosis = """
424
You are probably calling Return(NULL) and the compiler isn't sure how to turn
425
NULL into %(type)s. Use ReturnNull() instead.
426
Note: the line number may be off; please fix all instances of Return(NULL)."""
427
428
429
430
431
432
  return _GenericDiagnoser(
      'NRNULL', 'Need to use ReturnNull',
      [(clang_regex, diagnosis),
       (gcc_regex, diagnosis % {'type': 'the right type'})],
      msg)

433

434
435
def _TypeInTemplatedBaseDiagnoser(msg):
  """Diagnoses the TTB disease, given the error messages by the compiler."""
436

437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
  # 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')

  diagnosis = """
461
462
463
464
465
466
467
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;"""

468
469
470
471
472
473
474
  return _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)],
      msg)
475
476


477
def _WrongMockMethodMacroDiagnoser(msg):
478
479
480
481
482
483
484
485
486
487
488
489
  """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 size is 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+)')
490
  diagnosis = """
491
492
493
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."""
494
  return _GenericDiagnoser('WMM', 'Wrong MOCK_METHODn Macro',
495
496
497
                           [(gcc_regex, diagnosis),
                            (clang_regex, diagnosis)],
                           msg)
498
499


500
def _WrongParenPositionDiagnoser(msg):
501
502
503
504
505
506
507
508
  """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<.*>\'')
509
510
511
512
513
514
  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(...));"""
515
  return _GenericDiagnoser('WPP', 'Wrong Parenthesis Position',
516
517
518
                           [(gcc_regex, diagnosis),
                            (clang_regex, diagnosis)],
                           msg)
519

520

521
522
523
524
525
526
_DIAGNOSERS = [
    _IncompleteByReferenceArgumentDiagnoser,
    _MockObjectPointerDiagnoser,
    _NeedToReturnNothingDiagnoser,
    _NeedToReturnReferenceDiagnoser,
    _NeedToReturnSomethingDiagnoser,
527
    _NeedToUseReturnNullDiagnoser,
528
529
530
    _NeedToUseSymbolDiagnoser,
    _OverloadedFunctionActionDiagnoser,
    _OverloadedFunctionMatcherDiagnoser,
531
532
    _OverloadedMethodActionDiagnoser,
    _TypeInTemplatedBaseDiagnoser,
533
    _WrongMockMethodMacroDiagnoser,
534
    _WrongParenPositionDiagnoser,
535
536
537
538
    ]


def Diagnose(msg):
539
540
541
  """Generates all possible diagnoses given the compiler error message."""

  msg = re.sub(r'\x1b\[[^m]*m', '', msg)  # Strips all color formatting.
542

543
  diagnoses = []
544
  for diagnoser in _DIAGNOSERS:
545
546
547
548
549
    for diag in diagnoser(msg):
      diagnosis = '[%s - %s]\n%s' % diag
      if not diagnosis in diagnoses:
        diagnoses.append(diagnosis)
  return diagnoses
550
551
552
553
554
555
556
557
558
559
560
561
562


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()
563
  diagnoses = Diagnose(msg)
564
565
566
567
568
569
570
571
572
  count = len(diagnoses)
  if not count:
    print '\nGcc complained:'
    print '8<------------------------------------------------------------'
    print msg
    print '------------------------------------------------------------>8'
    print """
Uh-oh, I'm not smart enough to figure out what the problem is. :-(
However...
573
If you send your source code and the compiler's error messages to
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
googlemock@googlegroups.com, you can be helped and I can get smarter --
win-win for us!"""
  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
591
592
source code and compiler's error messages to googlemock@googlegroups.com.
Then you can be helped and I can get smarter -- I promise I won't be upset!"""
593
594
595
596


if __name__ == '__main__':
  main()