URL https://opencores.org/ocsvn/s80186/s80186/trunk

Subversion Repositories s80186

[/] [s80186/] [trunk/] [vendor/] [googletest/] [googlemock/] [scripts/] [generator/] [cpp/] [gmock_class_test.py] - Blame information for rev 2

Details | Compare with Previous | View Log


#!/usr/bin/env python
#
# Copyright 2009 Neal Norwitz All Rights Reserved.
# Portions Copyright 2009 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.
 
"""Tests for gmock.scripts.generator.cpp.gmock_class."""
 
__author__ = 'nnorwitz@google.com (Neal Norwitz)'
 
 
import os
import sys
import unittest
 
# Allow the cpp imports below to work when run as a standalone script.
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
 
from cpp import ast
from cpp import gmock_class
 
 
class TestCase(unittest.TestCase):
  """Helper class that adds assert methods."""
 
  def StripLeadingWhitespace(self, lines):
    """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):
    """Specialized assert that ignores the indent level."""
    self.assertEqual(expected_lines, self.StripLeadingWhitespace(lines))
 
 
class GenerateMethodsTest(TestCase):
 
  def GenerateMethodSource(self, cpp_source):
    """Convert C++ source to Google Mock output source lines."""
    method_source_lines = []
    # <test> is a pseudo-filename, it is not read or written.
    builder = ast.BuilderFromSource(cpp_source, '<test>')
    ast_list = list(builder.Generate())
    gmock_class._GenerateMethods(method_source_lines, cpp_source, ast_list[0])
    return '\n'.join(method_source_lines)
 
  def testSimpleMethod(self):
    source = """
class Foo {
 public:
  virtual int Bar();
};
"""
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_METHOD0(Bar,\nint());',
        self.GenerateMethodSource(source))
 
  def testSimpleConstructorsAndDestructor(self):
    source = """
class Foo {
 public:
  Foo();
  Foo(int x);
  Foo(const Foo& f);
  Foo(Foo&& f);
  ~Foo();
  virtual int Bar() = 0;
};
"""
    # The constructors and destructor should be ignored.
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_METHOD0(Bar,\nint());',
        self.GenerateMethodSource(source))
 
  def testVirtualDestructor(self):
    source = """
class Foo {
 public:
  virtual ~Foo();
  virtual int Bar() = 0;
};
"""
    # The destructor should be ignored.
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_METHOD0(Bar,\nint());',
        self.GenerateMethodSource(source))
 
  def testExplicitlyDefaultedConstructorsAndDestructor(self):
    source = """
class Foo {
 public:
  Foo() = default;
  Foo(const Foo& f) = default;
  Foo(Foo&& f) = default;
  ~Foo() = default;
  virtual int Bar() = 0;
};
"""
    # The constructors and destructor should be ignored.
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_METHOD0(Bar,\nint());',
        self.GenerateMethodSource(source))
 
  def testExplicitlyDeletedConstructorsAndDestructor(self):
    source = """
class Foo {
 public:
  Foo() = delete;
  Foo(const Foo& f) = delete;
  Foo(Foo&& f) = delete;
  ~Foo() = delete;
  virtual int Bar() = 0;
};
"""
    # The constructors and destructor should be ignored.
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_METHOD0(Bar,\nint());',
        self.GenerateMethodSource(source))
 
  def testSimpleOverrideMethod(self):
    source = """
class Foo {
 public:
  int Bar() override;
};
"""
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_METHOD0(Bar,\nint());',
        self.GenerateMethodSource(source))
 
  def testSimpleConstMethod(self):
    source = """
class Foo {
 public:
  virtual void Bar(bool flag) const;
};
"""
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_CONST_METHOD1(Bar,\nvoid(bool flag));',
        self.GenerateMethodSource(source))
 
  def testExplicitVoid(self):
    source = """
class Foo {
 public:
  virtual int Bar(void);
};
"""
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_METHOD0(Bar,\nint(void));',
        self.GenerateMethodSource(source))
 
  def testStrangeNewlineInParameter(self):
    source = """
