[G_PRO] Basis Programmeren en OO Programmeren
DigitAP
  • Welkom
  • Inleiding
    • Benodigdheden
    • Afspraken code
    • Afspraken oefeningen
    • Nuttige extras
    • Dankwoord
    • Mee helpen?
  • Semester 1: Programming Principles
    • H1: Werken met Visual Studio
      • Introductie tot C#
      • Visual Studio en .NET Core installeren
      • Een C# project maken in Visual Studio
      • Fouten in je code
      • Je eerste stappen in C#
      • Input/Output: ReadLine/WriteLine
      • Kleuren in Console
      • Oefeningen
    • H2: Variabelen en datatypes
      • De syntaxis van C#
      • Datatypes
      • Variabelen
      • Expressies en operators
      • Oefeningen
    • H3: Strings en hun methoden
      • Strings
      • Strings samenvoegen
      • Omzetten van en naar strings
      • Functionaliteit van strings
      • Oefeningen
    • H4: Beslissingen
      • Beslissingen intro
      • Enkelvoudige booleaanse expressies
      • If, else, else if
      • Samengestelde booleaanse expressies
      • Scope van variabelen
      • Switch
      • Oefeningen
    • H5: Loops
      • Loops intro
      • While en Do While
      • For
      • Debuggen
      • Oefeningen
    • H6: Arrays
      • Array principes
      • Alternatieve syntax
      • Werken met arrays
      • Defaultwaarden
      • List<T>
      • Oefeningen
    • H7: Methoden
      • Methoden intro
      • Parameters
      • Return waarden
      • Geavanceerde methoden
      • Oefeningen
    • Intermezzo: TextCell
    • H8: Numerieke data
      • De Math klasse
      • Random
      • Casting en conversie
      • Oefeningen
    • H9: Meerdimensionaal werken
      • N-dimensionale arrays
      • Geneste iteratie
      • Oefeningen
    • H10: Gevorderde tekstverwerking
      • Voorstelling van tekst
      • Interpolatie met formattering
      • Werken met arrays van strings
      • Input en output van tekstbestanden
      • Oefeningen
    • Afsluiter: TextCell2D
  • Semester 2 : OOP
    • H10: Klassen en objecten
      • OOP Intro
      • Klassen en objecten aanmaken
      • DateTime: leren werken met objecten
      • Enumeraties: nog een eigen datatype
      • Klassen en objecten weergeven deel 1
      • Attributen
      • Methoden
      • Access modifiers
      • Properties
      • Oefeningen
    • H11: Objecten (al dan niet) aanmaken
      • Constructors
      • Spelen met strings
      • Oefeningen
    • H12: Geheugenmanagement bij klassen
      • value en reference met eigen objecten
      • nullable value types
      • NullReference exception
      • Oefeningen
    • H13: Datastructuren
      • Foreach en var
      • List
      • Dictionary
      • Immutable datastructuren
      • Verdere datastructuren
      • Oefeningen
    • H14: Overerving
      • Overerving intro
      • Virtual en override
      • Abstract
      • Constructors bij overerving
      • Oefeningen
    • H15: Geavanceerde overerving
      • protected access modifier
      • Base keyword
      • System.Object
      • Oefeningen
    • H16: Exception handling
      • Werken met exceptions
      • Zelf uitzonderingen maken
      • Wanneer exceptions en handling gebruiken
      • Oefeningen
    • H17: Polymorfisme en interfaces
      • Polymorfisme
      • Polymorfisme in de praktijk
      • Interfaces
      • Losse koppeling
      • Oefeningen
    • H18: Testing
      • Intro Testing
      • Wat is Unit Testing
      • Waarom Unit Testing?
      • Wanneer Unit Testing?
      • Schrijven van een unit test: AAA methode
      • Eerste voorbeeld: Sum
      • Assert
      • Oefening even of oneven getal
      • TestInitialize en DataRows
      • Oefening BMI
      • Exception testing
      • Oefening BMI exception
      • Oefening SchoolAdmin test null-waarden en TestCleanup
      • Oefening SchoolAdmin test equals
      • Oefening SchoolAdmin test cursus zoeken met id
      • Dependencies bij Unit Testing
      • Mocking
      • Oefeningen Mocking
      • Test Driven Development
      • Class Library
      • Oefeningen TDD
    • H19: SOLID
      • Single Responsibility Principle (SRP)
      • Open/Closed Principle (OCP)
      • Liskov Substitution Principle (LSP)
      • Interface Segregation Principle (ISP)
      • Dependency Inversion Principle (DIP)
  • Appendix
    • Visual Studio Tips & Tricks
    • Ea-ict coding guidelines
    • Oefeningen kerkhof
  • Semester 1 appendix
    • Nice to know stuff
      • Out en Ref parameters
      • Jagged arrays
    • All-In-Projecten
      • Overzicht
      • Console Matrix
      • Ascii filmpjes maken met loops
      • Ascii filmpjes maken met methoden
      • Fun with methods: een verhaalgenerator
      • Tekst-gebaseerd Maze game
      • Conway game of life
  • Semester 2 appendix
    • Operator overloading
    • Object Initializer Syntax
    • Compositie en aggregatie
    • Nice to know stuff
      • Klassen herbruiken
      • Expression bodied members
    • All-In-Projecten
      • Overzicht
      • OO Textbased Game
      • War Simulator
      • Map Maker
      • Magic The Gathering API
      • SchoolAdmin
  • Pro (geen leerstof en/of in opbouw)
    • Bitwise operators
    • Generics en collections
      • Generics methoden en types
      • Generic classes en constraints
      • Collections
      • Labo-oefeningen
    • Events
      • Events
      • Chat server
    • Software engineering
      • SOLID
