NDC{Techtown} - Introducing Trompeloeil, a mocking framework for modern C++

1
Trompeloeil NDC{Techtown} 2017 – Björn Fahller @bjorn_fahller
Introducing Trompeloeil
a mocking framework for modern C++
Björn Fahller

View Slide

2
Björn Fahller
Trompe-l'œil noun (Concise Encyclopedia)
Style of representation in which a painted
object is intended to deceive the viewer into
believing it is the object itself...

View Slide

3
Björn Fahller

View Slide

4
https://www.youtube.com/watch?v=uhuHZXTRfH4
Mocking Frameworks considered harmful

View Slide

5
Trompeloeil is:
Pure C++14 without any dependencies
Implemented in a single header file
Under Boost Software License 1.0
Available from Conan
Adaptable to any (that I know of) unit testing framework

View Slide

6
https://github.com/rollbear/trompeloeil
Documentation
●
Integrating with unit test frame works
●
Introduction
●
Presentation videos
●
Trompeloeil on CppCast
●
Cheat Sheet (2*A4)
●
Cook Book
●
FAQ
●
Reference

View Slide

7
By default, Trompeloeil reports violations by throwing an exception,
explaining the problem in the what() string.
Depending on your test frame work and your runtime environment,
this may, or may not, suffice.
Trompeloeil offers support for adaptation to any test frame work.
Some sample adaptations are:
●
Catch!
●
crpcut
●
gtest
●
...

View Slide

8
By default, Trompeloeil reports violations by throwing an exception,
explaining the problem in the what() string.
Depending on your test frame work and your runtime environment,
this may, or may not, suffice.
Trompeloeil offers support for adaptation to any test frame work.
Some sample adaptations are:
●
Catch!
●
crpcut
●
gtest
●
...
If your favourite unit testing
frame work is not listed,
please write an adapter for it,
document it in the CookBook
and submit a pull request.
If your favourite unit testing
frame work is not listed,
please write an adapter for it,
document it in the CookBook
and submit a pull request.

View Slide

9
Introduction by example.
Free improvisation around the theme in Martin Fowler’s whisky store
order example, from the blog post “Mocks Aren’t Stubs”
http://martinfowler.com/articles/mocksArentStubs.html
class order {
...
};
This is the class to implement.
This is the class to implement.

View Slide

10
class order {
...
};
class store {
...
};
It will communicate with a store
It will communicate with a store
uses

View Slide

11
class order {
...
};
class store {
...
};
It will communicate with a store.
The store will be mocked.
It will communicate with a store.
The store will be mocked.
uses

View Slide

12
Creating a mock type.
#include
struct my_mock
{
MAKE_MOCK1(func, int(std::string&&));
};

View Slide

13
#include
struct my_mock
{
};
Function name Function signature
Number of arguments

View Slide

14
#include
struct my_mock
{
MAKE_MOCK1(func, int(std::string&&)); // int func(std::string&&);
};
Function name Function signature
Number of arguments

View Slide

15
Oh no, horrible mistake!
#include
struct my_mock
{
};

View Slide

