[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

Eerste voorbeeld: Sum

PreviousSchrijven van een unit test: AAA methodeNextAssert

Last updated 1 year ago

Visual Studio 2022 voorziet tools om unit tests te maken en deze te automatiseren. We bouwen in enkele stappen een kleine console applicatie in Visual Studio 2022 en maken hier een unit test voor.

1. Maak in Visual Studio een nieuwe console applicatie aan met de naam TestingCalculator

2. Voeg aan deze applicatie een nieuwe klasse toe met de naam Calculator

3. We voegen in deze klasse onderstaande methode toe

namespace TestingCalculator
{
    internal class Calculator
    {
        public int Sum(int a, int b)
        {
            return 0;
        }
    }
}

4. Deze methode zullen we gebruiken om 2 getallen op te tellen. Zoals je kan zien is deze methode nog niet uitgewerkt en geeft deze steeds 0 terug. Voorlopig laten we dit zo. We zullen eerst een test maken voor deze methode. Deze test zal falen. Daarna implementeren we de juiste logica in deze methode en laten we de test opnieuw lopen. Deze zal nu wel correct lopen. Deze manier van werken waarbij we eerst de test maken en dan pas de logica implementeren noemen we Test Driven Development of TDD.

5. Klik nu met je rechter muisknop op je solution en klik op Add > New Project…

6. Selecteer MSTest Test Project (voor C#), klik op Next, kies als project naam UnitTesting en klik op Next, selecteer .NET 6.0 (of 7.0) en klik op Create

  1. We krijgen nu onderstaande klasse:

namespace UnitTesting
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethod1()
        {
        }
    }
}

8. Het UnitTesting project refereert naar klassen uit het project TestingCalculator. We leggen dat vast in de dependencies. Klik rechts op Dependencies, kies Add Project Reference en selecteer TestingCalculator.

  1. Wijzig de code zoals in het onderstaande voorbeeld:

namespace UnitTesting
{
    [TestClass]
    public class CalculatorTest
    {
        [TestMethod]
        public void SumTest()
        {
            Assert.Fail();
        }
    }
}

10. Rechter klik nu op SumTest en klik op "Run Tests" (Ctrl+R, T)

11. Visual Studio toont nu de Test Explorer. We zien hier dat er één test is uitgevoerd en dat deze test faalde; zoals weergegeven in onderstaande afbeelding. Je kan de test explorer ook steeds openen via View > Test Explorer.

12. Deze test faalde omdat in deze test Assert.Fail() staat.

13. We implementeren deze test door onderstaande code toe te voegen. Merk op dat er een using is bijgevoegd en vergeet ook niet om de klasse Calculator public te maken.

Internal

Internal wil zeggen: de klasse/methode gedraagt zich als public zolang we in hetzelfde project aan het werken zijn. Alles daar buiten ziet de klasse/methode als private.

Voorheen was dit geen probleem omdat we steeds aan het werken waren binnen hetzelfde project. Maar om unit tests te gebruiken moeten we over 2 (of meer) projecten werken.

using TestingCalculator;

namespace UnitTesting
{
    [TestClass]
    public class CalculatorTest
    {
        [TestMethod]
        public void SumTest()
        {
            Calculator calculator = new Calculator();  // Maak een nieuwe calculator instantie
            int a = 2;                          // Waarde voor parameter a
            int b = 3;                          // Waarde voor parameter b
            int expected = 5;                   // Verwacht resultaat
            int result = calculator.Sum(a, b);  // Sum methode aanroepen
            Assert.AreEqual(expected, result);  // Testen of resultaat gelijk is aan verwachte waarde 
        }
    }
}

14. We laten de test opnieuw lopen. We krijgen nu het onderstaande resultaat.

15. Zoals je kan zien is het verwacht resultaat 5 (2 + 3) maar is het resultaat van de Sum methode 0. We moeten deze methode nog implementeren in onze calculator klasse. We werken deze als volgt uit.

namespace TestingCalculator
{
    public class Calculator
    {
        public int Sum(int a, int b)
        {
            return a + b;
        }
    }
}

16. Als we de test nu opnieuw uitvoeren krijgen we het onderstaande resultaat

We kunnen deze test in de toekomst steeds blijven uitvoeren. Als onze applicatie in de toekomst complexer zal worden, zijn we toch zeker dat dit stukje code blijft werken. Als er iemand het + teken per vergissing zou vervangen door een - teken zal deze test falen en weten we dat er een probleem is met deze methode. Uiteraard is het belangrijk om je test parameters zorgvuldig te kiezen en eventueel meerdere test te schrijven voor een methode.

We kunnen van deze eerste test gebruik maken om te tonen dat een unittest een vast patroon volgt.

using TestingCalculator;

namespace UnitTesting
{
    [TestClass]
    public class CalculatorTest
    {
        [TestMethod]
        public void SumTest()
        {
            //ARRANGE
            Calculator calculator = new Calculator();  // Maak een nieuwe calculator instantie
            int a = 2;                          // Waarde voor parameter a
            int b = 3;                          // Waarde voor parameter b
            int expected = 5;                   // Verwacht resultaat
            //ACT
            int result = calculator.Sum(a, b);  // Sum methode aanroepen
            //ASSERT
            Assert.AreEqual(expected, result);  // Testen of resultaat gelijk is aan verwachte waarde 
        }
    }
}

Dit helpt om structuur te houden in de unittests.