/ 47

Friendship in Service of Testing

Gábor Márton, martongabesz@gmail.comZoltán Porkoláb, gsd@elte.hu

1

/ 47

Agenda

• Introduction, principals

• Case study

• Making the example better

• Vision

2

/ 47

Functional Programming

std::size_t fibonacci(std::size_t);ASSERT(fibonacci(0u) == 0u);ASSERT(fibonacci(1u) == 1u);ASSERT(fibonacci(2u) == 1u);ASSERT(fibonacci(3u) == 2u);...ASSERT(fibonacci(7u) == 13u);ASSERT(fibonacci(8u) == 21u);

• Immutability

• Thread safe

• Easy to test!

3

/ 47

OOP

• States

• Dependencies (e.g Strategy pattern)

• Bad patterns -> Side Effects (singleton)

4

/ 47

OOP - SOLID

• Loosely coupled system

• Interface (ptr or ref)

5

/ 47

UUT/SUT

dependencydependencyReal

Test Double

MockStubFake

Often very heavy, e.g. requires network

Inter-face

Dependency Replacement - DR

Inter-face

6

/ 47

Creational Patterns• Factory Method

• Abstract Factory

• Service Locator

• Dependency Injection (DI)

• Extra Constructor / Setter

• DI != Dependency Replacement

7

/ 47

Creational Patterns• Factory Method

• Abstract Factory

• Service Locator

• Dependency Injection (DI)

• Extra Constructor / Setter

• DI != Dependency Replacement

• Who owns the object?

• Can we access the object from the test?

7

/ 47

OOP - Testing• Replace the dependency

• Access the dependency (private)

• To exercise them

• Make assertions on them

8

/ 47

Real

Often very heavy, e.g. requires network

UUT/SUT

dependencydependency

9

/ 47

Real

Often very heavy, e.g. requires network

No explicit interface (runtime or ct) What are the options for testing in C++?

UUT/SUT

dependencydependency

9

/ 4710

/ 47

• Linker

• Header only code?

• Templates? (extern template)

• Requires build system support

10

/ 47

• Linker

• Header only code?

• Templates? (extern template)

• Requires build system support

• Preprocessor

• Black magic

10

/ 47

• Linker

• Header only code?

• Templates? (extern template)

• Requires build system support

• Preprocessor

• Black magic

• Refactor

• Add that interface

10

/ 47

Seams

• Link seam

• Preprocessor seam

• Object seam

• Compile seam

With a seam we can alter behaviour in our program without editing the original unit under test.

11

/ 47

Seams

• Link seam

• Preprocessor seam

• Object seam

• Compile seam

With a seam we can alter behaviour in our program without editing the original unit under test.

The enabling point of a seam is the place where we can

make the decision to use one behaviour or another.

11

/ 47

class Entity {

public:

int process(int i) { int x = …; return x * 42; }

private: …

}; void test1() { Entity e;

ASSERT(e.process(1) == 42);

}

Case study

12

/ 47

class Entity {

public:

int process(int i) { int x = …; return x * 42; }

private: …

}; void test1() { Entity e;

ASSERT(e.process(1) == 42);

}

Case study

“Can we make it work in a multithreaded

environment?”

12

/ 47

class Entity {

public:

int process(int i) {

if(m.try_lock()) { int x = …; m.unlock(); return x * 42; }

else { …; return 0; }

}

private:

std::mutex m; …};

13

/ 47

class Entity {

public:

int process(int i) {

if(m.try_lock()) { int x = …; m.unlock(); return x * 42; }

else { …; return 0; }

}

private:

std::mutex m; …};

13

How to test the new logic?

/ 47

struct Mutex { virtual void lock() = 0;

virtual void unlock() = 0;

virtual bool try_lock() = 0;

};

struct RealMutex : Mutex { … };

struct StubMutex : Mutex { bool try_lock_result = false;

virtual bool try_lock() override {

return try_lock_result;

} … };

14

/ 47

struct Mutex { virtual void lock() = 0;

virtual void unlock() = 0;

virtual bool try_lock() = 0;

};