16
#include
struct my_mock
{
};
In file included from cardinality_mismatch.cpp:1:0:
trompeloeil.hpp:2953:3: error: static assertion failed: Function signature does not have 2
parameters
static_assert(TROMPELOEIL_ID(cardinality_match)::value, \
^
trompeloeil.hpp:2885:3: note: in expansion of macro ˜TROMPELOEIL_MAKE_MOCK_’
TROMPELOEIL_MAKE_MOCK_(name,,2, __VA_ARGS__,,)
^
trompeloeil.hpp:3209:35: note: in expansion of macro ˜TROMPELOEIL_MAKE_MOCK2’
#define MAKE_MOCK2 TROMPELOEIL_MAKE_MOCK2
^
cardinality_mismatch.cpp:4:3: note: in expansion of macro ˜MAKE_MOCK2’
^

View Slide

17
#include
struct my_mock
{
};
In file included from cardinality_mismatch.cpp:1:0:
trompeloeil.hpp:2953:3: error: static assertion failed: Function signature does not have 2
parameters
static_assert(TROMPELOEIL_ID(cardinality_match)::value, \
^
trompeloeil.hpp:2885:3: note: in expansion of macro ˜TROMPELOEIL_MAKE_MOCK_’
TROMPELOEIL_MAKE_MOCK_(name,,2, __VA_ARGS__,,)
^
trompeloeil.hpp:3209:35: note: in expansion of macro ˜TROMPELOEIL_MAKE_MOCK2’
#define MAKE_MOCK2 TROMPELOEIL_MAKE_MOCK2
^
cardinality_mismatch.cpp:4:3: note: in expansion of macro ˜MAKE_MOCK2’
^
Full error message from
g++ 5.4

View Slide

18
#include
struct my_mock
{
};

View Slide

19
#include
struct interface
{
virtual ~interface() = default;
virtual int func(std::string&&) = 0;
};
struct my_mock : public interface
{
};

View Slide

20
Not needed, but
strongly recommended
#include
struct interface
{
virtual ~interface() = default;
virtual int func(std::string&&) = 0;
};
struct my_mock : public interface
{
MAKE_MOCK1(func, int(std::string&&), override);
};

View Slide

21
Improvisation around http://martinfowler.com/articles/mocksArentStubs.html
class store {
public:
virtual ~store() = default;
virtual size_t inventory(const std::string& article) const = 0;
virtual void remove(const std::string& article, size_t quantity) = 0;
};

View Slide

22
class store {
public:
};
class order {
public:
void add(const std::string article, size_t quantity);
void fill(store&);
};

View Slide

23
class store {
public:
};
class order {
public:
void add(const std::string article, size_t quantity);
void fill(store&);
};
order the_order;
the_order.add("Talisker", 50);
store& a_store = …
the_order.fill(a_store);

View Slide

24
class store {
public:
};
class mock_store : public store {
public:
MAKE_CONST_MOCK1(inventory, size_t(const std::string&), override);
};

View Slide

25
class store {
public:
};
public:
MAKE_MOCK2(remove, void(const std::string&, size_t), override);
};

View Slide

26
Test by setting up expectations
public:
};
TEST_CASE("filling does nothing if stock is insufficient")
{
order test_order;
test_order.add("Talisker", 51);
mock_store store;
{
const char* whisky = "Talisker";
REQUIRE_CALL(store, inventory(whisky))
test_order.fill(store);
}
}

View Slide

27
Create an order object
public:
};
{
order test_order;
mock_store store;
{
}
}

View Slide

28
Save whiskies to order – no action
public:
};
{
order test_order;
mock_store store;
{
}
}

View Slide

29
Create the mocked store – no action
public:
};
{
order test_order;
mock_store store;
{
}
}

View Slide

30
Set up expectation
for call
public:
};
{
order test_order;
mock_store store;
{
}
}

View Slide

31
Set up expectation
for call
public:
};
{
order test_order;
mock_store store;
{
}
}

View Slide

32
public:
};
{
order test_order;
mock_store store;
{
REQUIRE_CALL(store, inventory(whisky));
}
}
Can call store.inventory(whisky)
Can compare const char* and const std::string&

View Slide

33
public:
};
{
order test_order;
mock_store store;
{
}
}
Creates an “anonymous”
expectation object

View Slide

34
public:
};
{
order test_order;
mock_store store;
{
}
}
Parameters are copied into
the expectation object.

View Slide

35
public:
};
{
order test_order;
mock_store store;
{
}
}
Adds entry first in expectation
list for inventory(const std::string)

View Slide

36
public:
};
{
order test_order;
mock_store store;
{
}
}
Expectation must be fulfilled before destruction
of the expectation object at the end of scope

View Slide

37
public:
};
{
order test_order;
mock_store store;
{
}
}
class order
{
public:
void add(const std::string&, size_t) {}
void fill(store&) {}
};

View Slide

38
public:
};
{
order test_order;
mock_store store;
{
}
}
In file included from order_test.cpp:1:0:
/home/bjorn/devel/trompeloeil/trompeloeil.hpp: In instantiation of 'auto
trompeloeil::call_validator_t::operator+(trompeloeil::call_modifierTag, Info>&&) const [with M = trompeloeil::call_matcherstd::basic_string&), std::tuple >; Tag =
mock_store::trompeloeil_tag_type_trompeloeil_7; Info =
trompeloeil::matcher_info&)>;
Mock = mock_store]':
order_test.cpp:23:5: required from here
/home/bjorn/devel/trompeloeil/trompeloeil.hpp:3155:7: error: static assertion
failed: RETURN missing for non-void function
static_assert(valid_return_type, "RETURN missing for non-void function");
^~~~~~~~~~~~~

View Slide

