Using Trompeloeil - a mocking framework for modern C++

1
Trompeloeil ACCU 2017
Using Trompeloeil
a mocking framework for modern C++
Björn Fahller

View Slide

2
Using Trompeloeil
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
Using Trompeloeil
Björn Fahller

View Slide

4
Using Trompeloeil
Björn Fahller

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
●
Intro presentation from Stockholm C++ UG (YouTube)
●
Introduction
●
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);
}
}
Sequence objects provides
a way to impose and
enforce a sequential
ordering of otherwise
unrelated expectations.

View Slide

50
public:
};
{
order test_order;
mock_store store;
{
.RETURN(50)
.IN_SEQUENCE(seq);
.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

View Slide

51
public:
};
{
order test_order;
mock_store store;
{
.RETURN(50)
.IN_SEQUENCE(seq);
.IN_SEQUENCE(seq);
}
}
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
public:
};
{
order test_order;
mock_store store;
{
.RETURN(50)
.IN_SEQUENCE(seq);
.IN_SEQUENCE(seq);
}
}
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

53
https://www.instagram.com/p/BRbWpWXhyhM/
●
Background
●
Adaptation to unit
test framework
●
Make mock member
functions
●
override
●
REQUIRE_CALL
●
Expectation objects
●
Lifetime of
expectation
●
RETURN
●
Sequence control
●
Templated type
●
Wildcard and WITH
●
Positional parameter
names
●
ALLOW_CALL
●
TIMES
●
Print custom data
types
●
Named expectations
●
SIDE_EFFECT
●
LR_ prefix
●
FORBID_CALL
●
Callbacks
●
Trompeloeil
matchers
●
Writing own
matchers
●
Lifetime control
●
Advanced sequence
control

View Slide

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

View Slide

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

View Slide

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

View Slide

57
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

58
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

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

View Slide

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

View Slide

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

View Slide

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

View Slide

63
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

64
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

65
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

66
template
struct mock_store {
...
};
{
whisky_store store;
{
.RETURN(50);
REQUIRE(q == 50);
}
}
Templatise the
order class too.

View Slide

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

View Slide

68
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

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

View Slide

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

View Slide

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

View Slide

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

View Slide

73
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

74
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

75
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

76
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

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

View Slide

78
{
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

79
{
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

80
{
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

81
TEST_CASE("destructor cancels the reserved item")
{
whisky_store store;
auto test_order = std::make_unique>(store);
{
.RETURN(50);
}
{
REQUIRE_CALL(store, cancel(_))
test_order.reset();
}
}

View Slide

82
Destroy the order object
{
whisky_store store;
{
.RETURN(50);
}
{
test_order.reset();
}
}

View Slide

83
{
mock_store store;
auto test_order = std::make_unique(store);
{
.RETURN(50);
}
{
test_order.reset();
}
}
Template
class order
{
public:
~order() {
the_store.cancel({line.first, line.second});
}
return q;
}
void fill() {
}
private:
};

View Slide

84
{
mock_store store;
auto test_order = std::make_unique(store);
{
.RETURN(50);
}
{
test_order.reset();
}
}
Template
class order
{
public:
~order() {
}
return q;
}
void fill() {
}
private:
};
===============================================================================

View Slide

85
TEST_CASE("multiple adds to same article are combined")
{
whisky_store store;
{
.RETURN(20);
}
{
.RETURN(30);
}
...
}

View Slide

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

View Slide

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

View Slide

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

View Slide

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

View Slide

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

View Slide

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

View Slide

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

View Slide

93
{
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

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

View Slide

95
{
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

96
{
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

97
{
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

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

View Slide

99
{
whisky_store store;
{
}
{
test_order->fill();
}
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
order_test2.cpp:109
...............................................................................
===============================================================================
Bug in summation from
reserve?

View Slide

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

View Slide

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

View Slide

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

View Slide

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

View Slide

104
https://www.instagram.com/p/BRYcd10AJy2
●
Background
●
Adaptation to unit
test framework
●
Make mock member
functions
●
override
●
REQUIRE_CALL
●
Expectation objects
●
Lifetime of
expectation
●
RETURN
●
Sequence control
●
Templated type
●
Wildcard and WITH
●
Positional
parameter names
●
ALLOW_CALL
●
TIMES
●
Print custom data
types
●
Named expectations
●
SIDE_EFFECT
●
LR_ prefix
●
FORBID_CALL
●
Callbacks
●
Trompeloeil
matchers
●
Writing own
matchers
●
Lifetime control
●
Advanced sequence
control

View Slide

105
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition
Repetition

View Slide

106
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

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

View Slide

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

View Slide

109
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

110
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

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

View Slide

112
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

113
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

114
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

115
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

116
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

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

View Slide

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

View Slide

119
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

120
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

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

View Slide

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

View Slide

123
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

124
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

125
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

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

View Slide

127
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

128
Check removal of all
Working with data
{
std::map stock_);
std::map reserved;
}
whisky_store store;
{
ALLOW_CALL(store, remove(_))
test_order->fill();
}
}

View Slide

129
Better. We expect
exactly two calls
Working with data
{
std::map stock_);
std::map reserved;
}
whisky_store store;
{
.TIMES(2)
test_order->fill();
}
}

View Slide

130
Working with data
{
std::map stock_);
std::map reserved;
};
whisky_store store;
{
.TIMES(2)
test_order->fill();
}
}
Should’ve added
REQUIRE(s.reserved.empty())
but ran out of slide space...

