Friendship in Service of Testing

Size: px

Start display at page:

Download "Friendship in Service of Testing"

Brian Reeves
5 years ago
Views:

1 Friendship in Service of Testing Gábor Márton, Zoltán Porkoláb, 1 / 47

2 Agenda Introduction, principals Case study Making the example better Vision 2 / 47

3 Functional Programming Immutability Thread safe Easy to test! 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); 3 / 47

4 OOP States Dependencies (e.g Strategy pattern) Bad patterns -> Side Effects (singleton) 4 / 47

5 OOP - SOLID Loosely coupled system Interface (ptr or ref) 5 / 47

6 Often very heavy, e.g. requires network dependency Inter-face dependency Inter-face Real UUT/SUT Test Double Fake Stub Mock Dependency Replacement - DR 6 / 47

7 Creational Patterns Factory Method Abstract Factory Service Locator Dependency Injection (DI) Extra Constructor / Setter DI!= Dependency Replacement 7 / 47

8 Creational Patterns Factory Method Abstract Factory Service Locator Who owns the object? Can we access the object from the test? Dependency Injection (DI) Extra Constructor / Setter DI!= Dependency Replacement 7 / 47

9 OOP - Testing Replace the dependency Access the dependency (private) To exercise them Make assertions on them 8 / 47

10 Often very heavy, e.g. requires network dependency dependency Real UUT/SUT 9 / 47

11 Often very heavy, e.g. requires network dependency dependency Real UUT/SUT No explicit interface (runtime or ct) What are the options for testing in C++? 9 / 47

12 10 / 47

13 Linker Header only code? Templates? (extern template) Requires build system support 10 / 47

14 Linker Header only code? Templates? (extern template) Requires build system support Preprocessor Black magic 10 / 47

15 Linker Header only code? Templates? (extern template) Requires build system support Preprocessor Black magic Refactor Add that interface 10 / 47

16 Seams With a seam we can alter behaviour in our program without editing the original unit under test. Link seam Preprocessor seam Object seam Compile seam 11 / 47

17 Seams With a seam we can alter behaviour in our program without editing the original unit under test. Link seam Preprocessor seam Object seam The enabling point of a seam is the place where we can make the decision to use one behaviour or another. Compile seam 11 / 47