39
public:
};
{
order test_order;
mock_store store;
{
}
}
In file included from order_test.cpp:1:0:
/home/bjorn/devel/trompeloeil/trompeloeil.hpp: In instantiation of 'auto
trompeloeil::call_validator_t::operator+(trompeloeil::call_modifierTag, Info>&&) const [with M = trompeloeil::call_matcherstd::basic_string&), std::tuple >; Tag =
mock_store::trompeloeil_tag_type_trompeloeil_7; Info =
trompeloeil::matcher_info&)>;
Mock = mock_store]':
order_test.cpp:23:5: required from here
/home/bjorn/devel/trompeloeil/trompeloeil.hpp:3155:7: error: static assertion
failed: RETURN missing for non-void function
static_assert(valid_return_type, "RETURN missing for non-void function");
^~~~~~~~~~~~~
Full error message from
g++ 6.2

View Slide

40
public:
};
{
order test_order;
mock_store store;
{
.RETURN(50);
}
}

View Slide

41
public:
};
{
order test_order;
mock_store store;
{
.RETURN(50);
}
}
Any expression with a type
convertible to the return
type of the function.

View Slide

42
public:
};
{
order test_order;
mock_store store;
{
.RETURN(50);
}
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.out is a Catch v1.8.1 host application.
Run with -? for options
-------------------------------------------------------------------------------
fill does nothing if stock is insufficient
-------------------------------------------------------------------------------
order_test.cpp:17
...............................................................................
order_test.cpp:50: FAILED:
CHECK( failure.empty() )
with expansion:
false
with message:
failure := "order_test.cpp:23
Unfulfilled expectation:
Expected store.inventory(whisky) to be called once, actually never called
param _1 == Talisker
"
===============================================================================
test cases: 1 | 1 failed
assertions: 1 | 1 failed

View Slide

43
public:
};
{
order test_order;
mock_store store;
{
.RETURN(50);
}
}
class order
{
public:
void add(const std::string& name, size_t) { article = name; }
void fill(store& the_store) { the_store.inventory(article); }
private:
std::string article;
};

View Slide

44
public:
};
{
order test_order;
mock_store store;
{
.RETURN(50);
}
}
class order
{
public:
void add(const std::string& name, size_t) { article = name; }
void fill(store& the_store) { the_store.inventory(article); }
private:
};
===============================================================================
test cases: 1 | 1 passed
assertions: - none -

View Slide

45
public:
};
TEST_CASE("filling does nothing if stock is insufficient")...
TEST_CASE("filling removes from store if in stock")
{
order test_order;
mock_store store;
{
REQUIRE_CALL(store, inventory("Talisker"))
.RETURN(50);
REQUIRE_CALL(store, remove("Talisker", 50));
}
}

View Slide

46
public:
};
{
order test_order;
mock_store store;
{
.RETURN(50);
}
}
Adds entry to expectation list for
inventory(const std::string&)

View Slide

47
public:
};
{
order test_order;
mock_store store;
{
.RETURN(50);
}
}
remove(const std::string&,size_t)

View Slide

48
public:
};
{
order test_order;
mock_store store;
{
.RETURN(50);
}
}
remove(const std::string&,size_t)
Note that the expectations
are added to separate lists.
There is no ordering relation
between them, so there are two
equally acceptable sequences
here.

View Slide

49
public:
};
{
order test_order;
mock_store store;
{
trompeloeil::sequence seq;
.RETURN(50)
.IN_SEQUENCE(seq);
REQUIRE_CALL(store, remove("Talisker", 50))
.IN_SEQUENCE(seq);
}
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-------------------------------------------------------------------------------
filling removes from store if in stock
-------------------------------------------------------------------------------
order_test.cpp:31
...............................................................................
order_test.cpp:64: FAILED:
with expansion:
false
with message:
failure := "order_test.cpp:39
Expected store.remove("Talisker", 50) to be called once, actually never
called
param _2 == 50
"
===============================================================================
test cases: 2 | 1 passed | 1 failed
assertions: 1 | 1 failed

View Slide

50
public:
};
{
order test_order;
mock_store store;
{
.RETURN(50);
}
}
class order
{
public:
void add(const std::string& name, size_t s) {
article = name;
quantity = s;
}
void fill(store& the_store) {
if (the_store.inventory(article) >= quantity) {
the_store.remove(article, quantity);
}
}
private:
size_t quantity;
};

View Slide