View Slide

131
Working with data
{
std::map stock_);
std::map reserved;
};
whisky_store store;
{
.TIMES(2)
test_order->fill();
}
}
Is this an improvement
for test readability?

View Slide

132
Working with data
{
std::map stock_);
std::map reserved;
};
whisky_store store;
{
.TIMES(2)
test_order->fill();
}
}
Is this an improvement
for test readability?
I think it is!

View Slide

133
https://www.instagram.com/p/BSCuTygl7eT/
●
Background
●
Adaptation to unit
test framework
●
Make mock member
functions
●
override
●
REQUIRE_CALL
●
Expectation objects
●
Lifetime of
expectation
●
RETURN
●
Sequence control
●
Templated type
●
Wildcard and WITH
●
names
●
ALLOW_CALL
●
TIMES
●
Print custom data
types
●
Named expectations
●
SIDE_EFFECT
●
LR_ prefix
●
FORBID_CALL
●
Callbacks
●
Trompeloeil matchers
●
Writing own matchers
●
Lifetime control
●
Advanced sequence
control

View Slide

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

View Slide

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

View Slide

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

View Slide

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

View Slide

138
Advanced usage
●
parameter to add().
●
quantity.
template
class order
{
public:
...
size_t add(
const article_type& article,
size_t quantity,
std::function = {})
{
return q;
}
...
private:
};

View Slide

139
Advanced usage
●
parameter to add().
●
quantity.
===============================================================================
template
class order
{
public:
...
size_t add(
size_t quantity,
std::function = {})
{
return q;
}
...
private:
};

View Slide

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

View Slide

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

View Slide

142
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

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

View Slide

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

View Slide

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

View Slide

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

View Slide

147
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

148
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

149
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

150
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

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

View Slide

152
whisky_store store;
{
}
callback();
REQUIRE(called);
}
Advanced usage
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
order_test4.cpp:167
...............................................................................
param _2 == nullptr
===============================================================================
So the fix broke another test.
It’s easy to fix, but let’s
think about a bigger picture
for more tests.

View Slide

153
Advanced usage
{
stock_w_reserve(whisky_store& store,
std::map stock_)
, r1{NAMED_ALLOW_CALL(store, reserve(_))
.RETURN(_1.quantity)}
...
, n{NAMED_ALLOW_CALL(store, notify(_,_))
.WITH(_2 != nullptr)}
{
}
std::map stock;
std::map reserved;
std::unique_ptr r1, ... , n;
}

View Slide

154
Advanced usage
{
std::map stock_)
...
, n{NAMED_ALLOW_CALL(store, notify(_,_))
.WITH(_2 != nullptr)}
{
}
std::map stock;
std::map reserved;
}
In most tests, notify() is uninteresting,
so we allow it as long as it follows the
rules (i.e. the function is initialised with
something.)
In other tests, we can set local
FORBID_CALL() or REQUIRE_CALL()
to enforce the rules when necessary.

View Slide

155
Advanced usage
using trompeloeil::ne;
{
std::map stock_)
...
, n{NAMED_ALLOW_CALL(store, notify(_,ne(nullptr)))}
{
}
std::map stock;
std::map reserved;
}
ne, not-equal, here will only match calls to notify
when the 2nd parameter does not compare equal
to nullptr. The other built-in matchers are:
eq – equal to
lt – less than
le – less than or equal to
gt – greater than
ge – greater than or equal to
re – regular expression

