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;
1505 class MockFoo : public Foo {
1511   MockFoo foo;
1536 class MockFoo : public Foo {
1542   MockFoo foo;
1573   MockFoo foo;
1589 class MockFoo : public Foo {
1756 class MockFoo : public Foo {
1766   MockFoo foo;
1828 class MockFoo : public Foo {
1842   MockFoo foo;
1883 class MockFoo : public Foo {
1891   MockFoo foo;
1904 class MockFoo : public Foo {
1915   MockFoo foo;
1960   MockFoo foo;
1983   MockFoo foo;
2010 class MockFoo : public Foo {
2017   MockFoo foo;
2443 class MockFoo : public Foo {
2460 class MockFoo : public Foo {
2463   MockFoo();
2464   virtual ~MockFoo();
2479 MockFoo::MockFoo() {}
2480 MockFoo::~MockFoo() {}
2508   MockFoo* const foo = new MockFoo;
2609   MOCK_METHOD0(~MockFoo, void());  // Won't compile!
2617 class MockFoo : public Foo {
2621   virtual ~MockFoo() { Die(); }
2626 name.) Now, we have translated the problem of testing when a `MockFoo`
2630   MockFoo* foo = new MockFoo;
2762 class MockFoo {
2768   MockFoo mock;
3644 class MockFoo : public Foo {
3651   MockFoo foo;