51
public:
};
{
order test_order;
mock_store store;
{
.RETURN(50);
}
}
class order
{
public:
void add(const std::string& name, size_t s) {
article = name;
quantity = s;
}
void fill(store& the_store) {
if (the_store.inventory(article) >= quantity) {
the_store.remove(article, quantity);
}
}
private:
size_t quantity;
};
===============================================================================

View Slide

52
class store {
public:
};
struct mock_store : store {
};

View Slide

53
class store {
public:
};
}; This API is no good
if there may be several
orders handled
simultaneously

View Slide

54
class store {
public:
};
orders handled
simultaneously
And what if we want
another type for
the article identification?

View Slide

55
class store {
public:
};
orders handled
simultaneously
And what if we want
another type for
the article identification?
And is an OO design with
a pure abstract base class
really what we want?

View Slide

56
template
struct mock_store {
public:
using article_type = ArticleType;
MAKE_MOCK2(reserve, size_t(const article_type&, size_t));
MAKE_MOCK2(cancel, void(const article_type&, size_t));
MAKE_MOCK2(remove, void(const article_type&, size_t));
};
using whisky_store = mock_store;
Allow arbitrary types
for article identification

View Slide

57
template
struct mock_store {
public:
};
Make reservation
atomically

View Slide

58
template
struct mock_store {
public:
};
Cancel a reservation

View Slide

59
template
struct mock_store {
public:
};
Remove from the store
what you have reserved

View Slide

60
template
struct mock_store {
public:
};
And a convenience when
writing the tests.

View Slide

61
Reduces repetition
template
struct mock_store {
public:
struct record {
article_type article;
size_t quantity;
};
MAKE_MOCK1(reserve, size_t(const record&));
MAKE_MOCK1(cancel, void(const record&));
MAKE_MOCK1(remove, void(const record&));
};
using record = whisky_store::record;

View Slide

62
template
struct mock_store {
public:
struct record {
size_t quantity;
};
};
using whisky_store = store;
whisky_store& a_store = ...
order the_order(a_store);
if (the_order.add({"Talisker", 50}) == 50)
the_order.fill();

View Slide

63
Rewriting tests to new interface
template
struct mock_store {
struct record { ... };
...
};
TEST_CASE("add returns reserved amount")
{
whisky_store store;
auto test_order = new order{store};
{
REQUIRE_CALL(store, reserve(record{"Talisker", 51}))
.RETURN(50);
auto q = test_order->add("Talisker", 51);
REQUIRE(q == 50);
}
// intentionally leak order, so as not to bother with cleanup
}

View Slide

64
template
struct mock_store {
...
};
{
whisky_store store;
{
.RETURN(50);
REQUIRE(q == 50);
}
}

View Slide

65
template
struct mock_store {
...
};
{
whisky_store store;
{
.RETURN(50);
REQUIRE(q == 50);
}
}
No operator==
for record
Hmmm...

View Slide

66
Matcher for any value and any type
template
struct mock_store {
...
};
{
whisky_store store;
{
using trompeloeil::_;
REQUIRE_CALL(store, reserve(_))
.WITH(_1.article == "Talisker" && _1.quantity == 51)
.RETURN(50);
REQUIRE(q == 50);
}
}

View Slide

67
So accept call with any record
template
struct mock_store {
...
};
{
whisky_store store;
{
.RETURN(50);
REQUIRE(q == 50);
}
}

View Slide

68
template
struct mock_store {
...
};
{
whisky_store store;
{
.RETURN(50);
REQUIRE(q == 50);
}
}
And then constrain it to only
match the intended value

View Slide

69
Boolean expression using
positional names for
parameters to the function
template
struct mock_store {
...
};
{
whisky_store store;
{
.RETURN(50);
REQUIRE(q == 50);
}
}

View Slide

70
Catch! assertion
template
struct mock_store {
...
};
{
whisky_store store;
{
.RETURN(50);
REQUIRE(q == 50);
}
}

View Slide

71
template
struct mock_store {
...
};
{
whisky_store store;
{
.RETURN(50);
REQUIRE(q == 50);
}
}
template
class order
{
public:
using article_type = typename StoreType::article_type;
order(StoreType& s) : the_store{s} {}
size_t add(const article_type& article, size_t quantity) {
...
}
private:
StoreType& the_store;
};

View Slide

72
template
struct mock_store {
...
};
{
whisky_store store;
{
.RETURN(50);
REQUIRE(q == 50);
}
}
template
class order
{
public:
return the_store.reserve({article, quantity});
}
private:
};

View Slide