View Slide

156
Advanced usage
{
std::map stock_)
...
{
}
std::map stock;
std::map reserved;
}
By default the built-in matchers apply to
any type for which the operation makes
sense.
If there are conflicting overloads, an
explicit type disambiguates.

View Slide

157
{
std::map stock_)
...
{
}
std::map stock;
std::map reserved;
}
Advanced usage
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
order_test4.cpp:169
...............................................................................
param _2 == nullptr
Tried store.notify(_,ne(nullptr)) at order_test4.cpp:73
Expected _2 != nullptr
===============================================================================

View Slide

158
{
std::map stock_)
...
{
}
std::map stock;
std::map reserved;
}
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

159
{
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

160
{
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

161
https://www.instagram.com/p/BR-q9QUhrCz
●
Background
●
Adaptation to unit
test framework
●
Make mock member
functions
●
override
●
REQUIRE_CALL
●
Expectation objects
●
Lifetime of
expectation
●
RETURN
●
Sequence control
●
Templated type
●
Wildcard and WITH
●
names
●
ALLOW_CALL
●
TIMES
●
Print custom data
types
●
Named expectations
●
SIDE_EFFECT
●
LR_ prefix
●
FORBID_CALL
●
Callbacks
●
Trompeloeil
matchers
●
Writing own
matchers
●
Lifetime control
●
Advanced sequence
control

View Slide

162
Matchers
{
std::map stock_)
.WITH(stock[_1.article] >= _1.quantity)
.WITH(stock[_1.article] < _1.quantity)
...}
{ }
std::map stock;
std::map reserved;
std::unique_ptr r1, r2 , n;
}

View Slide

163
Matchers
{
std::map stock_)
...}
{ }
std::map stock;
std::map reserved;
}
Maybe something should
be done about this
repetitive code?

View Slide

164
Matchers
{
std::map stock_)
...}
{ }
std::map stock;
std::map reserved;
}
Maybe something should
be done about this
repetitive code?
Let’s write a matcher!

View Slide

165
Matchers
struct S {
MAKE_MOCK1(func, void(const record&));
};
using inventory = std::map;
TEST_CASE("record with article not in stock fails") {
S s;
inventory stock{{"Talisker", 50}, {"Oban", 20 } };
try {
REQUIRE_CALL(s, func(available_in(stock)));
s.func({"Laphroaig", 1});
FAIL("was wrongly accepted");
}
catch (std::exception& e) {
auto re =
"something something something";
INFO("what() == " << e.what());
REQUIRE(std::regex_search(e.what(), std::regex(re)));
}
}
A new test program for
developing the matcher.

View Slide

166
A mock object
to test run the
matcher on
Matchers
struct S {
};
S s;
try {
}
auto re =
}
}

View Slide

167
Matchers
struct S {
};
S s;
try {
}
auto re =
}
}

View Slide

168
Usage looks good!
Matchers
struct S {
};
S s;
try {
}
auto re =
}
}

View Slide

169
Rely on default reporting
by throwing exception
Matchers
struct S {
};
S s;
try {
}
FAIL("what() == " << e.what());
}
}

View Slide

170
Matchers
struct S {
};
S s;
try {
}
}
}
My standard technique is to deliberately
fail, so I can see the message, until I’m
happy with it, and then encode it in a
regular expression.

View Slide

171
Matchers
struct S {
};
S s;
try {
}
}
}
auto available_in(inventory& container)
{
return trompeloeil::make_matcher(
[](const record& value, const inventory& c) {
},
[](std::ostream& os, const inventory& c) {
os << " in “;
trompeloeil::print(os, c);
},
container
);
}
Predicate function
Data shared between the two above
Failure report function

View Slide

172
Matchers
struct S {
};
S s;
try {
}
}
}
{
return false;
},
os << " in “;
},
std::ref(container)
);
}
Predicate function

View Slide

173
Matchers
struct S {
};
S s;
try {
}
}
}
{
return false;
},
os << " in “;
},
std::ref(container)
);
}

View Slide

174
Matchers
struct S {
};
S s;
try {
}
}
}
{
return false;
},
os << " in “;
},
std::ref(container)
);
}

View Slide

175
Matchers
struct S {
};
S s;
try {
}
}
}
{
return false;
},
os << " in “;
},
std::ref(container)
);
} trompeloeil::print() does a comma
separated member by member print
of anything that has a .begin() and
.end(). It also does element by element
print of std::pair<> and std::tuple<>.
And it does so recursively