class Foo {
 public:
  virtual void Bar(int
a) = 0;
};
"""
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_METHOD1(Bar,\nvoid(int a));',
        self.GenerateMethodSource(source))
 
  def testDefaultParameters(self):
    source = """
class Foo {
 public:
  virtual void Bar(int a, char c = 'x') = 0;
};
"""
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_METHOD2(Bar,\nvoid(int, char));',
        self.GenerateMethodSource(source))
 
  def testMultipleDefaultParameters(self):
    source = """
class Foo {
 public:
  virtual void Bar(int a = 42, char c = 'x') = 0;
};
"""
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_METHOD2(Bar,\nvoid(int, char));',
        self.GenerateMethodSource(source))
 
  def testRemovesCommentsWhenDefaultsArePresent(self):
    source = """
class Foo {
 public:
  virtual void Bar(int a = 42 /* a comment */,
                   char /* other comment */ c= 'x') = 0;
};
"""
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_METHOD2(Bar,\nvoid(int, char));',
        self.GenerateMethodSource(source))
 
  def testDoubleSlashCommentsInParameterListAreRemoved(self):
    source = """
class Foo {
 public:
  virtual void Bar(int a,  // inline comments should be elided.
                   int b   // inline comments should be elided.
                   ) const = 0;
};
"""
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_CONST_METHOD2(Bar,\nvoid(int a, int b));',
        self.GenerateMethodSource(source))
 
  def testCStyleCommentsInParameterListAreNotRemoved(self):
    # 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
    # are still elided.
    source = """
class Foo {
 public:
  virtual const string& Bar(int /* keeper */, int b);
};
"""
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_METHOD2(Bar,\nconst string&(int /* keeper */, int b));',
        self.GenerateMethodSource(source))
 
  def testArgsOfTemplateTypes(self):
    source = """
class Foo {
 public:
  virtual int Bar(const vector<int>& v, map<int, string>* output);
};"""
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_METHOD2(Bar,\n'
        'int(const vector<int>& v, map<int, string>* output));',
        self.GenerateMethodSource(source))
 
  def testReturnTypeWithOneTemplateArg(self):
    source = """
class Foo {
 public:
  virtual vector<int>* Bar(int n);
};"""
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_METHOD1(Bar,\nvector<int>*(int n));',
        self.GenerateMethodSource(source))
 
  def testReturnTypeWithManyTemplateArgs(self):
    source = """
class Foo {
 public:
  virtual map<int, string> Bar();
};"""
    # 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.
    self.assertEqualIgnoreLeadingWhitespace(
        '// The following line won\'t really compile, as the return\n'
        '// type has multiple template arguments.  To fix it, use a\n'
        '// typedef for the return type.\n'
        'MOCK_METHOD0(Bar,\nmap<int, string>());',
        self.GenerateMethodSource(source))
 
  def testSimpleMethodInTemplatedClass(self):
    source = """
template<class T>
class Foo {
 public:
  virtual int Bar();
};
"""
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_METHOD0_T(Bar,\nint());',
        self.GenerateMethodSource(source))
 
  def testPointerArgWithoutNames(self):
    source = """
class Foo {
  virtual int Bar(C*);
};
"""
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_METHOD1(Bar,\nint(C*));',
        self.GenerateMethodSource(source))
 
  def testReferenceArgWithoutNames(self):
    source = """
class Foo {
  virtual int Bar(C&);
};
"""
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_METHOD1(Bar,\nint(C&));',
        self.GenerateMethodSource(source))
 
  def testArrayArgWithoutNames(self):
    source = """
