From: Gottlob Frege (gottlobfrege_at_[hidden])
Date: 2006-09-15 00:11:36
On 9/14/06, Scott Meyers <usenet_at_[hidden]> wrote:
>
>
> My understanding is that the ability to drop in mock objects requires
> programming to an interface that can be either a "real" object or a mock
> object, which in turn suggests using either a template parameter or a
> base class. Suppose, for example, you have this:
>
> class BigHonkinHairyClass {
> ... // expensive to construct
> };
>
> and you want to implement some function f that takes a
> BigHonkinHairyClass as a parameter. The straightforward declaration
> would be
>
> void f(BigHonkinHairyClass& bhhc); // maybe const, doesn't matter
>
> But now it's hard to drop in a mock. So I assume you'd modify the
> interface to be either
>
> template<typename T>
> void f(T& bhhc); // T must more or less model
> // BigHonkinHairyClass
>
> or this:
>
> class BigHonkinHairyBase {
> ... // interface to program against --
> }; // uses virtuals
>
> class BigHonkinHairyClass: public BigHonkinHairyBase { ... };
>
> class MockHonkinHairyClass: public BigHonkinHairyBase { ... };
>
> void f(BigHonkinHairyBase& bhhc);
>
> Is that correct? In other words, you'd come up with an interface that
> let clients do what they wanted but that was also mock-friendly for
> testing purposes? That is, you'd take testability into account when
> designing your client interface?
I design interfaces like that, but not for testing - it's called the
Inversion Principle. How often do you really need a BigHonkinHairyClass ?
Often, you really just need a subset of its interface. So define that
sub-interface. Sometimes use templates, sometimes inheritance, etc.
Maybe that doesn't apply for every function f() (ie a different interface
for each function!?), but I thought the Inversion Principle would be worth
mentioning; YMMV.
Tony