O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Testgetriebene Entwicklung mit C++

Book Description

  • endlich ein TDD-Buch für C++-Entwickler !* mit vielen Codebeispielen * lockerer Schreibstil

Table of Contents

  1. Cover
  2. Titel
  3. Impressum
  4. Geleitwort
  5. Einleitung
  6. 1 Einführung
    1. 1.1 Setup
    2. 1.2 Die Beispiele
    3. 1.3 C++-Compiler
      1. 1.3.1 Ubuntu
      2. 1.3.2 OS X
      3. 1.3.3 Windows
    4. 1.4 CMake
    5. 1.5 Google Mock
      1. 1.5.1 Google Mock installieren
      2. 1.5.2 Ein Main-Programm zum Ausführen von Google-Mock-Tests erstellen
    6. 1.6 CppUTest
      1. 1.6.1 CppUTest installieren
      2. 1.6.2 Ein Main-Programm zum Ausführen von CppUTest-Tests erstellen
    7. 1.7 libcurl
    8. 1.8 JsonCpp
    9. 1.9 rlog
    10. 1.10 Boost
    11. 1.11 Beispiele erstellen und Tests ausführen
    12. 1.12 Teardown
  7. 2 Testgetriebene Entwicklung: Ein erstes Beispiel
    1. 2.1 Setup
    2. 2.2 Der Soundex-Algorithmus
    3. 2.3 Erste Schritte
    4. 2.4 Unsauberen Code korrigieren
    5. 2.5 Schrittweises Vorgehen
    6. 2.6 Fixtures
    7. 2.7 Denkprozesse bei TDD
    8. 2.8 Testen und testgetriebene Entwicklung im Vergleich
    9. 2.9 Was wäre, wenn ...?
    10. 2.10 Eins nach dem anderen!
    11. 2.11 Die Länge einschränken
    12. 2.12 Vokale fallen lassen
    13. 2.13 Tests übersichtlich gestalten
    14. 2.14 Querdenken beim Testen
    15. 2.15 Zurück zum Thema
    16. 2.16 Refactoring zu Funktionen mit nur je einer Aufgabe
    17. 2.17 Der letzte Schliff
    18. 2.18 Welche Tests fehlen noch?
    19. 2.19 Unsere Lösung
    20. 2.20 Die Soundex-Klasse
    21. 2.21 Teardown
  8. 3 Testgetriebene Entwicklung: Grundlagen
    1. 3.1 Setup
    2. 3.2 Unit Tests und Grundlagen von TDD
      1. 3.2.1 Gliederung und Ausführung von Unit Tests
      2. 3.2.2 Einheiten für die testgetriebene Entwicklung
    3. 3.3 Der TDD-Zyklus: Rot – Grün – Refactoring
      1. 3.3.1 Denkprozesse bei TDD
    4. 3.4 Die drei Regeln von TDD
    5. 3.5 Verfrühtes Bestehen von Tests
      1. 3.5.1 Der falsche Test für den Code
      2. 3.5.2 Der falsche Code für den Test
      3. 3.5.3 Ungünstige Testspezifikation
      4. 3.5.4 Ungültige Annahmen über das System
      5. 3.5.5 Suboptimale Testreihenfolge
      6. 3.5.6 Verlinkter Produktionscode
      7. 3.5.7 Übercodierung
      8. 3.5.8 Tests zur Absicherung
      9. 3.5.9 Innehalten und Nachdenken
    6. 3.6 Die richtige Einstellung für den erfolgreichen Einsatz von TDD
      1. 3.6.1 Schrittweises Vorgehen
      2. 3.6.2 Verhalten statt Methoden testen
      3. 3.6.3 Tests zur Beschreibung des Verhaltens verwenden
      4. 3.6.4 Möglichst einfach halten
      5. 3.6.5 Sich an den Zyklus halten
    7. 3.7 Techniken für den Erfolg
      1. 3.7.1 Was ist der nächste Test?
      2. 3.7.2 Eine Obergrenze von 10 Minuten
      3. 3.7.3 Fehler
      4. 3.7.4 Tests deaktivieren
    8. 3.8 Teardown
  9. 4 Tests konstruieren
    1. 4.1 Setup
    2. 4.2 Aufbau
      1. 4.2.1 Gliederung in Dateien
      2. 4.2.2 Fixtures
      3. 4.2.3 Setup und Teardown
      4. 4.2.4 »Arrange-Act-Assert« / »Given-When-Then«
    3. 4.3 Schnelle Tests, langsame Tests, Filter und Suiten
      1. 4.3.1 Eine Teilmenge der Tests ausführen
    4. 4.4 Assertions (Zusicherungen)
      1. 4.4.1 Zusicherungen in klassischer Form
      2. 4.4.2 Hamcrest-Assertions
      3. 4.4.3 Die richtige Zusicherung auswählen
      4. 4.4.4 Fließkommazahlen vergleichen
      5. 4.4.5 Ausnahmebasierte Tests
    5. 4.5 Private Daten untersuchen
      1. 4.5.1 Private Daten
      2. 4.5.2 Privates Verhalten
    6. 4.6 Testen und testgetriebene Entwicklung im Vergleich: Parametrisierte Tests und andere Spielereien
      1. 4.6.1 Parametrisierte Tests
      2. 4.6.2 Kommentare in Tests
    7. 4.7 Teardown
  10. 5 Testdoubles
    1. 5.1 Setup
    2. 5.2 Herausforderungen durch Abhängigkeiten
    3. 5.3 Testdoubles
    4. 5.4 Ein selbst gebautes Testdouble
    5. 5.5 Die Testabstraktion bei der Verwendung von Testdoubles verbessern
    6. 5.6 Mock-Frameworks verwenden
      1. 5.6.1 Eine Ableitung definieren
      2. 5.6.2 Erwartungen einrichten
      3. 5.6.3 NiceMock und StrictMock
      4. 5.6.4 Reihenfolge in Mocks
      5. 5.6.5 Intelligente Funktionen von Mock-Frameworks
      6. 5.6.6 Mock-Fehler beheben
      7. 5.6.7 Ein oder zwei Tests?
    7. 5.7 Testdoubles platzieren
      1. 5.7.1 Überschreiben der Factory-Methode oder der Get-Methode
      2. 5.7.2 Einführung über die Factory
      3. 5.7.3 Einführung über Template-Parameter
      4. 5.7.4 Injektionsframeworks
    8. 5.8 Ein anderes Vorgehen beim Design
      1. 5.8.1 Kohäsion und Kopplung
      2. 5.8.2 Private Abhängigkeiten verschieben
    9. 5.9 Strategien zur Verwendung von Testdoubles
      1. 5.9.1 Das Design ausprobieren
      2. 5.9.2 Verschiedene Denkschulen zur Verwendung von Mocks
      3. 5.9.3 Empfehlungen zum Einsatz von Testdoubles
    10. 5.10 Verschiedenes zum Thema Testdoubles
      1. 5.10.1 Die richtigen Bezeichnungen
      2. 5.10.2 Der richtige Platz
      3. 5.10.3 Auswirkungen von Vtables auf die Performance
      4. 5.10.4 Mocks für konkrete Klassen
    11. 5.11 Teardown
  11. 6 Inkrementelles Design
    1. 6.1 Setup
    2. 6.2 Einfaches Design
      1. 6.2.1 Die Kosten der Redundanz
      2. 6.2.2 Der Portfoliomanager
      3. 6.2.3 Einfache Redundanz im Portfoliomanager
      4. 6.2.4 Können wir die inkrementelle Vorgehensweise wirklich beibehalten?
      5. 6.2.5 Noch mehr Redundanz
      6. 6.2.6 Vorteile kleiner Methoden
      7. 6.2.7 Letzte Hand an den Funktionsumfang legen
      8. 6.2.8 Inkrementelles Design leicht gemacht
    3. 6.3 Was ist mit dem Design im Voraus?
      1. 6.3.1 Und wann geht es hier wirklich um Design?
      2. 6.3.2 Wo kommt es zu Konflikten zwischen einfachem und klassischem Design?
    4. 6.4 Hindernisse für das Refactoring
    5. 6.5 Teardown
  12. 7 Qualitativ hochwertige Tests
    1. 7.1 Setup
    2. 7.2 Tests nach dem FIRST-Prinzip
      1. 7.2.1 Fast (schnell)
      2. 7.2.2 Isolated (isoliert)
      3. 7.2.3 Repeatable (wiederholbar)
      4. 7.2.4 Self-Verifying (sich selbst überprüfend)
      5. 7.2.5 Timely (rechtzeitig)
    3. 7.3 Eine Zusicherung pro Test
    4. 7.4 Testabstraktion
      1. 7.4.1 Aufgeblähte Konstruktion
      2. 7.4.2 Irrelevante Einzelheiten
      3. 7.4.3 Fehlende Abstraktion
      4. 7.4.4 Mehrere Zusicherungen
      5. 7.4.5 Irrelevante Daten
      6. 7.4.6 Überflüssiger Testcode
    5. 7.5 Teardown
  13. 8 Herausforderungen durch Legacy-Code
    1. 8.1 Setup
    2. 8.2 Legacy-Code
    3. 8.3 Kernsätze
    4. 8.4 Die Altanwendung
    5. 8.5 Die Denkweise der testgetriebenen Entwicklung
    6. 8.6 Sicheres Refactoring zur Unterstützung von Tests
    7. 8.7 Tests zur Beschreibung des vorhandenen Verhaltens hinzufügen
    8. 8.8 Ablenkungen durch die Realitäten des vorhandenen Codes
    9. 8.9 Ein Testdouble für rlog erstellen
    10. 8.10 Testgetriebene Änderungen
    11. 8.11 Eine neue Story
    12. 8.12 Schnellere Tests finden
    13. 8.13 Mondo Extracto
    14. 8.14 Verwendung einer Membervariablen
    15. 8.15 Verwendung eines Mocks
    16. 8.16 Alternative Injektionstechniken
    17. 8.17 Umfassende Änderungen mit der Mikado-Methode
    18. 8.18 Die Mikado-Methode im Überblick
    19. 8.19 Methoden mit Mikado verschieben
    20. 8.20 Weitere Überlegungen zur Mikado-Methode
    21. 8.21 Lohnt sich der Aufwand?
    22. 8.22 Teardown
  14. 9 TDD für Threads
    1. 9.1 Setup
    2. 9.2 Grundprinzipien für die testgetriebene Thread-Entwicklung
    3. 9.3 GeoServer
    4. 9.4 Performance-Anforderungen
    5. 9.5 Eine asynchrone Lösung gestalten
    6. 9.6 Dies ist immer noch einfaches TDD
    7. 9.7 »Einfädeln«
    8. 9.8 Probleme der Parallelverarbeitung offenlegen
    9. 9.9 Client-Threads im Test erstellen
    10. 9.10 Mehrere Threads in ThreadPool erstellen
    11. 9.11 Zurück zu GeoServer
    12. 9.12 Teardown
  15. 10 Weitere Aspekte von TDD
    1. 10.1 Setup
    2. 10.2 TDD und die Performance
      1. 10.2.1 Eine Teststrategie zur Performance-Optimierung
      2. 10.2.2 Relative Performance-Tests auf Unit-Ebene
      3. 10.2.3 Den GeoServer-Code optimieren
      4. 10.2.4 Die Klasse TestTimer
      5. 10.2.5 Auswirkungen kleiner Funktionen auf die Performance
      6. 10.2.6 Empfehlungen
    3. 10.3 Unit Tests, Integrationstests und Akzeptanztests
      1. 10.3.1 Welcher Zusammenhang besteht zwischen TDD und Akzeptanztests?
      2. 10.3.2 Vom Entwickler definierte Integrationstests
      3. 10.3.3 Überlappungen zwischen TDD und ATDD
    4. 10.4 Transformation Priority Premise (TPP)
      1. 10.4.1 Die Transformationen
      2. 10.4.2 Triangulation
      3. 10.4.3 Die Testliste durchsuchen
    5. 10.5 Zusicherungen zuerst schreiben
      1. 10.5.1 »Assert-Act-Arrange«?
      2. 10.5.2 Beispiele an erster Stelle oder spätestens an zweiter
    6. 10.6 Teardown
  16. 11 Wachstum und Pflege von TDD
    1. 11.1 Setup
    2. 11.2 Laien TDD erklären
      1. 11.2.1 TD... wie bitte?
      2. 11.2.2 Forschung über TDD
    3. 11.3 Die Todesspirale schlechter Tests (»SCUMmy-Kreislauf«)
    4. 11.4 Pair Programming
      1. 11.4.1 Regeln für die Bildung von Paaren
      2. 11.4.2 Pair Programming und TDD
      3. 11.4.3 Rotation der Paare
    5. 11.5 Katas und Dojos
      1. 11.5.1 Katas auf TDD anwenden
      2. 11.5.2 Dojos
    6. 11.6 Metriken zur Codeabdeckung wirkungsvoll anwenden
    7. 11.7 Kontinuierliche Integration
    8. 11.8 Teamstandards für TDD aufstellen
    9. 11.9 Mit der Community auf dem Laufenden bleiben
      1. 11.9.1 Tests lesen
      2. 11.9.2 Blogs und Foren
    10. 11.10 Teardown
  17. A Unit-Test-Frameworks im Vergleich
    1. A.1 Setup
    2. A.2 Funktionen von TDD-Unit-Test-Frameworks
    3. A.3 Hinweise zu Google Mock
    4. A.4 Hinweise zu CppUTest
    5. A.5 Andere Frameworks für Unit Tests
    6. A.6 Teardown
  18. B Code-Kata: Umrechner für römische Zahlen
    1. B.1 Setup
    2. B.2 Los geht’s!
      1. B.2.1 Eins, zwei, drei, ...
      2. B.2.2 Zehn!
      3. B.2.3 Beinahe-Redundanzen ausmerzen
      4. B.2.4 Der letzte Schliff
    3. B.3 Übung macht den Meister
    4. B.4 Teardown
  19. Literaturverzeichnis
  20. Index
  21. Fußnoten