class Foo {
  virtual int Bar(C[]);
};
"""
    self.assertEqualIgnoreLeadingWhitespace(
        'MOCK_METHOD1(Bar,\nint(C[]));',
        self.GenerateMethodSource(source))
 
 
class GenerateMocksTest(TestCase):
 
  def GenerateMocks(self, cpp_source):
    """Convert C++ source to complete Google Mock output source."""
    # <test> is a pseudo-filename, it is not read or written.
    filename = '<test>'
    builder = ast.BuilderFromSource(cpp_source, filename)
    ast_list = list(builder.Generate())
    lines = gmock_class._GenerateMocks(filename, cpp_source, ast_list, None)
    return '\n'.join(lines)
 
  def testNamespaces(self):
    source = """
namespace Foo {
namespace Bar { class Forward; }
namespace Baz {
 
class Test {
 public:
  virtual void Foo();
};
 
}  // namespace Baz
}  // namespace Foo
"""
    expected = """\
namespace Foo {
namespace Baz {
 
class MockTest : public Test {
public:
MOCK_METHOD0(Foo,
void());
};
 
}  // namespace Baz
}  // namespace Foo
"""
    self.assertEqualIgnoreLeadingWhitespace(
        expected, self.GenerateMocks(source))
 
  def testClassWithStorageSpecifierMacro(self):
    source = """
class STORAGE_SPECIFIER Test {
 public:
  virtual void Foo();
};
"""
    expected = """\
class MockTest : public Test {
public:
MOCK_METHOD0(Foo,
void());
};
"""
    self.assertEqualIgnoreLeadingWhitespace(
        expected, self.GenerateMocks(source))
 
  def testTemplatedForwardDeclaration(self):
    source = """
template <class T> class Forward;  // Forward declaration should be ignored.
class Test {
 public:
  virtual void Foo();
};
"""
    expected = """\
class MockTest : public Test {
public:
MOCK_METHOD0(Foo,
void());
};
"""
    self.assertEqualIgnoreLeadingWhitespace(
        expected, self.GenerateMocks(source))
 
  def testTemplatedClass(self):
    source = """
template <typename S, typename T>
class Test {
 public:
  virtual void Foo();
};
"""
    expected = """\
template <typename T0, typename T1>
class MockTest : public Test<T0, T1> {
public:
MOCK_METHOD0_T(Foo,
void());
};
"""
    self.assertEqualIgnoreLeadingWhitespace(
        expected, self.GenerateMocks(source))
 
  def testTemplateInATemplateTypedef(self):
    source = """
class Test {
 public:
  typedef std::vector<std::list<int>> FooType;
  virtual void Bar(const FooType& test_arg);
};
"""
    expected = """\
class MockTest : public Test {
public:
MOCK_METHOD1(Bar,
void(const FooType& test_arg));
};
"""
    self.assertEqualIgnoreLeadingWhitespace(
        expected, self.GenerateMocks(source))
 
  def testTemplateInATemplateTypedefWithComma(self):
    source = """
