📝 Lesson 5.2: Unit Testing

What Is Unit Testing?

A unit test is a small, automated check that verifies one piece of your code — usually a single method — does what it should. You run your whole suite of tests in seconds, and each one either passes or fails.

Why bother, when you could just run the program and eyeball it?

• Confidence to change code. After editing, run the tests; if they still pass, you probably didn't break anything.
• Catch regressions. A bug you fix once, you write a test for — so it can never silently return.
• Living documentation. Tests show exactly how code is meant to behave.
• Better design. Code that's easy to test tends to be well-structured (small, focused methods).

Setting Up a Test Project

Tests live in their own project that references the code being tested. The most popular test framework for C# is xUnit. Here's the typical layout and commands:

# Create the code being tested (a class library)
dotnet new classlib -o MyApp

# Create an xUnit test project
dotnet new xunit -o MyApp.Tests

# Let the test project see the app project
dotnet add MyApp.Tests reference MyApp

# Run all tests
dotnet test

Your First Test (Arrange-Act-Assert)

Say we're testing this simple class in the MyApp project:

public class Calculator
{
    public int Add(int a, int b) => a + b;
}

A test is a method marked with the [Fact] attribute. The body follows the Arrange-Act-Assert (AAA) pattern — set up, do the thing, check the result:

using Xunit;

public class CalculatorTests
{
    [Fact]
    public void Add_TwoNumbers_ReturnsSum()
    {
        // Arrange — set up the objects and inputs
        var calc = new Calculator();

        // Act — call the method under test
        int result = calc.Add(3, 4);

        // Assert — verify the result is what we expect
        Assert.Equal(7, result);
    }
}

Common Assertions

The Assert class provides methods to check outcomes. If an assertion is false, the test fails. The ones you'll use most:

[Fact]
public void Assertions_Examples()
{
    Assert.Equal(10, 5 + 5);
    Assert.True(4 % 2 == 0);
    Assert.NotNull("hello");

    var list = new List<int> { 1, 2, 3 };
    Assert.Contains(2, list);
}

Data-Driven Tests

Often you want to test the same logic with many inputs. Instead of copying a [Fact] repeatedly, use a [Theory] with [InlineData] — the test runs once per data row:

public class MathTests
{
    [Theory]
    [InlineData(2, 3, 5)]
    [InlineData(0, 0, 0)]
    [InlineData(-1, 1, 0)]
    [InlineData(100, 200, 300)]
    public void Add_VariousInputs_ReturnsSum(int a, int b, int expected)
    {
        var calc = new Calculator();
        int result = calc.Add(a, b);
        Assert.Equal(expected, result);
    }
}

This counts as four separate tests — each row is reported individually, so you can see exactly which input failed.

Testing Exceptions

Sometimes correct behavior is throwing an exception — like rejecting invalid input (Lesson 1.1). Verify that with Assert.Throws<T>, which passes only if the code throws the expected type:

public class BankAccount
{
    public decimal Balance { get; private set; }

    public void Withdraw(decimal amount)
    {
        if (amount > Balance)
        {
            throw new InvalidOperationException("Insufficient funds.");
        }
        Balance -= amount;
    }
}

public class BankAccountTests
{
    [Fact]
    public void Withdraw_MoreThanBalance_Throws()
    {
        // Arrange
        var account = new BankAccount();   // balance starts at 0

        // Act & Assert — the withdrawal should throw
        Assert.Throws<InvalidOperationException>(() => account.Withdraw(100m));
    }
}

Exercise & Quiz

public class StringUtils
{
    public string Reverse(string input)
    {
        if (input is null)
        {
            throw new ArgumentNullException(nameof(input));
        }
        char[] chars = input.ToCharArray();
        Array.Reverse(chars);
        return new string(chars);
    }
}

using Xunit;

public class StringUtilsTests
{
    [Fact]
    public void Reverse_Word_ReturnsReversed()
    {
        var utils = new StringUtils();
        Assert.Equal("olleh", utils.Reverse("hello"));
    }

    [Theory]
    [InlineData("", "")]
    [InlineData("a", "a")]
    [InlineData("ab", "ba")]
    [InlineData("racecar", "racecar")]
    public void Reverse_VariousInputs_Works(string input, string expected)
    {
        var utils = new StringUtils();
        Assert.Equal(expected, utils.Reverse(input));
    }

    [Fact]
    public void Reverse_Null_ThrowsArgumentNull()
    {
        var utils = new StringUtils();
        Assert.Throws<ArgumentNullException>(() => utils.Reverse(null!));
    }
}

Passed!  - Failed: 0, Passed: 6, Skipped: 0

Summary

📚 Additional Resources

• Testing in .NET — Microsoft Docs
• Unit testing C# with xUnit — tutorial
• xUnit.net — official site

🚀 What's Next?

You now have every tool for professional C#. In the final lesson, Lesson 5.3: Capstone Project, you'll combine exceptions, generics, LINQ, records, files, JSON, async, web APIs, and tests into one complete application — the grand finale of the course.