Breaking dependency by templates in C++

There are many different ways to break dependencies when doing unit testing in C++. We can use approaches described in the book, including constructor injection, setter injection, extract and override, and...yes, the factory design pattern. They work well in some cases so that we should know the pros and cons of every tricks above. However, they have some common shortcomings:

• unnecessary run-time indirection by using inheritance (it is getting worse when critical execution path is on the objects)
• unnecessary interfaces should be added and used. (those interfaces are merely for unit test convenience, not so meaningful in production code)

Those traditional tricks used in unit test are based on common OO features. If we focus on C++, can we solve these two problems by different thinking? 

I gave template a try by writing a simple word count program. Before we go on, you can clone it to play. The main class (mwc) is a class template with a template parameter contains two dependencies will be used in it.

1.    /* abstract dependency policy for mwc */
2.    template<typename FL_, typename INI_>
3.       struct mwc_dep {
4.          typedef FL_            FL;
5.          typedef INI_           INI;
6.       };
8.    /* production dependency to be used in mwc */
9.    typedef mwc_dep<product_file_loader, product_ini_mgr> product_mwc_dep;
11.    /* mwc, our CUT, have some dependency needed to be broken by abstraction tricks */
12.    template <typename DEP = product_mwc_dep>
13.       class mwc {
14.          typedef typename DEP::FL               FL;
15.          typedef typename DEP::INI              INI;

The production code (production_mwc_dep) would do every practical work and it is the default template parameter of mwc. We can use it as following:

1. void ProductMWCTester::MWC_QueryValidWord_ReturnCount()
2. {
3.    MC::mwc<> wc;
5.    wc.load("./data");
7.    CPPUNIT_ASSERT_EQUAL(2, wc.query("ooooo"));
8. }

Then I do the unit test by writing some mock classes. Here comes the mock part:

1. class mock_file_loader0: public MC::file_loader {
2.    public:
3.       void content(const std::string &fn, std::string &source)
4.       {
5.          source = "";
6.          source += "ooooo\nI\nam who ooooo\nwho ope\nThere\n";
7.       }
8. };
10. class mock_ini_mgr0: public MC::ini_mgr {
11.    public:
12.       void open(const char *ini_file)
13.       {
14.          exclude_words_.insert("The");
15.          exclude_words_.insert("I");
16.          exclude_words_.insert("There");
17.       }
19.       uint32_t min_word_length() const { return 2; }
21.       const std::set<std::string> &exclude_words() const { return exclude_words_; }
23.       bool enable_case_sensitive() const { return true; }
24.    private:
25.       std::set<std::string> exclude_words_;
26. };
28. void MockMWCTester::MWC_QueryValidWord_ReturnCount()
29. {
30.    typedef MC::mwc_dep<mock_file_loader0, mock_ini_mgr0> mock_mwc_dep;
31.    MC::mwc<mock_mwc_dep> wc;
32.    wc.load("./data");
34.    CPPUNIT_ASSERT_EQUAL(2, wc.query("ooooo"));
35. }

Yes!! By using templates, we can really solve the problems we mentioned. However, experienced programmers might ask: how can I create mock classes conveniently just as gmock? The answer is: No, we don't.

Currently I can't find any mock framework which can mock "type". They all mock objects. If we want to mock types and then use the mock types as template parameters(which should be types), we must do it on our own. For now, I would like to try this method for a while to get more experience when using templates as dependency breaking tricks. And might try to create a mock framework to mock type if I can do it. Just wait and see. :-)