View Slide

176
Matchers
struct S {
};
S s;
try {
}
}
}
auto available_in(const inventory& container)
{
return false;
},
os << " in “;
},
container
);
}
-------------------------------------------------------------------------------
record with unknown article fails
-------------------------------------------------------------------------------
matcher_test.cpp:67
...............................................................................
matcher_test.cpp:79: FAILED:
what() ==
No match for call of func with signature void(const record&) with.
param _1 == { article=Laphroaig, quantity=1 }
Tried s.func(available_in(stock)) at matcher_test.cpp:72
Expected _1 in { { Oban, 20 }, { Talisker, 50 } }
===============================================================================
test cases: 1 | 1 failed

View Slide

177
Matchers
struct S {
};
S s;
try {
}
auto re =
".*_1 in \\{ \\{ Oban, 20 \\}, \\{ Talisker, 50 \\} \\}.*";
}
}

View Slide

178
Matchers
struct S {
};
S s;
try {
}
auto re =
".*_1 in \\{ \\{ Oban, 20 \\}, \\{ Talisker, 50 \\} \\}.*";
}
}
===============================================================================
All tests passed (1 assertion in 1 test case)

View Slide

179
Matchers
struct S {
};
TEST_CASE("record with article and quantity in stock is accepted")
{
S s;
s.func({"Talisker", 50});
}

View Slide

180
Matchers
struct S {
};
{
S s;
}
-------------------------------------------------------------------------------
record with article and quantity in stock is accepted
-------------------------------------------------------------------------------
matcher_test.cpp:42
...............................................................................
matcher_test.cpp:42: FAILED:
due to unexpected exception with message:
No match for call of func with signature void(const record&) with.
Tried s.func(available_in(stock)) at matcher_test.cpp:46
Expected _1 in { { Oban, 20 }, { Talisker, 50 } }
===============================================================================

View Slide

181
Matchers
struct S {
};
{
S s;
}
{
return c.find(value.article) != c.end();
},
os << " in “;
},
std::ref(container)
);
}
Make the predicate an actual
check of a condition.

View Slide

182
Matchers
struct S {
};
{
S s;
}
{
return c.find(value.article) != c.end();
},
os << " in “;
},
std::ref(container)
);
}
===============================================================================

View Slide

183
One too many
Matchers
struct S {
};
TEST_CASE("record with quantity exceeding stock fails") {
S s;
try {
s.func({"Oban", 21});
}
auto re =
".*_1 in \\{ \\{ Oban, 20 \\}, \\{ Talisker, 50 \\} \\}.*";
}
}

View Slide

184
Matchers
struct S {
};
S s;
try {
}
auto re =
".*_1 in \\{ \\{ Oban, 20 \\}, \\{ Talisker, 50 \\} \\}.*";
}
}
{
auto i = c.find(value.article);
return i != c.end() && value.quantity <= i->second;
},
os << " in “;
},
std::ref(container)
);
}

View Slide

185
Matchers
struct S {
};
S s;
try {
}
auto re =
".*_1 in \\{ \\{ Oban, 20 \\}, \\{ Talisker, 50 \\} \\}.*";
}
}
{
auto i = c.find(value.article);
return i != c.end() && value.quantity <= i->second;
},
os << " in “;
},
std::ref(container)
);
}
===============================================================================

View Slide

186
Matchers
{
std::map stock_)
, r1{NAMED_ALLOW_CALL(store, reserve(available_in(stock)))
...}
{ }
std::map stock;
std::map reserved;
}

View Slide

187
Matchers
{
std::map stock_)
, r2{NAMED_ALLOW_CALL(store, reserve(!available_in(stock)))
...}
{ }
std::map stock;
std::map reserved;
}
Matchers can be negated using
the logical-not operator (!)

View Slide

188
Matchers
{
std::map stock_)
, r2{NAMED_ALLOW_CALL(store, reserve(!available_in(stock)))
...}
{ }
std::map stock;
std::map reserved;
}
Matchers can be negated using
the logical-not operator (!)

View Slide

