[NDC{Oslo}] Using Trompeloeil - a mocking framework for modern C++

1
Trompeloeil NDC Oslo 2017 – Björn Fahller
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
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

5
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

6
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

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
●
...
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

8
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

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

View Slide

10
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

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

View Slide

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

View Slide

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

View Slide

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

View Slide

15
#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

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’
^
Full error message from
g++ 5.4

View Slide

17
#include
struct my_mock
{
};

View Slide

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

View Slide

19
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

20
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

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

View Slide

22
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

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

View Slide

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

View Slide

25
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

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

View Slide

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

View Slide

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

View Slide

29
Set up expectation
for call
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
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

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

View Slide

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

View Slide

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

View Slide

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

View Slide

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

View Slide

37
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

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");
^~~~~~~~~~~~~
Full error message from
g++ 6.2

View Slide

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

View Slide

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

View Slide

41
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

42
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

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:
};
===============================================================================
test cases: 1 | 1 passed
assertions: - none -

View Slide

44
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

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

View Slide

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

View Slide

47
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

48
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

49
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
assertions: 1 | 1 failed

View Slide

50
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

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
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);
}
}
Templatise the
order class too.

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("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

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

View Slide

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

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

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

View Slide

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

View Slide

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

View Slide

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

View Slide

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

View Slide

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

View Slide

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

View Slide

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

View Slide

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

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

View Slide

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

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

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

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

View Slide

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

View Slide

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

View Slide

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

View Slide

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

View Slide

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

View Slide

102
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

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

View Slide

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

View Slide

105
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

106
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

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

View Slide

108
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

109
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

110
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

111
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

112
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

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

View Slide

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

View Slide

115
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

116
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

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

View Slide

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

View Slide

119
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

120
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

121
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

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

View Slide

123
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

124
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

125
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

126
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

127
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

128
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

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

View Slide

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

View Slide

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

View Slide

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

View Slide

133
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

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

View Slide

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

View Slide

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

View Slide

137
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

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

View Slide

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

View Slide

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

View Slide

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

View Slide

142
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

143
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

144
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

145
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

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

View Slide

147
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

148
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

149
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

150
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

151
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

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

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

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

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

156

View Slide

157

View Slide

158
Björn Fahller
https://github.com/rollbear/trompeloeil
[email protected]
@bjorn_fahller
@rollbear cpplang, swedencpp
Using Trompeloeil

View Slide

[NDC{Oslo}] Using Trompeloeil - a mocking framework for modern C++

[NDC{Oslo}] Using Trompeloeil - a mocking framework for modern C++

Björn Fahller

More Decks by Björn Fahller

Other Decks in Programming

Featured

Transcript