Powered by GitBook
On this page
  • Wat is TDD
  • De drie wetten van TDD (Robert C. Martin - Uncle Bob)
  • Het TDD proces
  • Argumenten tegen TDD
  • Argumenten voor TDD
  • Blind beginnen
  • Instructievideo's
Export as PDF
  1. Semester 2 : OOP
  2. H18: Testing

Test Driven Development

PreviousOefeningen MockingNextClass Library

Last updated 1 year ago

Wat is TDD

TDD is een manier van werken in software ontwikkeling (mehodiek/discipline) die er op is gericht om foutarme (minder fouten) en flexibele software te ontwikkelen . D.m.v. TDD gaan de testen de duwende factor zijn bij het ontwikkelen van je code. Dat betekent dat je niet begint met de code te schrijven, je begint met de testen te schrijven. Nadien schrijf je de code die er voor gaat zorgen dat de test succesvol wordt doorlopen.De puristen onder de aanhangers van TDD zullen nooit ook maar één lijn code schrijven alvorens de test ervoor geschreven is. TDD gaat eigenlijk niet over testen, het gaat over het ontwerp en ontwikkeling van software. D.m.v. het gebruik van TDD zal je applicatie groeien in functionaliteit, maar zonder complexiteit toe te voegen.

De drie wetten van TDD (Robert C. Martin - Uncle Bob)

  1. Het is niet toegelaten om productie code te schrijven, behalve om een gefaalde test te doen slagen

  2. Het is niet toegelaten om meer testen te schrijven dan om de testen te doen falen, inclusief het falen van compilatie

  3. Het is niet toegelaten meer code te schrijven dan nodig om de gefaalde test te doen slagen

Het TDD proces

Het TDD proces is algemeen bekend als het 'Red-Green-Refactor' proces. TDD is absoluut een voorbeeld van iteratieve ontwikkeling waar je stap voor stap de nodige functionaliteit aan je applicatie toevoegt. Puristen zullen steeds starten met een eerste test ItExists waarin ze de ontwikkel- en testomgeving testen. Na die eerste test wordt voor het eerste stukje functionaliteit een test geschreven en wordt de test uitgevoerd. De test faalt (Red). Vervolgens wordt de productiecode geschreven tot de test slaagt (Green). Op het einde van elke iteratie is het zaak om te kijken of je code niet kan worden 'opgekuist'. Je bekijkt dus of het niet beter zou zijn om bepaalde stukken van je code en/of je data te herwerken, anders te structureren, … Merk op dat je geschreven testen je daarbij helpen, je hoeft niet bang te zijn dat je wijzigingen nieuwe fouten zullen introduceren. Alle testen moeten slagen alvorens je een nieuw stukje functionaliteit kan toevoegen

Argumenten tegen TDD

  1. Testen vraagt tijd - Geld

  2. Testen is moeilijk (het schrijven van de juiste testen)

  3. Wanneer de functionaliteit wijzigt moeten ook de testen worden aangepast

Argumenten voor TDD

  1. Vermindert het werk van manuele testen

  2. Reduceert het aantal fouten

  3. Garandeert een zeker niveau van correctheid

  4. Neemt de angst voor refactoring weg

  5. Zorgt voor een beter architectuur

  6. Zorgt voor snellere ontwikkeling

Blind beginnen

Het is aangewezen om op voorhand het lijstje met tests dat je denkt nodig te hebben al even te noteren

Waarom?

  • Je denkt op voorhand al eens na over de specificatie / requirements ipv direct beginnen code te typen. Aangezien TDD niet helpt bij het designen van je software kan het handig zijn om toch al een beetje een idee te hebben waar je naartoe wil werken. Zeker voor complexere functionaliteiten kan het helpen om hierin een collega te betrekken.

  • Je hebt dan al een plan van aanpak waar je kan beginnen met testen, het lijstje kan uiteraard altijd geüpdatet worden als je nog extra cases bedenkt tijdens het implementeren.

Instructievideo's

Hieronder vinden jullie twee video's over TDD gemaakt door Jeremy Clark. Het is de bedoeling dat jullie deze video's bekijken en in parallel met Jeremy de oefeningen maken. Opgelet, Jeremy gebruikt als test framework Nunit. Je kan dit ook downloaden langs NuGet (zoals Moq), zorg dat je dan de laatste versie gebruikt.

Bekijk ook het volgende stukje "Class Library"