189
https://www.instagram.com/p/BR-QInAAqQi
●
Background
●
Adaptation to unit
test framework
●
Make mock member
functions
●
override
●
REQUIRE_CALL
●
Expectation objects
●
Lifetime of
expectation
●
RETURN
●
Sequence control
●
Templated type
●
Wildcard and WITH
●
names
●
ALLOW_CALL
●
TIMES
●
Print custom data
types
●
Named expectations
●
SIDE_EFFECT
●
LR_ prefix
●
FORBID_CALL
●
Callbacks
●
Trompeloeil
matchers
●
Writing own
matchers
●
Lifetime control
●
Advanced sequence
control

View Slide

190
Lifetime management
After having refactored several tests, a new requirement
comes in again.
The order class must accept ownership of the store
instance, and after fill() it must destroy it.

View Slide

191
template
class order
{
public:
order(std::unique_ptr s) : the_store{std::move(s)} {}
~order() {
the_store->cancel({line.first, line.second});
}
auto q = the_store->reserve({article, quantity});
if (q < quantity && cb) the_store->notify(name, cb);
return q;
}
void fill() {
the_store->remove({line.first, line.second});
}
private:
std::unique_ptr the_store;
};

View Slide

192
template
class order
{
public:
~order() {
}
return q;
}
void fill() {
}
private:
};
So far a trivial change with
very minor impact
on the test code.
But how to test the
destruction on fill()?

View Slide

193
Lifetime management
TEST_CASE("store is destroyed after fill")
{
auto store = new trompeloeil::deathwatched;
order test_order{std::unique_ptr(store)};
{
stock_w_reserve s{*store, {{"Talisker", 50},{"Oban", 20}}};
test_order.add("Oban", 5);
}
{
REQUIRE_CALL(*store, remove(_))
.WITH(_1.article == "Oban" && _1.quantity == 5);
...
}
}
A deathwatched object is not
allowed to be destroyed until
we tell it to.
And when we tell it to, it must die.

View Slide

194
No, Mr. Bond,
I expect you to die!
Lifetime management
{
...
}
{
REQUIRE_DESTRUCTION(*store);
test_order.fill();
}
}

View Slide

195
No, Mr. Bond,
Lifetime management
{
...
}
{
test_order.fill();
}
}
In file included from order_test7.cpp:1:0:
/home/bjorn/devel/trompeloeil/trompeloeil.hpp: In instantiation of 'class
trompeloeil::deathwatched > >':
order_test7.cpp:259:33: required from here
/home/bjorn/devel/trompeloeil/trompeloeil.hpp:1878:5: error: static assertion failed:
virtual destructor is a necessity for deathwatched to work
static_assert(std::has_virtual_destructor::value,
^

View Slide

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

View Slide

197
Add virtual destructor
template
struct mock_store {
public:
struct record {
size_t quantity;
};
using callback = std::function;
virtual ~mock_store() = default;
MAKE_MOCK2(notify, void(const article_type&, callback));
};

View Slide

198
No, Mr. Bond,
Working with data
{
...
}
{
test_order.fill();
}
}
-------------------------------------------------------------------------------
store is deleted after fill
-------------------------------------------------------------------------------
order_test6.cpp:263
...............................................................................
with expansion:
false
with message:
failure := "order_test6.cpp:283
Object *store is still alive"
No match for call of cancel with signature void(const record&) with.
terminate called after throwing an instance of 'Catch::TestFailureException'
{Unknown expression after the reported line}
with expansion:
due to a fatal error condition:
SIGABRT - Abort (abnormal termination) signal
===============================================================================
Failure as expected.

View Slide

199
No, Mr. Bond,
Lifetime management
{
...
}
{
test_order.fill();
}
}
template
class order
{
public:
~order() {
}
return q;
}
void fill() {
reserved.clear();
}
private:
};

View Slide

200
No, Mr. Bond,
Lifetime management
{
...
}
{
test_order.fill();
}
}
template
class order
{
public:
~order() {
}
return q;
}
void fill() {
reserved.clear();
the_store.reset();
}
private:
};

View Slide

201
No, Mr. Bond,
Lifetime management
{
...
}
{
test_order.fill();
}
}
template
class order
{
public:
~order() {
}
return q;
}
void fill() {
reserved.clear();
the_store.reset();
}
private:
};
===============================================================================

View Slide

202
Lifetime management
{
...
}
{
trompeloeil::sequence seq_talisker, seq_oban;
.IN_SEQUENCE(seq_talisker);
.WITH(_1.article == "Oban" && _1.quantity == 5)
.IN_SEQUENCE(seq_oban);
REQUIRE_DESTRUCTION(*store)
.IN_SEQUENCE(seq_talisker, seq_oban);
test_order.fill();
}
}
Sequence objects are used to
impose an order between
otherwise unrelated expectations.

