Testing & Debugging; Templates I; C++17 Library Additions

Transcription

1 Testing & Debugging; Templates I; C++17 Library Additions PV264 Advanced Programming in C++ Nikola Beneš Jan Mrázek Vladimír Štill Faculty of Informatics, Masaryk University spring 2018 PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

2 Three Basic Questions of Programming Is my program well-written? Will someone else be able to read (maintain, refactor) it? Will I be able to read it (tomorrow, next week, next year)? Is my program correct? Does it do what it is supposed to? What is it actually supposed to do? Is my program efficient? time, memory consumption, other resources consumption (data, energy,... ) PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

3 Correctness How to approach correctness? Testing testing formal verification (automatic/semi-automatic/manual) code inspection... important part of development process levels of testing unit testing integration testing system testing... many approaches and frameworks our focus here: unit testing using the Catch2 framework PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

4 Using Catch2 Catch2 (C++ Automated Test Cases in Headers) advantages: easy to use no dependencies, one header file readable test cases (support for Behaviour-Driven Development) arbitrary strings as names test cases divided into independent sections use standard C++ operators for comparison PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

5 Using Catch2 Sections #define CATCH_CONFIG_MAIN // provide main() #include "catch.hpp" #include <vector> TEST_CASE("Vector is initialised as empty") { vector<int> vec; REQUIRE(vec.size() == 0); } PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

6 Using Catch2 Sections TEST_CASE("Vector size and capacity") { vector<int> vec; vec.push_back(1); vec.push_back(2); auto size = vec.size(); REQUIRE(size == 2); SECTION("push_back increases size") { vec.push_back(3); REQUIRE(vec.size() > size); } SECTION("erase decreases size") { vec.erase(vec.begin()); REQUIRE(vec.size() < size); } } PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

7 Using Catch2 Sections for each (leaf) SECTION the TEST_CASE is executed from the start alternative to the traditional text fixture approach (setup/teardown) Catch2 also supports fixtures, see docs SECTIONs can be arbitrarily nested failure in parent section prevents nested sections from running BDD (Behaviour-Driven Development) SCENARIO, GIVEN, WHEN, THEN SCENARIO("Adding an element to a vector") { GIVEN("A vector with no elements") { vector<int> vec; WHEN("an element is added via push_back") { vec.push_back(0); THEN("the size becomes 1") { REQUIRE(vec.size() == 1); } } } } PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

8 Using Catch2 Asserts & Logs REQUIRE, CHECK, REQUIRE_FALSE, CHECK_FALSE assert condition (CHECK: execution continues even after failure) REQUIRE_THROWS, REQUIRE_NOTHROW, CHECK_THROWS,... assert that an expression throws/does not throw an expression INFO, WARN, FAIL logging CAPTURE log the value of a variable PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

9 Using Catch2 Useful Information command-line parameters which test(s) to run output format (junit, XML,... ) configuration via macros, own main() Recommended practice one main source file with nothing but the main function (possibly generated by Catch2) #define CATCH_CONFIG_MAIN #include "catch.hpp" // end of file other source files for tests PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

10 Debugging PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

11 Debugging Tests fail, now what? tracing ( printf debugging ) logging using debuggers using other useful tools Recommendation try to find a minimal example where the problem occurs code bisection bugs are sometimes caused by bad memory management don t forget about valgrind and similar tools to be able to employ debuggers: compile without optimisation compile with debug information (-g) PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

12 Debuggers Typical Debugger Functions pause at specified breakpoints line of code, condition, exception thrown/caught, signals,... evaluate expressions step through program (modify program state) Our Focus gdb (The GNU Debugger) command-line tool many graphical front-ends PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

13 Using gdb Basic commands: help run start the debugged program list list specified function or line break set breakpoint catch set catchpoint (exception breakpoint) info show information about the debugged program info args, info registers, info breakpoints,... step step program, steps into functions next step program, steps over function calls stepi, nexti step by instructions, not lines of code print evaluate expression examine display contents of memory address disp evaluate expression each time the program stops continue continue running (after breakpoint) kill stop execution of the program PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

14 Using gdb Stack commands: backtrace print backtrace of stack frames up, down, frame, select-frame select stack frame finish run until current stack frame returns info locals, info frame Executing code at runtime: set var = value change the value of a variable call func() call a function Watchpoints: watch var watch changes (writes) of a variable rwatch var watch reads of a variable awatch var watch both reads and writes PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