73
template
struct mock_store {
...
};
{
whisky_store store;
{
.RETURN(50);
REQUIRE(q == 50);
}
}
===============================================================================
template
class order
{
public:
return the_store.reserve({article, quantity});
}
private:
};

View Slide

74
TEST_CASE("fill removes the reserved item")
{
whisky_store store;
{
.RETURN(50);
test_order->add("Talisker", 51);
}
{
REQUIRE_CALL(store, remove(_))
.WITH(_1.article == "Talisker" && _1.quantity == 50);
test_order->fill();
}
}

View Slide

75
The trigger to remove from store
{
whisky_store store;
{
.RETURN(50);
}
{
test_order->fill();
}
}

View Slide

76
{
mock_store store;
{
.RETURN(50);
}
{
.WITH(_1.article == "Talisker" && 1.quantity == 50);
test_order->fill();
}
}
template
class order
{
public:
auto q = the_store.reserve({article, quantity});
reserved[article] = q;
return q;
}
void fill() {
}
private:
std::unordered_map reserved;
};

View Slide

77
{
mock_store store;
{
.RETURN(50);
}
{
test_order->fill();
}
}
template
class order
{
public:
return q;
}
void fill() {
for (auto& line : reserved)
the_store.remove({line.first, line.second});
}
private:
};

View Slide

78
{
mock_store store;
{
.RETURN(50);
}
{
test_order->fill();
}
}
===============================================================================
All tests passed (1 assertion in 2 test cases)
template
class order
{
public:
return q;
}
void fill() {
}
private:
};

View Slide

79
TEST_CASE("multiple adds to same article are combined")
{
whisky_store store;
auto test_order = std::make_unique>(store);
{
.RETURN(20);
}
{
.RETURN(30);
}
...
}

View Slide

80
{
whisky_store store;
{
.RETURN(20);
}
{
.RETURN(30);
}
...
}

View Slide

81
{
whisky_store store;
{
.RETURN(20);
}
{
.RETURN(30);
}
...
}
This is madness!

View Slide

82
{
whisky_store store;
{
ALLOW_CALL(store, reserve(_))
.WITH(_1.article == "Talisker")
.RETURN(_1.quantity);
}
{
test_order->fill();
}
}

View Slide

83
Any number of calls
{
whisky_store store;
{
}
{
test_order->fill();
}
}

View Slide

84
Must happen exactly twice
{
whisky_store store;
{
.TIMES(2)
}
{
test_order->fill();
}
}

View Slide

85
{
whisky_store store;
{
.TIMES(2)
}
{
test_order->fill();
}
}
There’s also
.TIMES(AT_LEAST(2))

View Slide

86
{
whisky_store store;
{
.TIMES(2)
}
{
test_order->fill();
}
}
There’s also
.TIMES(AT_LEAST(2))
and
.TIMES(AT_MOST(5))

View Slide

87
{
whisky_store store;
{
.TIMES(2)
}
{
test_order->fill();
}
}
There’s also
.TIMES(AT_LEAST(2))
and
.TIMES(AT_MOST(5))
and even
.TIMES(2,5)

View Slide

88
{
whisky_store store;
{
.TIMES(2)
}
{
test_order->fill();
}
}

View Slide

