Gain insights into unit testing principles, and delve into configuring and using NUnit. Discover how to write effective tests, maximize coverage, and elevate your testing projects.

Dockerfile.tar.gz

Iteration1

Iteration2

AssertTrueExample

AssertTrueExercise

AssertNullExample

AssertNullExercise

GeneralJob

WebAppWithoutTest

MSTest

XUnit

ConsoleWithoutTest

GeneralJobFIX

WebAppWithoutTestFIX

WebAppWithoutTestNIAZ

NiazSolution

Industry, employers, startups, and amateur developers are increasingly looking towards unit testing their software. Unit testing is one of the most reliable ways to find and keep software bugs at bay, thus reducing costs and development pains. Developers working with the .NET framework are overwhelmingly turning to NUnit to meet their unit testing needs.

In this course, you’ll learn the principles of unit testing, and in the process, learn to configure and use the NUnit testing framework. Given that the course places an emphasis on principles, these skills are transferable to other unit testing frameworks. Alongside these, you’ll also get hands-on experience with projects and exercises that provide ample opportunities to learn how to design effective tests in the NUnit framework.

At the end of the course, you’ll be able to quickly write unit tests that maximize logical coverage, test complex applications, and better organize your testing projects—setting you up as a natural leader in your organization.

Mastering Unit Testing Principles with NUnit

# Introduction

C# types store values which are categorized into the following groups:
- `Null`
- `NotNull`
- `Zero`
- `NotZero`
- `IsNaN`
- `IsEmpty`
- `IsNotEmpty`

NUnit provides facilities to assert against these value categories.

# Conceptually understanding each value category

The following are interpretations of each value category:

- `Null`:
A nullable value type or a reference type can assume the value of `null`. This means that the variable does not point to any instance in memory.

- `NotNull`: A nullable value type/reference type can assume the value of not null. This means that the variable points to an instance in memory.

- `Zero`:
 A variable that assumes the value of zero.

- `NotZero`:
A variable that does not assume the value of zero.

- `IsNaN`:
A numeric variable assumes a value that is not expressible as a valid number. This scenario results from certain mathematical operations.

- `IsEmpty`:
The variable points to an instance that has zero length.

- `IsNotEmpty`:
The variable points to an instance whose length is not zero.



# Value category assertions

Classic assertions for the various value categories are listed below. These methods are overloaded to take various other parameters. For a full list of overloaded methods, consult the official NUnit documentation, provided in the “Unit Testing Resources” lesson in the “Conclusion” section.
## `Null`

The following syntax asserts whether the passed reference variable points to null:

```cs
Assert.Null(object anObject);
```

## `NotNull`

The following syntax asserts whether the passed reference variable does not point to null:

```cs
Assert.NotNull(object anObject);
```

## `Zero`

The following syntax asserts whether the passed value variable is equal to zero. Note that this method is overloaded to take other value types, not just integers.

```cs
Assert.Zero(int actual);
```

## `NotZero`

The following syntax asserts whether the passed value variable is not equal to zero. Note that this method is overloaded to take other value types, not just integers.

```cs
Assert.NotZero(int actual);
```

## `IsNaN`

The following syntax asserts whether the passed value variable is not a number:

```cs
Assert.IsNaN(double aDouble);
```

## `IsEmpty`

The following syntax asserts whether the passed string or collection is empty:

```cs
Assert.IsEmpty(string aString);
Assert.IsEmpty(IEnumerable collection);
```

## `IsNotEmpty`

The following syntax asserts whether the passed string or collection is not empty

```cs
Assert.IsNotEmpty(string aString);
Assert.IsNotEmpty(IEnumerable collection);
```

# Exercise

In the next piece of code, we present a quadratic class. This class calculates the roots of a quadratic equation. A quadratic equation takes the following form:

$f(x) = ax^2 + bx + c$

To calculate the roots of the polynomial, we use the two equations:

$r_1 = \frac{-b + \sqrt{b^2 - 4ac}}{2a}$

$r_2 = \frac{-b - \sqrt{b^2 - 4ac}}{2a}$

It is possible that the value of $r_1$ = $r_2$ in which case there is one root and not two.

The component $b^2 - 4ac$ within the two equations is called the **discriminant**.

The value of the discriminant determines the nature of the roots as follows:

$b^2 - 4ac < 0$: There are no real roots

$b^2 - 4ac = 0$: There is one real root

$b^2 - 4ac > 0$: There are two real roots

The number of roots is visualized by the number of times the graph intersects the x-axis (horizontal axis).

These three cases are shown below:

Learn and practice how to perform assertions on value categories.

Assert Value Categories

Fundamentals of Unit Testing

Testing Conditions With Classic And Fluent Assertions

Making Unit Testing More Effective

Unit Testing Code with External Dependencies

Conclusion

Appendix - Unit Test Project Organization and Console Setup

Assert Value Categories

Introduction

Conceptually understanding each value category