15 gdb front-ends cgdb terminal-based front-end for gdb (uses the curses library) displays the source code above the gdb session module add cgdb on faculty computers Other front-ends: see PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

16 Assembler Assembly Language (symbolic machine code) low-level; closest to machine code commands machine code instructions Why do we want to know about it? debugging computer security examine optimisation done by compiler sometimes it is good to know what s under the hood Our focus here: brief overview; reading assembly, not writing it PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

17 Assembler Tools Disassemble clang++ -S, g++ -S, etc. gdb disassemble x/10i address (such as $rip) (print, disp) set disassemble-next-line on objdump -d Show raw bytes hexdump -C xxd Compiler explorer: PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

18 Assembler Notation Intel AT&T operands in order dest, src mov rax, rbx moves from rbx to rax add rax, 0x1f adds 0x1f to rax memory indexing [base + index*scale + disp] mov eax, [rbx + rcx*4 + 0x10] operands in order src, dest mov %rbx, %rax add $0x1f, %rax memory indexing disp(base, index, scale) movl 0x10(%rbx, %rcx, 4), %eax size indicated in the instruction mnemonic movb, movw, movl, movq (1, 2, 4, and 8 bytes) immediate values with $, registers with % PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

19 Assembler notation How to use the Intel syntax? clang++ -S -masm=intel objdump -d -M intel gdb set disassembly-flavor intel PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

20 x86(-64) Architecture Registers instruction pointer: ip (16 bit), eip (32 bit), rip (64 bit) stack pointer: sp (16 bit), esp (32 bit), rsp (64 bit) general purpose: ax, bx, cx, dx (eax, rax,... ) lower 8 bits: al, bl, cl, dl source/destination: si, di (esi, rsi,... ) stack frame base pointer: bp (ebp, rbp) 64 bit general purpose: r8, r9,..., r15 low 32 bits: r8d,... low 16 bits: r8w,... low 8 bits: r8b,... floating-point (80 bit) registers st0,..., st7 XMM 128 bit registers xmm0,..., xmm15 PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

21 x86(-64) Architecture Stack memory area given by OS to programs LIFO data structure; x86 stack grows towards lower addresses esp (rsp) points to the top of the stack main use: return address, function arguments, local variables, temporary storage PUSH value decrements esp (rsp) and then stores the given value at the memory address given by (the new value of) esp (rsp) POP register copies the value from the memory address given by esp (rsp) into the given register and then increments esp (rsp) PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

22 x86(-64) Architecture How do function calls work? parameters are stored somewhere (see below) call address push address of next instruction on stack jump to address ret (return from function) pops address from stack and jumps to it Calling conventions 32bit: many different possibilities cdecl: arguments passed on the stack in reverse order 64bit: two main approaches (Microsoft x64, System V AMD64) both use registers to pass (some of) the arguments registers used also depend on type (integers, floats) of arguments PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

23 x86(-64) Architecture Function frames (standard entry/exit sequence) at the beginning of a function: push rbp mov rbp, rsp sub rsp, 0x10 (allocate 16 bytes on stack for local variables) rbp is the base frame pointer local values referenced as [rbp + 0x08],... note that [rbp] holds the value of the previous rbp at the end of a function: mov rsp, rbp pop rbp Note: Optimisations (frame pointer omission optimisation) may eliminate this. (-f[no-]omit-frame-pointer) PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

24 x86(-64) Instructions Move instruction MOV copy value from src to dest Arithmetic and logic instructions ADD, SUB, MUL,... AND, OR, XOR,... Test instructions CMP performs SUB; does not save the result, only sets flags TEST similar to CMP, performs AND Jump instructions JMP unconditional jump Jxx conditional jump, reacts to flags JZ jump if zero JBE jump if below or equal... PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

25 Optimisations What can the compiler optimise for us? speed space obvious rearranging memory accesses inline functions tail recursion (sometimes even non-tail recursion) loop unrolling... and much more collapse common code constant propagation PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

26 Templates Motivation Syntax generic programming; polymorphism metaprogramming; compile-time programming template < parameters > parameters can be: types: typename or class values: integers, enums, (pointers, references) templates: more about this later parameters can have default values template <typename T, typename U = bool, size_t N = 10> PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

27 Templates What can be templated? functions classes type aliases (using) since C++11 variables since C++14 template<typename T> const T pi = T( ); int main() { std::cout.precision(17); std::cout << pi<double> << '\n'; std::cout << pi<float> << '\n'; std::cout << pi<int> << '\n'; } PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