View Slide

203
Different sequence objects means
remove() order is indifferent.
Lifetime management
{
...
}
{
test_order.fill();
}
}

View Slide

204
Destruction uses both sequence
objects, so it must be last.
Lifetime management
{
...
}
{
test_order.fill();
}
}

View Slide

205
Lifetime management
{
...
}
{
test_order.fill();
}
}
The sequence objects are
not needed here, though,
because destruction of
a mock objects with
pending expectations
is reported as a violation.

View Slide

206
Lifetime management
{
...
}
{
test_order.fill();
}
}
The sequence objects are
not needed here, though,
because destruction of
a mock objects with
pending expectations
is reported as a violation.
But there are other situations
when sequence control is
absolutely necessary.
Just don’t restrict too much!

View Slide

207
https://www.instagram.com/p/BSV4oxqj3cb
●
Background
●
Adaptation to unit
test framework
●
Make mock member
functions
●
override
●
REQUIRE_CALL
●
Expectation objects
●
Lifetime of
expectation
●
RETURN
●
Sequence control
●
Templated type
●
Wildcard and WITH
●
names
●
ALLOW_CALL
●
TIMES
●
Print custom data
types
●
Named expectations
●
SIDE_EFFECT
●
LR_ prefix
●
FORBID_CALL
●
Callbacks
●
Trompeloeil
matchers
●
Writing own
matchers
●
Lifetime control
●
Advanced
sequence control

View Slide

208

View Slide

209

View Slide

210
Check out some alternative mocking frameworks
Google mock (gmock) https://github.com/google/googletest
Mockator http://mockator.com
FakeIt https://github.com/eranpeer/FakeIt
HippoMocks https://github.com/dascandy/hippomocks

View Slide

211
Björn Fahller
[email protected]
@bjorn_fahller
@rollbear cpplang, swedencpp
Using Trompeloeil

View Slide

212
Writing a type erased matcher
Let’s write a matcher is_key_in() that checks if a value
is a key in a container.

View Slide

213
Let’s write a matcher is_key_in() that checks if a
value is a key in a container.
The matcher should accept any container that has a
.find() member function that returns something
comparable with the return value from .end().

View Slide

214
Let’s write a matcher is_key_in() that checks if a
value is a key in a container.
The matcher should accept any container that has a
.find() member function that returns something
comparable with the return value from .end().
The matcher should accept any value for which the return
value from container.find() != container.end()

View Slide

215
What should this be, that
can match anything?
template
auto is_key_in(Container&& container)
{
return trompeloeil::make_matcher???>(
[](const auto& value, const Container& c) {
},
[](std::ostream& os, const Container& c) {
},
std::forward(container)
);
}

View Slide

216
template
{
},
},
);
}

View Slide

217
template
{
},
os << "to be key in ";
},
);
}

View Slide

218
template
{
return c.find(value) != c.end();
},
},
);
}

View Slide

219
template
{
},
},
);
}
This works as long as there
is only one function with a
matching signature.

View Slide

220
template
{
},
},
);
}
But this causes a compilation error!!!
struct S
{
MAKE_MOCK1(func, void(std::unordered_set>));
MAKE_MOCK1(func, void(int));
};

View Slide

221
template
{
[](const auto& value, const Container& c)
-> decltype(c.find(value) != c.end()) {
},
},
);
}

View Slide

222
template
{
},
},
);
}
Now SFINAE kicks in and unordered_set<> is the only candidate
struct S
{
MAKE_MOCK1(func, void(int));
};

View Slide

223
template
{
},
},
);
}
But what about this?
struct S
{
MAKE_MOCK1(func, void(std::map));
};

View Slide

224
template typename Container>
{
},
},
);
}
Now call can be disambiguated using
is_key_in>(...)

View Slide

225
template typename Container>
{
using c_type = typename decltype(std::ref(container))::type;
[](const auto& value, const c_type& c)
},
[](std::ostream& os, const c_type& c) {
},
);
}

View Slide

226
Björn Fahller
[email protected]
@bjorn_fahller
@rollbear cpplang, swedencpp
Using Trompeloeil

View Slide

Using Trompeloeil - a mocking framework for modern C++

Using Trompeloeil - a mocking framework for modern C++

Björn Fahller

More Decks by Björn Fahller

Other Decks in Programming

Featured

Transcript