class Test {
 public:
  typedef std::function<void(
      const vector<std::list<int>>&, int> FooType;
  virtual void Bar(const FooType& test_arg);
};
"""
    expected = """\
class MockTest : public Test {
public:
MOCK_METHOD1(Bar,
void(const FooType& test_arg));
};
"""
    self.assertEqualIgnoreLeadingWhitespace(
        expected, self.GenerateMocks(source))
 
if __name__ == '__main__':
  unittest.main()

Browse

Tools

Subversion Repositories s80186

[/] [s80186/] [trunk/] [vendor/] [googletest/] [googlemock/] [scripts/] [generator/] [cpp/] [gmock_class_test.py] - Blame information for rev 2

Line No.	Rev	Author	Line
1	2	jamieiles	`#!/usr/bin/env python`
2			`#`
3			`# Copyright 2009 Neal Norwitz All Rights Reserved.`
4			`# Portions Copyright 2009 Google Inc. All Rights Reserved.`
5			`#`
6			`# Licensed under the Apache License, Version 2.0 (the "License");`
7			`# you may not use this file except in compliance with the License.`
8			`# You may obtain a copy of the License at`
9			`#`
10			`# http://www.apache.org/licenses/LICENSE-2.0`
11			`#`
12			`# Unless required by applicable law or agreed to in writing, software`
13			`# distributed under the License is distributed on an "AS IS" BASIS,`
14			`# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.`
15			`# See the License for the specific language governing permissions and`
16			`# limitations under the License.`
17
18			`"""Tests for gmock.scripts.generator.cpp.gmock_class."""`
19
20			`__author__ = 'nnorwitz@google.com (Neal Norwitz)'`
21
22
23			`import os`
24			`import sys`
25			`import unittest`
26
27			`# Allow the cpp imports below to work when run as a standalone script.`
28			`sys.path.append(os.path.join(os.path.dirname(__file__), '..'))`
29
30			`from cpp import ast`
31			`from cpp import gmock_class`
32
33
34			`class TestCase(unittest.TestCase):`
35			`"""Helper class that adds assert methods."""`
36
37			`def StripLeadingWhitespace(self, lines):`
38			`"""Strip leading whitespace in each line in 'lines'."""`
39			`return '\n'.join([s.lstrip() for s in lines.split('\n')])`
40
41			`def assertEqualIgnoreLeadingWhitespace(self, expected_lines, lines):`
42			`"""Specialized assert that ignores the indent level."""`
43			`self.assertEqual(expected_lines, self.StripLeadingWhitespace(lines))`
44
45
46			`class GenerateMethodsTest(TestCase):`
47
48			`def GenerateMethodSource(self, cpp_source):`
49			`"""Convert C++ source to Google Mock output source lines."""`
50			`method_source_lines = []`
51			`# <test> is a pseudo-filename, it is not read or written.`
52			`builder = ast.BuilderFromSource(cpp_source, '<test>')`
53			`ast_list = list(builder.Generate())`
54			`gmock_class._GenerateMethods(method_source_lines, cpp_source, ast_list[0])`
55			`return '\n'.join(method_source_lines)`
56
57			`def testSimpleMethod(self):`
58			`source = """`
59			`class Foo {`
60			`public:`
61			`virtual int Bar();`
62			`};`
63			`"""`
64			`self.assertEqualIgnoreLeadingWhitespace(`
65			`'MOCK_METHOD0(Bar,\nint());',`
66			`self.GenerateMethodSource(source))`
67
68			`def testSimpleConstructorsAndDestructor(self):`
69			`source = """`
70			`class Foo {`
71			`public:`
72			`Foo();`
73			`Foo(int x);`
74			`Foo(const Foo& f);`
75			`Foo(Foo&& f);`
76			`~Foo();`
77			`virtual int Bar() = 0;`
78			`};`
79			`"""`
80			`# The constructors and destructor should be ignored.`
81			`self.assertEqualIgnoreLeadingWhitespace(`
82			`'MOCK_METHOD0(Bar,\nint());',`
83			`self.GenerateMethodSource(source))`
84
85			`def testVirtualDestructor(self):`
86			`source = """`
87			`class Foo {`
88			`public:`
89			`virtual ~Foo();`
90			`virtual int Bar() = 0;`
91			`};`
92			`"""`
93			`# The destructor should be ignored.`
94			`self.assertEqualIgnoreLeadingWhitespace(`
95			`'MOCK_METHOD0(Bar,\nint());',`
96			`self.GenerateMethodSource(source))`
97
98			`def testExplicitlyDefaultedConstructorsAndDestructor(self):`
99			`source = """`
100			`class Foo {`
101			`public:`
102			`Foo() = default;`
103			`Foo(const Foo& f) = default;`
104			`Foo(Foo&& f) = default;`
105			`~Foo() = default;`
106			`virtual int Bar() = 0;`
107			`};`
108			`"""`
109			`# The constructors and destructor should be ignored.`
110			`self.assertEqualIgnoreLeadingWhitespace(`
111			`'MOCK_METHOD0(Bar,\nint());',`
112			`self.GenerateMethodSource(source))`
113
114			`def testExplicitlyDeletedConstructorsAndDestructor(self):`
115			`source = """`
116			`class Foo {`
117			`public:`
118			`Foo() = delete;`
119			`Foo(const Foo& f) = delete;`
120			`Foo(Foo&& f) = delete;`
121			`~Foo() = delete;`
122			`virtual int Bar() = 0;`
123			`};`
124			`"""`
125			`# The constructors and destructor should be ignored.`
126			`self.assertEqualIgnoreLeadingWhitespace(`
127			`'MOCK_METHOD0(Bar,\nint());',`
128			`self.GenerateMethodSource(source))`
129
130			`def testSimpleOverrideMethod(self):`
131			`source = """`
132			`class Foo {`
133			`public:`
134			`int Bar() override;`
135			`};`
136			`"""`
137			`self.assertEqualIgnoreLeadingWhitespace(`
138			`'MOCK_METHOD0(Bar,\nint());',`
139			`self.GenerateMethodSource(source))`
140
141			`def testSimpleConstMethod(self):`
142			`source = """`
143			`class Foo {`
144			`public:`
145			`virtual void Bar(bool flag) const;`
146			`};`
147			`"""`
148			`self.assertEqualIgnoreLeadingWhitespace(`
149			`'MOCK_CONST_METHOD1(Bar,\nvoid(bool flag));',`
150			`self.GenerateMethodSource(source))`
151
152			`def testExplicitVoid(self):`
153			`source = """`
154			`class Foo {`
155			`public:`
156			`virtual int Bar(void);`
157			`};`
158			`"""`
159			`self.assertEqualIgnoreLeadingWhitespace(`
160			`'MOCK_METHOD0(Bar,\nint(void));',`
161			`self.GenerateMethodSource(source))`
162
163			`def testStrangeNewlineInParameter(self):`
164			`source = """`
165			`class Foo {`
166			`public:`
167			`virtual void Bar(int`
168			`a) = 0;`
169			`};`
170			`"""`
171			`self.assertEqualIgnoreLeadingWhitespace(`
172			`'MOCK_METHOD1(Bar,\nvoid(int a));',`
173			`self.GenerateMethodSource(source))`
174
175			`def testDefaultParameters(self):`
176			`source = """`
177			`class Foo {`
178			`public:`
179			`virtual void Bar(int a, char c = 'x') = 0;`
180			`};`
181			`"""`
182			`self.assertEqualIgnoreLeadingWhitespace(`
183			`'MOCK_METHOD2(Bar,\nvoid(int, char));',`
184			`self.GenerateMethodSource(source))`
185
186			`def testMultipleDefaultParameters(self):`
187			`source = """`
188			`class Foo {`
189			`public:`
190			`virtual void Bar(int a = 42, char c = 'x') = 0;`
191			`};`
192			`"""`
193			`self.assertEqualIgnoreLeadingWhitespace(`
194			`'MOCK_METHOD2(Bar,\nvoid(int, char));',`
195			`self.GenerateMethodSource(source))`
196
197			`def testRemovesCommentsWhenDefaultsArePresent(self):`
198			`source = """`
199			`class Foo {`
200			`public:`
201			`virtual void Bar(int a = 42 /* a comment */,`
202			`char /* other comment */ c= 'x') = 0;`
203			`};`
204			`"""`
205			`self.assertEqualIgnoreLeadingWhitespace(`
206			`'MOCK_METHOD2(Bar,\nvoid(int, char));',`
207			`self.GenerateMethodSource(source))`
208
209			`def testDoubleSlashCommentsInParameterListAreRemoved(self):`
210			`source = """`
211			`class Foo {`
212			`public:`
213			`virtual void Bar(int a, // inline comments should be elided.`
214			`int b // inline comments should be elided.`
215			`) const = 0;`
216			`};`
217			`"""`
218			`self.assertEqualIgnoreLeadingWhitespace(`
219			`'MOCK_CONST_METHOD2(Bar,\nvoid(int a, int b));',`
220			`self.GenerateMethodSource(source))`
221
222			`def testCStyleCommentsInParameterListAreNotRemoved(self):`
223			`# NOTE(nnorwitz): I'm not sure if it's the best behavior to keep these`
224			`# comments. Also note that C style comments after the last parameter`
225			`# are still elided.`
226			`source = """`
227			`class Foo {`
228			`public:`
229			`virtual const string& Bar(int /* keeper */, int b);`
230			`};`
231			`"""`
232			`self.assertEqualIgnoreLeadingWhitespace(`
233			`'MOCK_METHOD2(Bar,\nconst string&(int /* keeper */, int b));',`
234			`self.GenerateMethodSource(source))`
235
236			`def testArgsOfTemplateTypes(self):`
237			`source = """`
238			`class Foo {`
239			`public:`
240			`virtual int Bar(const vector<int>& v, map<int, string>* output);`
241			`};"""`
242			`self.assertEqualIgnoreLeadingWhitespace(`
243			`'MOCK_METHOD2(Bar,\n'`
244			`'int(const vector<int>& v, map<int, string>* output));',`
245			`self.GenerateMethodSource(source))`
246
247			`def testReturnTypeWithOneTemplateArg(self):`
248			`source = """`
249			`class Foo {`
250			`public:`
251			`virtual vector<int>* Bar(int n);`
252			`};"""`
253			`self.assertEqualIgnoreLeadingWhitespace(`
254			`'MOCK_METHOD1(Bar,\nvector<int>*(int n));',`
255			`self.GenerateMethodSource(source))`
256
257			`def testReturnTypeWithManyTemplateArgs(self):`
258			`source = """`
259			`class Foo {`
260			`public:`
261			`virtual map<int, string> Bar();`
262			`};"""`
263			`# Comparing the comment text is brittle - we'll think of something`
264			`# better in case this gets annoying, but for now let's keep it simple.`
265			`self.assertEqualIgnoreLeadingWhitespace(`
266			`'// The following line won\'t really compile, as the return\n'`
267			`'// type has multiple template arguments. To fix it, use a\n'`
268			`'// typedef for the return type.\n'`
269			`'MOCK_METHOD0(Bar,\nmap<int, string>());',`
270			`self.GenerateMethodSource(source))`
271
272			`def testSimpleMethodInTemplatedClass(self):`
273			`source = """`
274			`template<class T>`
275			`class Foo {`
276			`public:`
277			`virtual int Bar();`
278			`};`
279			`"""`
280			`self.assertEqualIgnoreLeadingWhitespace(`
281			`'MOCK_METHOD0_T(Bar,\nint());',`
282			`self.GenerateMethodSource(source))`
283
284			`def testPointerArgWithoutNames(self):`
285			`source = """`
286			`class Foo {`
287			`virtual int Bar(C*);`
288			`};`
289			`"""`
290			`self.assertEqualIgnoreLeadingWhitespace(`
291			`'MOCK_METHOD1(Bar,\nint(C*));',`
292			`self.GenerateMethodSource(source))`
293
294			`def testReferenceArgWithoutNames(self):`
295			`source = """`
296			`class Foo {`
297			`virtual int Bar(C&);`
298			`};`
299			`"""`
300			`self.assertEqualIgnoreLeadingWhitespace(`
301			`'MOCK_METHOD1(Bar,\nint(C&));',`
302			`self.GenerateMethodSource(source))`
303
304			`def testArrayArgWithoutNames(self):`
305			`source = """`
306			`class Foo {`
307			`virtual int Bar(C[]);`
308			`};`
309			`"""`
310			`self.assertEqualIgnoreLeadingWhitespace(`
311			`'MOCK_METHOD1(Bar,\nint(C[]));',`
312			`self.GenerateMethodSource(source))`
313
314
315			`class GenerateMocksTest(TestCase):`
316
317			`def GenerateMocks(self, cpp_source):`
318			`"""Convert C++ source to complete Google Mock output source."""`
319			`# <test> is a pseudo-filename, it is not read or written.`
320			`filename = '<test>'`
321			`builder = ast.BuilderFromSource(cpp_source, filename)`
322			`ast_list = list(builder.Generate())`
323			`lines = gmock_class._GenerateMocks(filename, cpp_source, ast_list, None)`
324			`return '\n'.join(lines)`
325
326			`def testNamespaces(self):`
327			`source = """`
328			`namespace Foo {`
329			`namespace Bar { class Forward; }`
330			`namespace Baz {`
331
332			`class Test {`
333			`public:`
334			`virtual void Foo();`
335			`};`
336
337			`} // namespace Baz`
338			`} // namespace Foo`
339			`"""`
340			`expected = """\`
341			`namespace Foo {`
342			`namespace Baz {`
343
344			`class MockTest : public Test {`
345			`public:`
346			`MOCK_METHOD0(Foo,`
347			`void());`
348			`};`
349
350			`} // namespace Baz`
351			`} // namespace Foo`
352			`"""`
353			`self.assertEqualIgnoreLeadingWhitespace(`
354			`expected, self.GenerateMocks(source))`
355
356			`def testClassWithStorageSpecifierMacro(self):`
357			`source = """`
358			`class STORAGE_SPECIFIER Test {`
359			`public:`
360			`virtual void Foo();`
361			`};`
362			`"""`
363			`expected = """\`
364			`class MockTest : public Test {`
365			`public:`
366			`MOCK_METHOD0(Foo,`
367			`void());`
368			`};`
369			`"""`
370			`self.assertEqualIgnoreLeadingWhitespace(`
371			`expected, self.GenerateMocks(source))`
372
373			`def testTemplatedForwardDeclaration(self):`
374			`source = """`
375			`template <class T> class Forward; // Forward declaration should be ignored.`
376			`class Test {`
377			`public:`
378			`virtual void Foo();`
379			`};`
380			`"""`
381			`expected = """\`
382			`class MockTest : public Test {`
383			`public:`
384			`MOCK_METHOD0(Foo,`
385			`void());`
386			`};`
387			`"""`
388			`self.assertEqualIgnoreLeadingWhitespace(`
389			`expected, self.GenerateMocks(source))`
390
391			`def testTemplatedClass(self):`
392			`source = """`
393			`template <typename S, typename T>`
394			`class Test {`
395			`public:`
396			`virtual void Foo();`
397			`};`
398			`"""`
399			`expected = """\`
400			`template <typename T0, typename T1>`
401			`class MockTest : public Test<T0, T1> {`
402			`public:`
403			`MOCK_METHOD0_T(Foo,`
404			`void());`
405			`};`
406			`"""`
407			`self.assertEqualIgnoreLeadingWhitespace(`
408			`expected, self.GenerateMocks(source))`
409
410			`def testTemplateInATemplateTypedef(self):`
411			`source = """`
412			`class Test {`
413			`public:`
414			`typedef std::vector<std::list<int>> FooType;`
415			`virtual void Bar(const FooType& test_arg);`
416			`};`
417			`"""`
418			`expected = """\`
419			`class MockTest : public Test {`
420			`public:`
421			`MOCK_METHOD1(Bar,`
422			`void(const FooType& test_arg));`
423			`};`
424			`"""`
425			`self.assertEqualIgnoreLeadingWhitespace(`
426			`expected, self.GenerateMocks(source))`
427
428			`def testTemplateInATemplateTypedefWithComma(self):`
429			`source = """`
430			`class Test {`
431			`public:`
432			`typedef std::function<void(`
433			`const vector<std::list<int>>&, int> FooType;`
434			`virtual void Bar(const FooType& test_arg);`
435			`};`
436			`"""`
437			`expected = """\`
438			`class MockTest : public Test {`
439			`public:`
440			`MOCK_METHOD1(Bar,`
441			`void(const FooType& test_arg));`
442			`};`
443			`"""`
444			`self.assertEqualIgnoreLeadingWhitespace(`
445			`expected, self.GenerateMocks(source))`
446
447			`if __name__ == '__main__':`
448			`unittest.main()`