struct RealMutex : Mutex { … };

struct StubMutex : Mutex { bool try_lock_result = false;

virtual bool try_lock() override {

return try_lock_result;

} … };

virtual ~Mutex() {}

14

/ 47

class Entity {

public:

Entity(Mutex& m) : m(m) {} int process(int i) { … }

private: Mutex& m;

};

Object Seam

15

/ 47

class Entity {

public:

Entity(Mutex& m) : m(m) {} int process(int i) { … }

private: Mutex& m;

};

• Ex. of Object Seam: Entity + Mutex • Enabling point: constructor

Object Seam

15

/ 47

void realWorldClient() {

RealMutex m;

Entity e(m);

// Real usage of e

}

void testClient() {

// test setup

StubMutex m;

Entity e(m);

m.try_lock_result = false;

ASSERT(e.process(1) == 0);

m.try_lock_result = true;

ASSERT(e.process(1) == 42);

}16

/ 47

class Entity {

public:

Entity(Mutex& m) : m(m) {} int process(int i) { … }

private: Mutex& m;

};

Feels so unnatural!

17

/ 47

class Entity {

public:

Entity(Mutex& m) : m(m) {} int process(int i) { … }

private: Mutex& m;

}; Ownership?

Feels so unnatural!

17

/ 47

class Entity {

public:

Entity(Mutex& m) : m(m) {} int process(int i) { … }

private: Mutex& m;

}; Ownership?Extra ctor/setter

Feels so unnatural!

17

/ 47

class Entity {

public:

Entity(Mutex& m) : m(m) {} int process(int i) { … }

private: Mutex& m;

}; Ownership?Extra ctor/setterExtra interface

Virtual functions Cache locality?

Feels so unnatural!

17

/ 47

class Entity {

public:

Entity(Mutex& m) : m(m) {} int process(int i) { … }

private: Mutex& m;

}; Ownership?Extra ctor/setterExtra interface

Virtual functions Cache locality?

Pointer semantics Cache locality?

Feels so unnatural!

17

/ 47

class Entity {

public:

Entity(Mutex& m) : m(m) {} int process(int i) { … }

private: Mutex& m;

}; Ownership?Extra ctor/setterExtra interface

Virtual functions Cache locality?

Pointer semantics Cache locality?

Type erasure? Can’t spare the virtual calls

Feels so unnatural!

17

/ 47

Ownershipclass Entity { public: Entity(std::unique_ptr<Mutex> m) : m(std::move(m)) {} int process(int i) { if(m−>try_lock()) { … } else { … }

} Mutex& getMutex() { return *m.get(); } private: std::unique_ptr<Mutex> m; }; void testClient() { Entity e(std::make_unique<StubMutex>()); auto& m = e.getMutex(); // assertions …

}18

/ 47

Ownership OK As before: Extra ctor, virtuals, pointer semantics, etc Extra getter

19

/ 47

template <typename Mutex> class Entity { public:

int process(int i) { … }

// Use only from tests Mutex& getMutex() { return m; }

private:

Mutex m;

};

Compile Seam

20

/ 47

void realWorldClient() { Entity<std::mutex> e; // Real usage of e

}void testClient() { struct StubMutex{ void lock() {} void unlock() {} bool try_lock_result = false; bool try_lock() { return try_lock_result; } }; Entity<StubMutex> e; auto& m = e.getMutex(); // assertions …

} 21

/ 47

void realWorldClient() { Entity<std::mutex> e; // Real usage of e

}void testClient() { struct StubMutex{ void lock() {} void unlock() {} bool try_lock_result = false; bool try_lock() { return try_lock_result; } }; Entity<StubMutex> e; auto& m = e.getMutex(); // assertions …

}

• No inheritance • No virtual functions

21

/ 47

Ownership

Locality

No Extra ctor/setter

Extra Interface (compile time)

Extra Getter

Extra Compilation Time

22

/ 47

Extra Compilation Time -Combine with Pimpl

// detail/Entity.hpp

namespace detail {

// as before

template <typename Mutex>class Entity { … };

} // detail

23

/ 47

