Testy jednostkowe w C# – podstawy

Solution 'CalculatorApp'
├── CalculatorApp (projekt główny)
│   ├── Program.cs
│   └── Calculator.cs
└── CalculatorApp.Tests (projekt testowy)
    ├── Dependencies
    │   └── Projects
    │       └── CalculatorApp ← musi tu być!
    └── CalculatorTests.cs

using CalculatorApp; // Jeśli się podkreśla na czerwono = brak referencji!

✅ Test passed (zielony) – test zakończony sukcesem
❌ Test failed (czerwony) – test wykrył błąd
⚠️ Test not run (szary) – test nie został jeszcze uruchomiony

Assert.AreEqual(5, wynik);

Assert.AreEqual(5, wynik, "Suma 2+3 powinna być równa 5!");

namespace CalculatorApp
{
    public class Calculator
    {
        public static int Dodaj(int a, int b)
        {
            return a + b;
        }

        public static int Odejmij(int a, int b)
        {
            return a - b;
        }

        public static int Pomnoz(int a, int b)
        {
            return a * b;
        }

        public static double Podziel(int a, int b)
        {
            if (b == 0)
            {
                throw new DivideByZeroException("Nie można dzielić przez zero!");
            }
            return (double)a / b;
        }

        public static string GenerujKomunikat(int a, int b, int wynik)
        {
            return $"Suma {a} + {b} = {wynik}";
        }
    }
}

using Microsoft.VisualStudio.TestTools.UnitTesting;
using CalculatorApp;

namespace CalculatorApp.Tests
{
    [TestClass]
    public class CalculatorTests
    {
        [TestMethod]
        public void Dodaj_DwieLiczbyDodatnie_ZwracaSume()
        {
            // Arrange (przygotowanie danych)
            int a = 2;
            int b = 3;
            int oczekiwanyWynik = 5;

            // Act (wykonanie metody)
            int wynik = Calculator.Dodaj(a, b);

            // Assert (sprawdzenie wyniku)
            Assert.AreEqual(oczekiwanyWynik, wynik);
        }
    }
}

✅ Dodaj_DwieLiczbyDodatnie_ZwracaSume
   Czas: 23ms

❌ Dodaj_DwieLiczbyDodatnie_ZwracaSume
   Assert.AreEqual failed. Expected:<5>. Actual:<6>.
   Czas: 18ms

[TestMethod]
public void Dodaj_TestKtoryNiePrzejdzie()
{
    int wynik = Calculator.Dodaj(2, 3);
    Assert.AreEqual(10, wynik); // ❌ Spodziewamy się 10, ale będzie 5!
}

❌ Dodaj_TestKtoryNiePrzejdzie
   Assert.AreEqual failed. Expected:<10>. Actual:<5>.

[TestMethod]
public void Dodaj_DwieLiczbyUjemne_ZwracaSume()
{
    // Arrange
    int a = -5;
    int b = -3;

    // Act
    int wynik = Calculator.Dodaj(a, b);

    // Assert
    Assert.AreEqual(-8, wynik);
}

[TestMethod]
public void Dodaj_JednaLiczbaZero_ZwracaDrugaLiczbe()
{
    // Arrange
    int a = 0;
    int b = 7;

    // Act
    int wynik = Calculator.Dodaj(a, b);

    // Assert
    Assert.AreEqual(7, wynik);
}

[TestMethod]
public void Dodaj_DuzeLiczby_ZwracaSume()
{
    // Arrange
    int a = 1000000;
    int b = 2000000;

    // Act
    int wynik = Calculator.Dodaj(a, b);

    // Assert
    Assert.AreEqual(3000000, wynik);
}

[TestMethod]
public void Odejmij_DwieLiczby_ZwracaRoznice()
{
    // Arrange
    int a = 10;
    int b = 3;

    // Act
    int wynik = Calculator.Odejmij(a, b);

    // Assert
    Assert.AreEqual(7, wynik);
}

[TestMethod]
public void Pomnoz_DwieLiczby_ZwracaIloczyn()
{
    // Arrange
    int a = 4;
    int b = 5;

    // Act
    int wynik = Calculator.Pomnoz(a, b);

    // Assert
    Assert.AreEqual(20, wynik);
}

[TestMethod]
public void Podziel_PrzezZero_RzucaWyjatek()
{
    // Arrange
    int a = 10;
    int b = 0;

    // Act & Assert (w jednej linii!)
    Assert.ThrowsException<DivideByZeroException>(() => 
    {
        Calculator.Podziel(a, b);
    });
}

Assert.ThrowsException<DivideByZeroException>(() => 
{
    // Kod, który POWINIEN rzucić wyjątek
});

[TestMethod]
public void Podziel_DwieLiczby_ZwracaIloraz()
{
    // Arrange
    int a = 10;
    int b = 2;

    // Act
    double wynik = Calculator.Podziel(a, b);

    // Assert
    Assert.AreEqual(5.0, wynik);
}

