Introduction To Unit Testing In C# Complete Guide

Introduction to Unit Testing in C#

What is Unit Testing?

Unit testing is a software development process where individual units, such as methods or classes, are tested to ensure they work as expected. Unit tests are automated tests written and executed by software developers to validate that a particular section of an application (a method, a function, or a procedure, known as the unit) meets its design and behaves as intended.

Why Unit Testing?

• Bug Detection: Helps in early detection of bugs, reducing the cost of fixing bugs.
• Refactoring: Makes it easier and safer to change the code in the future.
• Documentation: Acts as documentation for the code.
• Code Quality: Improves the overall quality of the code.

Tools for Unit Testing in C#

The most popular tool for unit testing in C# is NUnit and xUnit. However, Microsoft also provides MSTest which is integrated with Visual Studio.

In this guide, we will use MSTest.

Setting Up MSTest

1. Create a C# Project (Class Library)

   dotnet new classlib -o CalculatorLib
   cd CalculatorLib
   

2. Create a Unit Test Project

   dotnet new mstest -o CalculatorLib.Tests
   cd CalculatorLib.Tests
   

3. Add Reference to the Class Library

   dotnet add reference ../CalculatorLib/CalculatorLib.csproj
   

Complete Example: Unit Testing a Simple Calculator Class

Step 1: Implement a Simple Calculator Class

CalculatorLib/Calculator.cs

namespace CalculatorLib
{
    public class Calculator
    {
        public int Add(int a, int b)
        {
            return a + b;
        }

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

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

        public double Divide(int a, int b)
        {
            if (b == 0) throw new DivideByZeroException("Cannot divide by zero");
            return (double)a / b;
        }
    }
}

Step 2: Create Unit Tests for the Calculator Class

CalculatorLib.Tests/CalculatorTests.cs

using Microsoft.VisualStudio.TestTools.UnitTesting;
using CalculatorLib;
using System;

namespace CalculatorLib.Tests
{
    [TestClass]
    public class CalculatorTests
    {
        private Calculator _calculator;

        // Initialize the Calculator instance before each test
        [TestInitialize]
        public void Initialize()
        {
            _calculator = new Calculator();
        }

        // Test method for Add
        [TestMethod]
        public void Add_TwoPositiveNumbers_ReturnsCorrectSum()
        {
            // Arrange
            int expected = 7;
            int a = 3;
            int b = 4;

            // Act
            int result = _calculator.Add(a, b);

            // Assert
            Assert.AreEqual(expected, result);
        }

        [TestMethod]
        public void Add_TwoNegativeNumbers_ReturnsCorrectSum()
        {
            // Arrange
            int expected = -7;
            int a = -3;
            int b = -4;

            // Act
            int result = _calculator.Add(a, b);

            // Assert
            Assert.AreEqual(expected, result);
        }

        // Test method for Subtract
        [TestMethod]
        public void Subtract_LargerFromSmaller_ReturnsNegativeResult()
        {
            // Arrange
            int expected = -1;
            int a = 3;
            int b = 4;

            // Act
            int result = _calculator.Subtract(a, b);

            // Assert
            Assert.AreEqual(expected, result);
        }

        // Test method for Multiply
        [TestMethod]
        public void Multiply_TwoPositiveNumbers_ReturnsCorrectProduct()
        {
            // Arrange
            int expected = 12;
            int a = 3;
            int b = 4;

            // Act
            int result = _calculator.Multiply(a, b);

            // Assert
            Assert.AreEqual(expected, result);
        }

        // Test method for Divide
        [TestMethod]
        public void Divide_DivisorIsZero_ThrowsDivideByZeroException()
        {
            // Arrange
            int a = 10;
            int b = 0;

            // Act and Assert
            Assert.ThrowsException<DivideByZeroException>(() => _calculator.Divide(a, b));
        }

        [TestMethod]
        public void Divide_PositiveNumbers_ReturnsCorrectQuotient()
        {
            // Arrange
            double expected = 2.5;
            int a = 10;
            int b = 4;

            // Act
            double result = _calculator.Divide(a, b);

            // Assert
            Assert.AreEqual(expected, result, 0.001);
        }
    }
}

Step 3: Running the Unit Tests

1. Build the Solution

   dotnet build
   

2. Run the Tests

   dotnet test
   

   You should see output similar to this:

   Test Run Successful.
   Total tests: 5
   Total time: 0.6435 Seconds
   

Conclusion

In this guide, we've covered:

• What unit testing is.
• Why it is important.
• How to set up a unit test project using MSTest in C#.
• How to write and run unit tests for a simple Calculator class.

By following this guide, you should now have a good understanding of how to implement unit testing in C#. Happy testing!