// Entity.hppclass Entity {public: Entity(); ~Entity(); int process(int i);private: struct Impl; std::unique_ptr<Impl> pimpl;};

24

/ 47

// Entity.cpp

#include “detail/Entity.hpp” using RealEntity = detail::Entity<std::mutex>;struct Entity::Impl : RealEntity { // delegate the consturctors using RealEntity::RealEntity;};

Entity::Entity() : pimpl(std::make_unique<Impl>()) {}Entity::~Entity() = default;int Entity::process(int i) { return pimpl->process(i); } 25

/ 47

// Client.cpp#include “Entity.hpp”void realWorldClient() { Entity e; // Real usage of e}

// Test.cpp #include “detail/Entity.hpp”void testClient() { struct StubMutex { … }; detail::Entity<StubMutex> e; // Test code as before}

26

/ 47

No extra compile time

But at least two compiles if detail::Entity changes

Entity.cpp

Test.cpp

Extra complexity

Compile Seam + Pimpl

27

/ 47

template <typename Mutex> class Entity {public: Mutex& getMutex() { return m; } int process(int i) { … }private: Mutex m;};

class Entity {

public:

int process(int i) { … }

private:

std::mutex m;};

28

/ 47

template <typename Mutex> class Entity {public: Mutex& getMutex() { return m; } int process(int i) { … }private: Mutex m;};

class Entity {

public:

int process(int i) { … }

private:

std::mutex m;}; Intrusive

28

/ 47