[TestMethod]
public void Podziel_ZReszta_ZwracaWartoscZmiennoprzecinkowa()
{
    // Arrange
    int a = 10;
    int b = 3;

    // Act
    double wynik = Calculator.Podziel(a, b);

    // Assert
    Assert.AreEqual(3.333, wynik, 0.001); // Delta = dopuszczalny błąd
}

[TestMethod]
public void Dodaj_Test1() { Assert.AreEqual(5, Calculator.Dodaj(2, 3)); }

[TestMethod]
public void Dodaj_Test2() { Assert.AreEqual(10, Calculator.Dodaj(7, 3)); }

[TestMethod]
public void Dodaj_Test3() { Assert.AreEqual(0, Calculator.Dodaj(-5, 5)); }

[DataTestMethod]
[DataRow(2, 3, 5)]
[DataRow(7, 3, 10)]
[DataRow(-5, 5, 0)]
[DataRow(0, 0, 0)]
[DataRow(100, 200, 300)]
public void Dodaj_RozneWartosci_ZwracaPoprawnaSume(int a, int b, int oczekiwany)
{
    // Act
    int wynik = Calculator.Dodaj(a, b);

    // Assert
    Assert.AreEqual(oczekiwany, wynik);
}

✅ Dodaj_RozneWartosci_ZwracaPoprawnaSume (2, 3, 5)
✅ Dodaj_RozneWartosci_ZwracaPoprawnaSume (7, 3, 10)
✅ Dodaj_RozneWartosci_ZwracaPoprawnaSume (-5, 5, 0)
✅ Dodaj_RozneWartosci_ZwracaPoprawnaSume (0, 0, 0)
✅ Dodaj_RozneWartosci_ZwracaPoprawnaSume (100, 200, 300)

// ❌ To NIE ZADZIAŁA w testach!
public static void WypiszSume(int a, int b)
{
    Console.WriteLine($"Suma {a} + {b} = {a + b}");
}

public static string GenerujKomunikat(int a, int b, int wynik)
{
    return $"Suma {a} + {b} = {wynik}";
}

[TestMethod]
public void GenerujKomunikat_DwieLiczby_ZwracaPoprawnyTekst()
{
    // Arrange
    int a = 5;
    int b = 3;
    int wynik = 8;

    // Act
    string komunikat = Calculator.GenerujKomunikat(a, b, wynik);

    // Assert
    Assert.AreEqual("Suma 5 + 3 = 8", komunikat);
}

[DataTestMethod]
[DataRow(2, 3, 5, "Suma 2 + 3 = 5")]
[DataRow(0, 0, 0, "Suma 0 + 0 = 0")]
[DataRow(-1, 1, 0, "Suma -1 + 1 = 0")]
public void GenerujKomunikat_RozneWartosci(int a, int b, int wynik, string oczekiwany)
{
    // Act
    string komunikat = Calculator.GenerujKomunikat(a, b, wynik);

    // Assert
    Assert.AreEqual(oczekiwany, komunikat);
}

[TestMethod]
public void Dodaj_DwieLiczby_ZwracaSume()
{
    Assert.AreEqual(5, Calculator.Dodaj(2, 3));
}

[TestMethod]
public void Dodaj_RozneScenariusze()
{
    Assert.AreEqual(5, Calculator.Dodaj(2, 3));
    Assert.AreEqual(10, Calculator.Dodaj(7, 3));
    Assert.AreEqual(0, Calculator.Dodaj(-5, 5));
}

int wynik; // Zmienna współdzielona

[TestMethod]
public void Test1() { wynik = 5; }

[TestMethod]
public void Test2() { Assert.AreEqual(5, wynik); } // Zależny od Test1!

[TestMethod]
public void Test1() 
{
    int wynik = Calculator.Dodaj(2, 3);
    Assert.AreEqual(5, wynik);
}

[TestMethod]
public void Test2() 
{
    int wynik = Calculator.Dodaj(7, 3);
    Assert.AreEqual(10, wynik);
}

[TestClass]
public class CalculatorTests
{
    private Calculator kalkulator;

    [TestInitialize]
    public void Setup()
    {
        // Wykonywane przed KAŻDYM testem
        kalkulator = new Calculator();
    }

    [TestMethod]
    public void Test1() { /* użyj kalkulator */ }

    [TestMethod]
    public void Test2() { /* użyj kalkulator */ }
}

public static int Poteguj(int podstawa, int wykladnik)
{
    return (int)Math.Pow(podstawa, wykladnik);
}

public static bool CzyParzysta(int liczba)
{
    return liczba % 2 == 0;
}

public static int Pierwiastek(int liczba)
{
    if (liczba < 0)
    {
        throw new ArgumentException("Nie można obliczyć pierwiastka z liczby ujemnej!");
    }
    return (int)Math.Sqrt(liczba);
}

public static bool CzyWiekPoprawny(int wiek)
{
    return wiek >= 0 && wiek <= 150;
}

public class StringHelper
{
    public static string Odwroc(string tekst) { /* TODO */ }
    public static int IleLiter(string tekst) { /* TODO */ }
    public static bool CzyPalindrom(string tekst) { /* TODO */ }
}