Unit testing is a type of testing or the technique to take the smallest piece of testable code isolated from the remaining software in the application and then determine whether it behaves as expected. Enterprise software applications usually comprises of multiple methods and functions with multiple lines of code integrated together. Identifying the piece of code that produces the defect is always a time-consuming task and the cost involved is also high. It is always a good practice to test the code in units and confirm the expectations before integrating the code module(s). Requiring all code to pass the unit tests before they can be integrated ensures standards and quality. It is the responsibility of the developer who has written the code to make sure that each unit of code behaves exactly as expected. The code should also be written in such a way that it can be tested independently. Another advantage is that every time a defect is fixed or code is modified, you need not retest the entire module or application. As long as the unit of code is tested and it produces the expected result, it should be fine. Automating the tests would help in re-running the tests whenever there is code change in any unit of code.

Visual Studio has the capability and feature to create, customize, and automate the unit tests, irrespective of type of the method whether it is public or private. Unit tests are just another class file, similar to any other class and method but having additional attributes to define the type as test class and the test method. The unit tests are created either manually by writing the code for class and methods, or by generating the skeleton code using the Create Unit Tests option from the Context menu and then customizing it.

The generated unit test code file contains special attributes assigned to the class and methods in it. Test classes are marked by the TestClass() attribute and each test method is marked with the TestMethod() attribute. Apart from these two, there are many other attributes used for unit testing. After generating the unit test class and methods, the Assert methods are used to verify the produced result with the expected value.

All unit test classes and methods are defined in the Microsoft.VisualStudio.TestTools.UnitTesting namespace. Any unit test created using Visual Studio should include this namespace. One of the main classes is the TestContext, which provides all the information for unit tests. This chapter covers the following topics in detail:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestLibrary
{
    public class Class1
    {
        public double CalculateTotalPrice(double quantity)
        {
            double totalPrice;
            double unitPrice;

            // Todo get unit price. For test let us hardcode it 
            unitPrice = 16.0;

            totalPrice = unitPrice * quantity;
            return totalPrice;
        }

        public void GetTotalPrice()
        {
            int qty = 5;
            double totalPrice = CalculateTotalPrice(qty);
            Console.WriteLine("Total Price: " + totalPrice);
        }
    }
}

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
{
    [TestClass()]
    public class Class1Test
    {
        [TestMethod()]
        public void CalculateTotalPriceTest()
        {
            Class1 cls = new Class1(); 
            double quantity = 0F;
            double expected = 0F; 
            double actual;
            actual = cls.CalculateTotalPrice(quantity);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test
			                     method");
        }

        [TestMethod()]
        public void GetTotalPriceTest()
        {
            Class1 cls = new Class1(); 
            cls.GetTotalPrice();
            Assert.Inconclusive("Method that does not return a value");
        }
    }
}