Eliminate the Extra Gettertemplate <typename Mutex> class Entity { …#ifdef TEST Mutex& getMutex() { return m; }#endif …};

29

/ 47

Eliminate the Extra Gettertemplate <typename Mutex> class Entity { …#ifdef TEST Mutex& getMutex() { return m; }#endif …};

Worse

Readability

Maintainability29

/ 47

#define private public#include "Entity.hpp"#undef private// Test code comes from here

30

/ 47

#define private public#include "Entity.hpp"#undef private// Test code comes from here

Undefined behaviour

The order of allocation of non-static data members with different access control is unspecified

Danger, everything included from Entity.hpp is now public

class X {public: int x;private: int y;public: int z;};

xzy

xyz

31

/ 47

Eliminate the Extra Getter - Access via a Friend Function

template <typename Mutex> class Entity {public:+ friend Mutex& testFriend(Entity &e); int process(int i) { … }private: Mutex m;};

32

/ 47

// Test.cpp struct StubMutex { … };

StubMutex& testFriend(Entity<StubMutex>& e){ return e.m; }

void testClient() { Entity<StubMutex> e; auto &m = testFriend(e); // assertions …}

33

/ 47

Eliminate the Extra Getter - Access via a Friend Class

template <typename Mutex> class Entity {public:+ friend struct EntityTestFriend; int process(int i) { … }private: Mutex m;};

34

/ 47

// Test.cpp struct StubMutex { … };

struct EntityTestFriend { template<typename Mutex> static auto& getMutex(Entity<Mutex>& e) { return e.m; }}; void testClient() { Entity<StubMutex> e; auto &m = EntityTestFriend::getMutex(e); // assertions …}

35

/ 47

class EntityTestFriend { template<typename Mutex> static auto& getMutex(Entity<Mutex>& e) { return e.m; }+ friend void test_try_lock_succeeds();+ friend void test_try_lock_fails();}; void test_try_lock_succeeds() { Entity<StubMutex> e; auto &m = EntityTestFriend::getMutex(e); // assertion …}// …

36

/ 47

class EntityTestFriend { template<typename Mutex> static auto& getMutex(Entity<Mutex>& e) { return e.m; }+ friend void test_try_lock_succeeds();+ friend void test_try_lock_fails();}; void test_try_lock_succeeds() { Entity<StubMutex> e; auto &m = EntityTestFriend::getMutex(e); // assertion …}// … • Attorney <—> EntityTestFriend

• Client <—> Entity

36

/ 47

template <typename Mutex> class Entity {public: friend struct EntityTestFriend; int process(int i) { … }private: Mutex m;};

class Entity {

public:

int process(int i) { … }

private:

std::mutex m;};

37

/ 47

template <typename Mutex> class Entity {public: friend struct EntityTestFriend; int process(int i) { … }private: Mutex m;};

class Entity {

public:

int process(int i) { … }

private:

std::mutex m;}; Intrusive

37

/ 47

Eliminate the Extra Getter - Non-intrusive Access

template <typename Mutex> class Entity {public: int process(int i) { … }private: Mutex m;};

38

/ 47

// Test.cpp struct StubMutex { … };

ACCESS_PRIVATE_FIELD( Entity<StubMutex>, StubMutex, m)

void test_try_lock_fails() { Entity<StubMutex> e; auto& m = access_private::m(e); m.try_lock_result = false; ASSERT(e.process(1) == 0);}

39

/ 47

Access a private static member

class A { static int i;};int A::i = 42;

40

/ 47

Access a private static member

class A { static int i;};int A::i = 42;

template struct private_access<&A::i>;

40

/ 47

Access a private static member

class A { static int i;};int A::i = 42;

template struct private_access<&A::i>;

template <int* PtrValue> struct private_access { friend int* get() { return PtrValue; }};

40

/ 47

Access a private static member

class A { static int i;};int A::i = 42;

template struct private_access<&A::i>;

template <int* PtrValue> struct private_access { friend int* get() { return PtrValue; }};

int* get();

40

/ 47

Access a private static member

class A { static int i;};int A::i = 42;

template struct private_access<&A::i>;

template <int* PtrValue> struct private_access { friend int* get() { return PtrValue; }};

int* get();

void usage() { int* i = get(); assert(*i == 42);}

40

/ 47

Access a private non-static memberclass A { int i = 42;};

41

/ 47

Access a private non-static memberclass A { int i = 42;};

template struct private_access<&A::i>;

41

/ 47

Access a private non-static memberclass A { int i = 42;};

template struct private_access<&A::i>;

using PtrType = int A::*;template<PtrType PtrValue> struct private_access { friend PtrType get() { return PtrValue; }};

41

/ 47

Access a private non-static memberclass A { int i = 42;};

template struct private_access<&A::i>;

using PtrType = int A::*;template<PtrType PtrValue> struct private_access { friend PtrType get() { return PtrValue; }};

PtrType get();

41

/ 47

Access a private non-static memberclass A { int i = 42;};

template struct private_access<&A::i>;

using PtrType = int A::*;template<PtrType PtrValue> struct private_access { friend PtrType get() { return PtrValue; }};

PtrType get();

void usage() { A a; PtrType ip = get(); int& i = a.*ip; assert(i == 42);} 41

/ 47

Can access private member fields, functions

Can’t access private types

Can’t access private ctor/dtor

Link error with in-class defined private static const

42

/ 4743

/ 47

Eliminate the Extra Getter - Out-of-class Friend

template <typename Mutex> class Entity { public: int process(int i) { … } private: Mutex m;};

44

/ 47

Eliminate the Extra Getter - Out-of-class Friend

template <typename Mutex> class Entity { public: int process(int i) { … } private: Mutex m;};

// Test.cpp friend for(Entity<StubMutex>) void testClient() { Entity<StubMutex> e; auto& m = e.m; // access the private // assertions …}

44

/ 47

Clear intentions, self describing code

No cumbersome accessor patterns

Can access all private (types, ctor, …)

Proof-of-concept implementation in clang

Encapsulation (?)

A good language should prevent non-intuitive, accidental failure

“friend for” cannot be accidental

45

/ 47

Visionclass Entity { … };

46

/ 47

Visionclass Entity { … };

// Test.cpp void testClient() { using EntityUnderTest = test::ReplaceMemberType<Entity, std::mutex, StubMutex>; EntityUnderTest e; auto& m = e.get<StubMutex>(); // assertions … }

46

/ 47

Thank you!• Gábor Márton

martongabesz@gmail.com

• https://github.com/martong/access_private

• https://github.com/martong/clang/tree/out-of-class_friend_attr

• Questions?

47