[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
Export as PDF
  1. Semester 2 : OOP
  2. H18: Testing

Dependencies bij Unit Testing

We bouwen een spel waarbij je een getal moet raden van 1 tot 6 (we werpen een virtuele dobbelsteen). Kan je het getal exact raden dan krijg je 2 punten. Gok je eentje hoger of lager dan krijg je 1 punt. In de andere gevallen krijg je geen punten.

1. We bouwen in Visual Studio 2022 een nieuwe console applicatie met de naam UnitTestingDependencies

2. We hebben een klasse nodig die een willekeurig getal terug kan geven van 1 tot 6. Dit is onze virtuele dobbelsteen. We voege een nieuwe klasse Die toe aan ons project en implementeren deze als volgt:

public class Die
{
    private static Random random = new Random();

    public int Roll()
    {
        return random.Next(6) + 1;
    }
}

3. Nu we een dobbelsteen hebben kunnen we ons spel implementeren. Dit spel zal gebruik maken van de dobbelsteen. We voegen een nieuwe klasse NumberGame toe aan ons project en implementeren deze als volgt:


public class NumberGame
{
    private Die die; 
    public NumberGame()
    {
        this.die = new Die();
    }

    public int RateGuess(int guess)
    {
        int result = die.Roll();
        if (result == guess)
        {
            return 2;
        }
        if (result - 1 == guess || result + 1 == guess)
        {
            return 1;
        }
        return 0;
    }
}

4. We kunnen nu onze Main Methode implementeren zodat we een werkend programma krijgen:

public class Program
{
    static void Main(string[] args)
    {
        var numberGame = new NumberGame();
        int score = numberGame.RateGuess(5);
        Console.WriteLine($"Uw score: {score}");
    }
}

We hebben nu een werkend programma

5. Nu we een werkend programma hebben wil ik ook zeker zijn dat dit correct werkt, en in de toekomst ook correct zal blijven werken. Ik wil een unit test maken voor de RateGuess Methode van de NumberGame klasse. Ik wil volgende zaken testen:

  1. Als je het getal juist kan raden geeft de methode 2 terug

  2. Als je eentje hoger of lager gokt geeft de methode 1 terug

  3. Als je fout gokt geeft deze methode 0 terug

6. We implementeren onze test: Creëer een nieuw test project met de naam UnitTestingDependencies.Tests (vergeet niet de referenties toe te voegen). Hernoem de naam van de klasse UnitTest1 door NumberGameTests. Vervang de standaard test methode door een test methode met de naam RateGuess_Returns_2_When_Guess_Is_Correct

7. We doen nu een poging om deze test te implementeren door onderstaande code toe te voegen:

[TestMethod]
public void RateGuess_Returns_2_When_Guess_Is_Correct()
{
    var numberGame = new NumberGame();
    int result = numberGame.RateGuess(5);
    Assert.AreEqual(2, result);
}

Deze test zal soms werken, als 5 toevallig het juiste getal is. Maar 5 kansen op 6 zal deze test fout lopen. Er is met andere woorden een factor in mijn test die ik zelf niet in de hand heb. NumberGame heeft een dependency met Die en deze zal altijd een willekeurig getal teruggeven. We zullen onze code eerst moeten aanpassen om deze degelijk te kunnen testen. We zullen zien dat we hiermee ook de kwaliteit van onze code zullen verbeteren. Als je code niet testbaar is dan is ze in de meeste gevallen ook niet goed.

PreviousOefening SchoolAdmin test cursus zoeken met idNextMocking

Last updated 1 year ago