89
{
whisky_store store;
{
}
{
test_order->fill();
}
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-------------------------------------------------------------------------------
multiple adds to same article are combined
-------------------------------------------------------------------------------
order_test2.cpp:101
...............................................................................
order_test2.cpp:133: FAILED:
explicitly with message:
No match for call of remove with signature void(const record&) with.
param _1 == 40-byte object={
0x10 0xfb 0x90 0x30 0xff 0x7f 0x00 0x00 0x80 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x54 0x61 0x6c 0x69 0x73 0x6b 0x65 0x72 0x00 0xfb 0x90 0x30 0xff 0x7f 0x00 0x00
0x1e 0x00 0x00 0x00 0x00 0x00 0x00 0x00 }
Tried store.remove(_) at order_test2.cpp:113
Failed WITH(_1.article == "Talisker" && _1.quantity == 50)
===============================================================================
assertions: 2 | 1 passed | 1 failed

View Slide

90
{
whisky_store store;
{
}
{
test_order->fill();
}
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
order_test2.cpp:101
...............................................................................
param _1 == 40-byte object={
0x10 0xfb 0x90 0x30 0xff 0x7f 0x00 0x00 0x80 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x54 0x61 0x6c 0x69 0x73 0x6b 0x65 0x72 0x00 0xfb 0x90 0x30 0xff 0x7f 0x00 0x00
0x1e 0x00 0x00 0x00 0x00 0x00 0x00 0x00 }
===============================================================================
Hex dump for types with no
stream insertion operator.
Time to implement a custom
print function for record

View Slide

91
{
whisky_store store;
{
}
{
test_order->fill();
}
}
namespace trompeloeil {
void print(std::ostream& os, const ::record& line)
{
os << "{ article=" << line.article << ", quantity=" << line.quantity << " }";
}
}

View Slide

92
{
whisky_store store;
{
}
{
test_order->fill();
}
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
order_test2.cpp:109
...............................................................................
param _1 == { article=Talisker, quantity=30 }
===============================================================================

View Slide

93
{
whisky_store store;
{
}
{
test_order->fill();
}
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
order_test2.cpp:109
...............................................................................
param _1 == { article=Talisker, quantity=30 }
===============================================================================
Bug in summation from
reserve?

View Slide

94
{
mock_store store;
{
}
{
test_order->fill();
}
}
Template
class order
{
public:
~order() {
the_store.cancel({line.first, line.second});
}
return q;
}
void fill() {
}
private:
};

View Slide

95
{
mock_store store;
{
}
{
test_order->fill();
}
}
Template
class order
{
public:
~order() {
}
return q;
}
void fill() {
}
private:
};
Oops!

View Slide

96
{
mock_store store;
{
}
{
test_order->fill();
}
}
Template
class order
{
public:
~order() {
}
reserved[article] += q;
return q;
}
void fill() {
}
private:
};

View Slide

97
{
mock_store store;
{
}
{
test_order->fill();
}
}
Template
class order
{
public:
~order() {
}
return q;
}
void fill() {
}
private:
};
===============================================================================

View Slide

98
Automation
I want a mocked store that I can stock up at the beginning
of a test, and that enforces the allowed/required behaviour
of its client.

View Slide

99
Automation
of its client.
It is not required to handle all situations, odd cases can be
handled with tests written as previously.

View Slide

100
Automation
of its client.
It is not required to handle several parallel orders.

View Slide

101
Automation
of its client.
It is not required to handle several parallel orders.
It should suffice with one map for the stock, and one map
for what’s reserved by the client.

View Slide

102
Working with data
struct stock_w_reserve
{
stock_w_reserve(whisky_store& store_,
std::map stock_)
: stock(std::move(stock_))
{
}
std::map stock;
std::map reserved;
}
?

View Slide

103
{
std::map stock_)
{
...
}
std::map stock;
std::map reserved;
}
Working with data
Expectation must be fulfilled
by the end of the scope.

View Slide

104
Working with data
std::unique_ptr
{
std::map stock_)
, e(NAMED_ALLOW_CALL(store, reserve(_))...)
{
}
std::map stock;
std::map reserved;
std::unique_ptr e;
}

View Slide

105
Working with data
{
std::map stock_)
, e(NAMED_ALLOW_CALL(store, reserve(_))
.WITH(_1.quantity > 0 && _1.quantity <= stock[_1.article]))
{
}
std::map stock;
std::map reserved;
std::unique_ptr e;
}

View Slide

106
Update
maps
Working with data
{
std::map stock_)
.WITH(_1.quantity > 0 && _1.quantity <= stock[_1.article])
.SIDE_EFFECT(stock[_1.article] -= _1.quantity)
.SIDE_EFFECT(reserved[_1.article] += _1.quantity))
{
}
std::map stock;
std::map reserved;
std::unique_ptr e;
}

View Slide

107
Working with data
{
std::map stock_)
.SIDE_EFFECT(reserved[_1.article] += _1.quantity)
.RETURN(_1.quantity))
{
}
std::map stock;
std::map reserved;
std::unique_ptr e;
}

View Slide

108
Working with data
{
std::map stock_);
std::map reserved;
}
TEST_CASE("multiple adds to same article are combined") {
whisky_store store;
stock_w_reserve s(store, {{"Talisker",50}});
{
.LR_WITH(s.reserved[_1.article] == _1.quantity);
test_order->fill();
}
}

View Slide

109
Working with data
{
std::map stock_);
std::map reserved;
}
whisky_store store;
{
test_order->fill();
}
}

View Slide

110
Working with data
{
std::map stock_);
std::map reserved;
}
whisky_store store;
{
test_order->fill();
}
}

View Slide