28 Templates Template Instantiation templates instantiated at compile time all templated functions/classes in header files methods of templated classes only instantiated if actually used (why?) the previous point is not completely true; why? virtual methods template <typename T> struct X { T t; void f() { t.f(); } void g() { t.g(); } }; struct A { void f() {} }; int main() { X<int> xi; X<A> xa; xa.f(); } PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

29 Template Deduction until C++14 only for templated functions in C++17 also for classes in initialization template arguments may be deduced from the usage template <typename To, typename From> To lexical_cast(const From& val) { std::stringstream str; str << val; To result; str >> result; return result; } int main() { double d = lexical_cast<double, int>(17); int x = lexical_cast<int>("17"); std::string s = lexical_cast(10); // ERROR: why? } PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

30 Template Deduction template <typename T> void foo1(t t); // value parameter template <typename T> void foo2(t& t); // reference parameter Value parameters arrays and functions decay into pointers int a[7]; foo1(a); // T is deduced to be int* Reference parameters no decay int a[7]; foo2(a); // T is deduced to be int[7] // works as if foo2 was declared as // void foo(int (&t) [7]); // reference to array PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

31 Template Deduction template <typename T> void foo1(t t); template <typename T> void foo2(t& t); template <typename T> void foo3(const T& t); what is T deduced as? int x; const int answer = 42; foo1(x); foo1(answer); foo2(x); foo2(answer); foo3(x); foo3(answer); int, int, int, const int, int, int PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

32 Class Template Deduction in C++17, we can finally write things like these: we need std::make_pair etc. no more std::pair my_pair{ 1, "hello" }; std::vector some_ints{ 1, 2, 7, 42, 17, -1, 0 }; those things can also work with user-defined classes template <typename T> class Wrapper { T value; public: Wrapper(T val) : value(std::move(val)) {} }; Wrapper x = 3; // x is Wrapper<int> note: does not work with unique_ptr PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

33 Class Template Deduction: Deduction Guides sometimes the compiler might be unable to deduce what we want sometimes we may want a different deduction behaviour we can change the deduction behaviour using deduction guides template<typename Iterator> MyContainer(Iterator, Iterator) -> MyContainer<typename Iterator::value_type>; // also non-templated ones Wrapper(const char*) -> Wrapper<std::string>; Wrapper w{ "hello" }; // w is now Wrapper<std::string> see template_argument_deduction PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

34 C++17 Library Additions std::optional motivation: return either a value or an information that there is none no good default value for a type (or too expensive) other languages: Maybe (Haskell), nullable types (C#),... old solutions: std::pair<t, bool> std::unique_ptr<t> (needs heap allocation) std::optional<t> allocates space for a value of type T locally (on stack if local variable) pointer-like access (operators *, ->); std::nullopt PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

35 C++17 Library Additions std::variant motivation: type-safe union other languages: Either (Haskell), Rust enums,... std::variant<int, std::string> v = 42; // v contains int std::get<int>(v); // returns 42 std::get<0>(v); // also works std::get<std::string>(v); // throws v.index(); // returns 0 std::get_if<int>(&v); // returns pointer to int std::get_if<std::string>(&v); // returns nullptr PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

36 C++17 Library Additions std::variant visitor access struct Visitor { void operator()(int val) const { std::cout << "got int: " << val << '\n'; } void operator()(std::string val) const { std::cout << "got string: \"" << val << "\"\n"; } }; int main() { std::variant<int, std::string> v{ "hello" }; std::visit(visitor, v); } PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

37 C++17 Library Additions std::string_view motivation: lightweight (non-owning) string wrapper with reference semantics eliminate temporary std::string (needs allocation) take substrings in a cheap way (without allocation) void do_something(const std::string& str) { // do something read-only with str } do_something("what is this?"); void do_something_with_subst(const std::string& str) { auto substr = str.substr(1, 7); // this always creates a copy // even if I only want to read the substring } PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38

38 C++17 Library Additions std::string_view older solutions: std::pair<const char*, size_t> std::string_view does exactly that! with a nicer interface can be created from std::string, const char* libraries can add their own conversions (QString) how to use: always pass by value make sure that the original string is still alive (think of std::string_view as a reference) do read-only string operations take substrings using substr PV264: Testing & Debugging; Templates I; C++17 Library Additions spring / 38