Sometimes, it becomes essential to test a private type or a private member of a type. Let's create a new UnitTest class on the same project and call it SalaryPrivateTests. The unit testing API provides two classes to handle private types and members:

The PrivateObject class is used to invoke private members of a type. To test this feature, let's test the validity of the Salary class constructor as follows:

[TestMethod]
public void TestPrivateMembers()
{
    //arrange
    string name = "Abhishek";
    int age = 30;
    Salary osalary = new Salary(name, age);

    //act
    PrivateObject pObj = new PrivateObject(osalary);

    //asset
    Assert.AreEqual<int>(age, Convert.ToInt32(pObj.GetField("age")));
    Assert.AreEqual<string>(name, pObj.GetFieldOrProperty("name") as string);
}

In the preceding code, the instance of PrivateObject is used to get the private data members defined in the Salary class using GetField or GetFieldOrProperty to determine the validity of the constructor. The PrivateObject class provides methods such as GetField, GetProperty, SetField, and SetProperty to handle private fields, properties, or methods. You can call a Private method using the Invoke method from the PrivateObject instance.

The PrivateObject class is used to test instance members of a private type. When there is a need to test a private static member, we need to use PrivateType instead of PrivateObject. Let's add a simple static method to the Salary class, which takes an object of the salary and returns the name associated with the object:

static string GetName(Salary oSalary)
{
    return oSalary.name;
}

The preceding code takes an object of the Salary class and retrieves the name associated with it. To test this method, we need to create an instance of the PrivateType class as follows:

[TestMethod]
public void GetName_StaticMethodTest()
{
    //arrange
    string name = "Abhishek";
    int age = 30;
    Salary osalary = new Salary(name, age);

    //act
    PrivateType pType = new PrivateType(typeof(Salary));
    string returnValue = pType.InvokeStatic("GetName", osalary) as string;

    //assert
    Assert.AreEqual(name, returnValue);
}

In the preceding code, the PrivateType class allows you to call the private static member GetName and get the result of the method. Similarly, using the object of PrivateType, we can call the static field, properties, and so on using GetField and GetProperty.

From Test Explorer, Visual Studio 2013 allows you to analyze a project to ensure that all the lines of the project are tested. The Code Coverage window allows you to get an estimate on how much code has already been tested by the test cases defined in the unit testing project.

Let's say we comment out all the tests other than the GetSalary_ValidValues method from the project and rerun them. You will see that the tests have been passed to the Test Explorer. Once the tests have been passed, right-click on the test entry in the Test Explorer and select Analyze Code coverage for Selected Tests. The project will be analyzed and the result will be displayed inside the IDE.

In the following screenshot, how much code has been covered by the selected test has been shown. The GetSalary method listed on the Code Coverage Results window shows 50%. If you choose Show code coverage coloring form the Result pane, it will annotate all the lines that have been tested.

If you uncomment all the test cases for the project and run the code coverage, you will see that a lot more lines of the GetSalary method are colored in blue, which indicates that the lines are covered by test cases.

Test-driven development is a new way of developing code, where the test cases are written before the actual code is written. Visual Studio IDE helps in developing the actual code from the test cases easily. To create a test-driven method, let's create a unit testing project in Visual Studio and name it TDDSample.Tests.

Get rid of the default test file and create a new unit test class on the project. Create a test case and name it BasicDivideTest:

[TestMethod]
public void BasicDivideTest()
{
    //arrange
    Calculator ocalc = new Calculator();
    double expected = 4d;
    //act
    double actual = ocalc.Divide(20d, 5d);

    //assert
    Assert.AreEqual(expected, actual);
}

In the preceding code, we created an instance of the Calculator class that does not exist and call its Divide method with two double arguments. Now, we need to generate the class and the method automatically.

Let's add a new project to the solution and call it TDDSample. Right-click on Calculator in the code and select the New Type option from Generate, as shown in the following screenshot:

The new type pops up a new window, where you need to choose the correct project to autogenerate the Calculator class. Once the class is generated, you can again right-click on the Divide method and generate it inside the calculator class in a similar way.

Next, when we run the test from Test Explorer, it fails as the method throws NotImplementedException by default. If you select the test entry from Test Explorer, you will be navigated to the actual method. Let's now write the code that will ensure that the test passes:

public double Divide(double p1, double p2)
{
    return p1 / p2;
}

If we run the test again, it will pass because the result returned by the Divide method is valid for the test case.

Now, let's validate our test using a range of values:

[TestMethod]
public void RangeDivideTest()
{
    //arrange
    Calculator ocalc = new Calculator();

    //act
    for(double p1 = -100d; p1 < 100d; p1 ++)
        for (double p2 = -100d; p2 < 100d; p2++)
        {
            double expected = p1 / p2;
            AssertRange(ocalc, p1, p2, expected);
        }
}

private void AssertRange(Calculator ocalc, double p1, double p2, double expected)
{
    double actual = ocalc.Divide(p1, p2);

    //Assert
    Assert.AreEqual(expected, actual);Assert.IsFalse(Double.IsInfinity(actual));
}

In the preceding code, we try to test a range of values for p1 and p2 from -100 to +100. The test will fail because when the value of p2 is 0, the result will be returned as infinity. A check of Double.IsInfinity will ensure that the assert statement fails.

Let's add a code snippet to fix the problem:

public double Divide(double p1, double p2)
{
    if (p2 == 0 || p1 == 0)
        return 0;

    return p1 / p2;
}

Here, we validated p1 and p2 to return 0. Hence, the code will run.