Lines Matching refs:MockFoo

37 class MockFoo : public Foo {
69 class MockFoo : public Foo {
84 class MockFoo : public Foo {
236 Suppose your test uses a mock class `MockFoo`:
240   MockFoo mock_foo;
248 test to use `NiceMock<MockFoo>` instead, the warning will be gone,
255   NiceMock<MockFoo> mock_foo;
261 `NiceMock<MockFoo>` is a subclass of `MockFoo`, so it can be used
262 wherever `MockFoo` is accepted.
264 It also works if `MockFoo`'s constructor takes some arguments, as
265 `NiceMock<MockFoo>` "inherits" `MockFoo`'s constructors:
271   NiceMock<MockFoo> mock_foo(5, "hi");  // Calls MockFoo(5, "hi").
284   StrictMock<MockFoo> mock_foo;
296 …MockFoo>` and `StrictMock<MockFoo>` only work for mock methods defined using the `MOCK_METHOD*` fa…
297 …1. The constructors of the base mock (`MockFoo`) cannot have arguments passed by non-const referen…
298 …1. During the constructor or destructor of `MockFoo`, the mock object is _not_ nice or strict.  Th…
439 class MockFoo : public Foo {
458 With that, you can use `MockFoo` in your tests as usual. Just remember
466   MockFoo foo;
522 class MockFoo : public Foo {
524   MockFoo() {
540   MockFoo mock;
570 class MockFoo : public Foo {
580 `MockFoo::Concrete()`. Perhaps you want to do it as part of a stub
589 class MockFoo : public Foo {
608       .WillOnce(Invoke(&foo, &MockFoo::FooConcrete));
617       .WillByDefault(Invoke(&foo, &MockFoo::FooConcrete));
621 that, `MockFoo::Concrete()` will be called (and cause an infinite
719 class MockFoo : public Foo {
725   MockFoo foo;
749 class MockFoo : public Foo {
756   MockFoo foo;
1456 class MockFoo : public Foo {
1462   MockFoo foo;
1487 class MockFoo : public Foo {
1493   MockFoo foo;
1524   MockFoo foo;
1540 class MockFoo : public Foo {
1705 class MockFoo : public Foo {
1715   MockFoo foo;
1777 class MockFoo : public Foo {
1791   MockFoo foo;
1832 class MockFoo : public Foo {
1840   MockFoo foo;
1853 class MockFoo : public Foo {
1864   MockFoo foo;
1909   MockFoo foo;
1932   MockFoo foo;
1959 class MockFoo : public Foo {
1966   MockFoo foo;
2200 class MockFoo : public Foo {
2217 class MockFoo : public Foo {
2220   MockFoo();
2221   virtual ~MockFoo();
2236 MockFoo::MockFoo() {}
2237 MockFoo::~MockFoo() {}
2265   MockFoo* const foo = new MockFoo;
2366   MOCK_METHOD0(~MockFoo, void());  // Won't compile!
2374 class MockFoo : public Foo {
2378   virtual ~MockFoo() { Die(); }
2383 name.) Now, we have translated the problem of testing when a `MockFoo`
2387   MockFoo* foo = new MockFoo;
2519 class MockFoo {
2525   MockFoo mock;
3401 class MockFoo : public Foo {
3408   MockFoo foo;