18 Case study class Entity { public: int process(int i) { int x = ; return x * 42; } private: void test1() { Entity e; } ASSERT(e.process(1) == 42); 12 / 47

19 Case study class Entity { public: int process(int i) { int x = ; return x * 42; } private: void test1() { Entity e; } ASSERT(e.process(1) == 42); 12 / 47 Can we make it work in a multithreaded environment?

20 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

21 class Entity { public: int process(int i) { if(m.try_lock()) { int x = ; m.unlock(); return x * 42; } else { ; return 0; } } private: How to test the new logic? std::mutex m; 13 / 47

22 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

23 struct Mutex { virtual void lock() = 0; virtual void unlock() = 0; virtual bool try_lock() = 0; virtual ~Mutex() {} struct RealMutex : Mutex { struct StubMutex : Mutex { bool try_lock_result = false; virtual bool try_lock() override { } return try_lock_result; 14 / 47

24 Object Seam class Entity { public: Entity(Mutex& m) : m(m) {} int process(int i) { } private: Mutex& m; 15 / 47

25 Object Seam class Entity { public: Entity(Mutex& m) : m(m) {} int process(int i) { } private: Mutex& m; Ex. of Object Seam: Entity + Mutex Enabling point: constructor 15 / 47

26 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

27 class Entity { public: Entity(Mutex& m) : m(m) {} int process(int i) { } private: Mutex& m; Feels so unnatural! 17 / 47

28 class Entity { public: Entity(Mutex& m) : m(m) {} int process(int i) { } private: Mutex& m; Ownership? Feels so unnatural! 17 / 47

29 class Entity { public: Entity(Mutex& m) : m(m) {} int process(int i) { } private: Mutex& m; Ownership? Extra ctor/setter Feels so unnatural! 17 / 47

30 class Entity { public: Entity(Mutex& m) : m(m) {} int process(int i) { } private: Mutex& m; Ownership? Extra ctor/setter Extra interface Feels so unnatural! Virtual functions Cache locality? 17 / 47

31 class Entity { public: Entity(Mutex& m) : m(m) {} int process(int i) { } private: Mutex& m; Ownership? Extra ctor/setter Extra interface Feels so unnatural! Virtual functions Cache locality? Pointer semantics Cache locality? 17 / 47

32 class Entity { public: Entity(Mutex& m) : m(m) {} int process(int i) { } private: Mutex& m; Ownership? Extra ctor/setter Extra interface Virtual functions Cache locality? Pointer semantics Cache locality? Type erasure? Feels so unnatural! Can t spare the virtual calls 17 / 47

33 Ownership class 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

34 Ownership OK As before: Extra ctor, virtuals, pointer semantics, etc Extra getter 19 / 47

35 Compile Seam template <typename Mutex> class Entity { public: int process(int i) { } // Use only from tests Mutex& getmutex() { return m; } private: Mutex m; 20 / 47

36 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

37 void realworldclient() { Entity<std::mutex> e; // Real usage of e } void testclient() { struct StubMutex{ No inheritance void lock() {} No virtual functions void unlock() {} bool try_lock_result = false; bool try_lock() { return try_lock_result; } Entity<StubMutex> e; auto& m = e.getmutex(); // assertions } 21 / 47

38 Ownership Locality No Extra ctor/setter Extra Interface (compile time) Extra Getter Extra Compilation Time 22 / 47

39 Extra Compilation Time - Combine with Pimpl // detail/entity.hpp namespace detail { // as before template <typename Mutex> class Entity { } // detail 23 / 47

40 // Entity.hpp class Entity { public: Entity(); ~Entity(); int process(int i); private: struct Impl; std::unique_ptr<impl> pimpl; 24 / 47

41 // 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

42 // 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

43 Compile Seam + Pimpl No extra compile time But at least two compiles if detail::entity changes Entity.cpp Test.cpp Extra complexity 27 / 47

44 class Entity { public: int process(int i) { } private: std::mutex m; template <typename Mutex> class Entity { public: Mutex& getmutex() { return m; } int process(int i) { } private: Mutex m; 28 / 47

45 class Entity { public: int process(int i) { } private: std::mutex m; Intrusive template <typename Mutex> class Entity { public: Mutex& getmutex() { return m; } int process(int i) { } private: Mutex m; 28 / 47

46 Eliminate the Extra Getter template <typename Mutex> class Entity { #ifdef TEST Mutex& getmutex() { return m; } #endif 29 / 47

47 Eliminate the Extra Getter template <typename Mutex> class Entity { #ifdef TEST Mutex& getmutex() { return m; } #endif Worse Readability Maintainability 29 / 47

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

49 #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 class X { public: int x; private: int y; public: int z; x z y x y z Danger, everything included from Entity.hpp is now public 31 / 47

50 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

51 // Test.cpp struct StubMutex { StubMutex& testfriend(entity<stubmutex>& e){ } return e.m; void testclient() { Entity<StubMutex> e; auto &m = testfriend(e); // assertions } 33 / 47

52 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

53 // 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

54 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

55 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

56 class Entity { public: int process(int i) { } private: std::mutex m; template <typename Mutex> class Entity { public: friend struct EntityTestFriend; int process(int i) { } private: Mutex m; 37 / 47

57 class Entity { public: int process(int i) { } private: std::mutex m; Intrusive template <typename Mutex> class Entity { public: friend struct EntityTestFriend; int process(int i) { } private: Mutex m; 37 / 47

58 Eliminate the Extra Getter - Non-intrusive Access template <typename Mutex> class Entity { public: int process(int i) { } private: Mutex m; 38 / 47

59 // 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

60 class A { static int i; int A::i = 42; Access a private static member 40 / 47

61 class A { static int i; int A::i = 42; Access a private static member template struct private_access<&a::i>; 40 / 47

62 class A { static int i; int A::i = 42; Access a private static member template <int* PtrValue> struct private_access { friend int* get() { return PtrValue; } template struct private_access<&a::i>; 40 / 47

63 class A { static int i; int A::i = 42; Access a private static member template <int* PtrValue> struct private_access { friend int* get() { return PtrValue; } int* get(); template struct private_access<&a::i>; 40 / 47

64 class A { static int i; int A::i = 42; Access a private static member template <int* PtrValue> struct private_access { friend int* get() { return PtrValue; } int* get(); template struct private_access<&a::i>; void usage() { int* i = get(); assert(*i == 42); } 40 / 47

65 Access a private non-static member class A { int i = 42; 41 / 47

66 Access a private non-static member class A { int i = 42; template struct private_access<&a::i>; 41 / 47

67 Access a private non-static member class A { int i = 42; using PtrType = int A::*; template<ptrtype PtrValue> struct private_access { friend PtrType get() { return PtrValue; } template struct private_access<&a::i>; 41 / 47

68 Access a private non-static member class A { int i = 42; using PtrType = int A::*; template<ptrtype PtrValue> struct private_access { friend PtrType get() { return PtrValue; } PtrType get(); template struct private_access<&a::i>; 41 / 47

69 Access a private non-static member class A { int i = 42; using PtrType = int A::*; template<ptrtype PtrValue> struct private_access { friend PtrType get() { return PtrValue; } PtrType get(); template struct private_access<&a::i>; void usage() { A a; PtrType ip = get(); int& i = a.*ip; assert(i == 42); } 41 / 47

70 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 / 47

71 43 / 47

72 Eliminate the Extra Getter - Out-of-class Friend template <typename Mutex> class Entity { public: int process(int i) { } private: Mutex m; 44 / 47

73 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

74 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

75 Vision class Entity { 46 / 47

76 Vision class Entity { // Test.cpp void testclient() { using EntityUnderTest = test::replacemembertype<entity, std::mutex, StubMutex>; EntityUnderTest e; auto& m = e.get<stubmutex>(); // assertions } 46 / 47

77 Thank you! Gábor Márton Questions? 47 / 47

Unit Testing in C++ with Compiler Instrumentation and Friends

Acta Cybernetica 23 (2017) 659 686. Unit Testing in C++ with Compiler Instrumentation and Friends Gábor Márton a and Zoltán Porkoláb b Abstract In C++, test code is often interwoven with the unit we want