111
Working with data
{
std::map stock_);
std::map reserved;
}
whisky_store store;
{
test_order->fill();
}
}
LR_ prefix means local reference

View Slide

112
Working with data
{
std::map stock_);
std::map reserved;
}
whisky_store store;
{
test_order->fill();
}
}
LR_ prefix means local reference
i.e. s is a reference.

View Slide

113
Working with data
{
std::map stock_);
std::map reserved;
}
whisky_store store;
{
test_order->fill();
}
}
If it wasn’t already clear, this is the
return expression in a lambda.
LR_ makes the capture [&]
instead of the default [=]

View Slide

114
Working with data
{
std::map stock_);
std::map reserved;
}
whisky_store store;
{
test_order->fill();
}
}
What if fill() actually
calls reserve()?

View Slide

115
Working with data
{
std::map stock_);
std::map reserved;
}
whisky_store store;
{
FORBID_CALL(store, reserve(_));
test_order->fill();
}
}

View Slide

116
Working with data
{
std::map stock_);
std::map reserved;
}
whisky_store store;
{
test_order->fill();
}
}
Adds entry first in
expectation list for
reserve(const record&)

View Slide

117
Working with data
{
std::map stock_);
std::map reserved;
}
whisky_store store;
{
test_order->fill();
}
}
Adds entry first in
expectation list for
reserve(const record&)
Multiple expectations on the same
object and same function are tried
in reverse order of creation.
reserve() is already allowed from
stock_w_reserve,
but this unconstrained expectation
match first, so errors are caught.

View Slide

118
Or maybe better to
only allow reserve
in local scope?
Working with data
{
std::map stock_);
std::map reserved;
}
whisky_store store;
{
}
{
.WITH(_1.article] == "Talisker" && _1.quantity == 50);
test_order->fill();
}
}

View Slide

119
Working with data
{
std::map stock_);
std::map reserved;
}
whisky_store store;
{
}
{
.WITH(_1.article] == "Talisker" && _1.quantity == 50);
test_order->fill();
}
}

View Slide

120
Working with data
{
std::map stock_);
std::map reserved;
};
TEST_CASE("multiple articles can be ordered") {
whisky_store store;
stock_w_reserve s{store, {{"Talisker",50},{"Oban",10}}};
test_order->add("Oban", 5);
{
ALLOW_CALL(store, remove(_))
.LR_WITH(s.reserved[_1.name] == _1.quantity);
.LR_SIDE_EFFECT(s.reserved.erase(_1.name));
test_order->fill();
}
}
GIMME
MOAR
WHISKY!!!
http://img07.deviantart.net/c866/i/2010/284/c/2/crazy_kitten_by_cindy1701d-d2wncka.jpg

View Slide

121
Working with data
{
std::map stock_);
std::map reserved;
};
whisky_store store;
{
test_order->fill();
}
} http://img07.deviantart.net/c866/i/2010/284/c/2/crazy_kitten_by_cindy1701d-d2wncka.jpg
Maybe it’s time to stop
and think...

View Slide

122
Working with data
{
std::map stock_);
std::map reserved;
};
whisky_store store;
{
test_order->fill();
}
} http://img07.deviantart.net/c866/i/2010/284/c/2/crazy_kitten_by_cindy1701d-d2wncka.jpg
… is this the job for
a mock?

View Slide

123
Advanced usage
After having refactored several tests and added many new
ones, a new requirement comes in.

View Slide

124
Advanced usage
It must be possible to optionally get notifications through a
callback when an article becomes available in stock.

View Slide

125
Advanced usage
●
This should be as an optional std::function
parameter to add().

View Slide

126
Advanced usage
●
parameter to add().
●
This implementation of add() must request notifications
when the returned quantity is lower than the requested
quantity.

View Slide

127
Advanced usage
●
parameter to add().
●
This implementation of add() must request notifications
when the returned quantity is lower than the requested
quantity.
template
class order
{
public:
...
size_t add(
const article_type& article,
size_t quantity,
std::function = {})
{
return q;
}
...
private:
};

View Slide

128
template
struct mock_store {
public:
struct record {
size_t quantity;
};
};

View Slide

129
template
struct mock_store {
public:
struct record {
size_t quantity;
};
using cb = std::function;
MAKE_MOCK2(notify, void(const article_type&, cb));
};

View Slide

130
Advanced usage
TEST_CASE("add with cb requests notification if insufficient stock") {
whisky_store store;
bool called = false;
std::function callback;
{
REQUIRE_CALL(store, notify("Oban", _))
.LR_SIDE_EFFECT(callback = _2);
test_order->add("Oban", 11, [&called]() { called = true;});
}
callback();
REQUIRE(called);
}

View Slide

131
Advanced usage
Save 2nd parameter in local variable
whisky_store store;
{
}
callback();
REQUIRE(called);
}

View Slide

132
Advanced usage
Call with lambda that changes
local variable when called.
whisky_store store;
{
}
callback();
REQUIRE(called);
}

View Slide

133
Advanced usage
whisky_store store;
{
}
callback();
REQUIRE(called);
}

View Slide

134
Ensure local variable
did change after call
Advanced usage
whisky_store store;
{
}
callback();
REQUIRE(called);
}

View Slide

135
whisky_store store;
std::map stock = {{"Talisker",50},{"Oban",10}};
std::map reserved;
{
auto expectations = stock_up_store(store, stock, reserved);
}
callback();
REQUIRE(called);
}
Advanced usage
-------------------------------------------------------------------------------
add with cb requests notification when insufficient stock
-------------------------------------------------------------------------------
order_test4.cpp:204
...............................................................................
with expansion:
false
with message:
failure := "order_test4.cpp:214
Expected store.notify("Oban", _) to be called once, actually never called
param _1 == Oban
param _2 matching _
"
REQUIRE( callback )
with expansion:
false
===============================================================================

View Slide

136
whisky_store store;
{
}
callback();
REQUIRE(called);
}
Advanced usage
template
class order
{
public:
...
size_t add(
size_t quantity,
std::function cb = {})
{
return q;
}
...
private:
};

View Slide

137
whisky_store store;
{
}
callback();
REQUIRE(called);
}
Advanced usage
template
class order
{
public:
...
size_t add(
size_t quantity,
{
if (q < quantity) the_store.notify(article, cb);
return q;
}
...
private:
};

View Slide

138
whisky_store store;
{
}
callback();
REQUIRE(called);
}
Advanced usage
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
order_test4.cpp:167
...............................................................................
No match for call of notify with signature void(const std::string&,
std::function) with.
param _2 == nullptr
===============================================================================

View Slide

139
whisky_store store;
{
}
callback();
REQUIRE(called);
}
Advanced usage
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
order_test4.cpp:167
...............................................................................
param _2 == nullptr
===============================================================================

View Slide

140
whisky_store store;
{
}
callback();
REQUIRE(called);
}
Advanced usage
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
order_test4.cpp:167
...............................................................................
param _2 == nullptr
===============================================================================
So the fix broke another test.

View Slide

141
using trompeloeil::ne;
{
stock_w_reserve(whisky_store& store,
std::map stock_)
, r1{NAMED_ALLOW_CALL(store, reserve(_))
.RETURN(_1.quantity)}
...
, n{NAMED_ALLOW_CALL(store, notify(_,ne(nullptr)))}
{
}
std::map stock;
std::map reserved;
std::unique_ptr r1, ... , n;
}
Advanced usage
template
class order
{
public:
...
size_t add(
size_t quantity,
{
if (q < quantity) the_store.notify(article, cb);
return q;
}
...
private:
};

View Slide

142
{
std::map stock_)
...
{
}
std::map stock;
std::map reserved;
}
Advanced usage
template
class order
{
public:
...
size_t add(
size_t quantity,
{
if (q < quantity && cb) the_store.notify(article, cb);
return q;
}
...
private:
};

View Slide

143
{
std::map stock_)
...
{
}
std::map stock;
std::map reserved;
}
Advanced usage
===============================================================================
template
class order
{
public:
...
size_t add(
size_t quantity,
{
if (q < quantity && cb) the_store.notify(article, cb);
return q;
}
...
private:
};

View Slide

144

View Slide

145

View Slide

146
Huge thanks to:
Andrew Paxie
●
backport to C++11 (coming soon)
●
fixed numerous bugs
●
corrected documentation
Austin McCartney
●
fixed broken travis-ci integration

View Slide

147
Björn Fahller
[email protected]
@bjorn_fahller
@rollbear cpplang, swedencpp

View Slide

NDC{Techtown} - Introducing Trompeloeil, a mocking framework for modern C++

NDC{Techtown} - Introducing Trompeloeil, a mocking framework for modern C++

Björn Fahller

More Decks by Björn Fahller

Other Decks in Programming

Featured

Transcript