This is used for comparing and verifying actual and expected values. The following are the overloaded methods for Assert.AreEqual() and the result for the preceding code samples:

All the previously mentioned overloaded methods for Assert.AreEqual also applies to Assert.AreNotEqual but the only difference is that the comparison is the exact opposite of the AreEqual assert. For example, the following method verifies if the two strings are not equal by ignoring or not ignoring the casing as specified by Boolean. The test fails if they are equal and the message is displayed with the specified formatting applied to it:

Assert.AreNotEqual(String, String, Boolean, String, Object[])

The following code compares two strings and verifies whether they are equal or not:

Assert.AreNotEqual(expected.ItemType, actual.ItemType, false, "Both the strings '{0}' and '{1}' are equal", expected.ItemType, actual.ItemType);

If the string values are equal, the output of this would be:

Assert.AreNotEqual failed. Expected any value except:<Electronics>. Actual:<Electronics>. Both the strings 'Electronics' and 'Electronics' are equal

The following table shows different type of overloaded assert methods for the assert type AreSame to check if the objects are the same or not:

This Assert is used for verifying whether the two objects are not the same. The test fails if the objects are the same. The same overloaded methods for Assert.AreSame apply here, but the comparison is the exact opposite. The following are the three overloaded methods applied to Assert.AreNotSame:

For example, the following code verifies if objects A and B are not the same. If they are the same, the test fails with the specified error message with the specified formatting applied to it:

ArrayList A = new ArrayList(5);
ArrayList B = A;
Assert.AreNotSame(A, B, "The test fails because the objects {0} and {1} are same", "A", "B");

The preceding test fails with the message, Assert.AreNotSame failed. The test fails because the objects A and B are same.

This assert is used for failing the test without checking any condition. Assert.Fail has three overloaded methods:

This is useful if the method is incomplete and we cannot determine whether the output is true or false. We can set the assertion to be inconclusive until we complete the method for testing. There are three overloaded methods for Assert.Inconclusive:

This is used for verifying if the condition is true. The test fails if the condition is false. There are three overloaded methods for Assert.IsTrue:

This is to verify if the condition is false. The test fails if the condition is true. Similar to Assert.IsTrue, this one has three overloaded methods:

This is useful in verifying whether the object is null. The test fails if the object is not null. Given here are the three overloaded methods for Assert.IsNull:

This is to verify if the object is null or not. The test fails if the object is null. This is the exact opposite of the Assert.IsNull and has the same overloaded methods.

This method verifies whether the object is of the specified System.Type. The test fails if the type does not match.

This method verifies if the second parameter string is present in the first parameter string. The test fails if the string is not present. There are three overloaded methods for StringAssert.Contains. The third parameter specifies the message to be displayed if the assertion fails and the fourth parameter specifies the message formatter to be applied to the error message for the assertion failure. The formatters are the placeholders for the parameters values:

For example, the following code verifies if the string, Test, is present in the first string. If not, the message is displayed with the format applied to it:

string find = "Testing";
StringAssert.Contains("This is the Test for StringAsserts", find, "The string '{0}' is not found in the first parameter value", find);

The assertion fails with the specified error message added to its default message as StringAssert.Contains failed. String 'This is the Test for StringAsserts' does not contain string 'Testing'. The string 'Testing' is not found in the first parameter value.

As the name suggests, this method verifies if the first string matches the regular expression specified as the second parameter. These assert methods contain three overloaded methods to display the custom error message and apply formats to the message if the assertion fails:

For example, the following code verifies if the string contains any numbers between 0 and 9. If not, the assertion fails with the message specified with the formatters.

Regex regEx = new Regex("[0-9]");
StringAssert.Matches("This is first test for StringAssert", regEx, "There are no numbers between {0} and {1} in the string", 0, 9);

The error message would be StringAssert.Matches failed. String 'This is first test for StringAssert' does not match pattern '[0-9]'. There are no numbers between 0 and 9 in the string.

This is the exact opposite of StringAssert.Matches. This assert method verifies whether the first parameter string matches the regular expression specified as the second parameter. The assertion fails if it matches. This assert type has three overloaded methods to display the error message and apply the message formatting to it which is the place holder for the parameter values in the message:

For example, the following code verifies if the first parameter string does not match with the regular expression specified in the second parameter. The assertion fails if it does match and displays the specified error message with the formatting applied to it:.

Regex regEx = new Regex("[0-9]");
StringAssert.DoesNotMatch("This is 1st test for StringAssert", regEx, "There is a number in the string");

The assertion fails with the error message StringAssert.DoesNotMatch failed. String 'This is 1st test for StringAssert' matches pattern '[0-9]'. There is a number in the string.

This is to verify whether a string in the first parameter starts with the value in the second parameter. The assertion fails if the string does not start with the second string. There are three overloaded methods to specify the error message to be displayed and to specify the formatting to be applied to the error message:

For example, the following code verifies if the first string starts with the specified second parameter value. The assertion fails if it does not, and displays the specified error message with the specified formatting:

string startWith = "First";
StringAssert.StartsWith("This is 1st test for StringAssert", startWith, "The string does not start with '{0}'", startWith);

The assertion fails with the error message StringAssert.StartsWith failed. String 'This is 1st test for StringAssert' does not start with string 'First'. The string does not start with 'First'.

This is similar to the StringAssert.StartsWith, but here, it verifies if the first string ends with the specified string in the second parameter. The assertion fails if it does not end with the specified string and displays the error message. There are three overloaded methods to specify the custom error message and the formatting:

For example, the following code verifies whether the first string ends with the specified string as the second parameter. The assertion will fail and display the message with the specified formatting.

string endsWith = "Testing";
StringAssert.EndsWith("This is 1st test for StringAssert", endsWith, "'{0}' is not the actual ending in the string", endsWith);

The error message displayed would be StringAssert.EndsWith failed. String 'This is 1st test for StringAssert' does not end with string 'Testing'. 'Testing' is not the actual ending in the string.

This assert verifies if any of the items in the collection is not null. The assertion will pass as none of the items is null in firstArray.

CollectionAssert.AllItemsAreNotNull(firstArray)

The assertion will fail if we add the third item as:

firstArray.Add(null)

There are three overloaded methods to display the custom error message and to specify the formatting for the message if the assertion fails:

CollectionAssert.AreEquivalent verifies if both the collections are equivalent. It means that even if the items are in different order in the collections, the items should match:

CollectionAssert.AreEquivalent(thirdArray, secondArray);

In the example, we can see that MiddleName is the last item in the secondArray but it is the second item in the thirdArray. But both the collections have the same items, so the assertion will pass. The following are the overloaded methods for Collectionassert.AreEquivalent:

The assert CollectionAssert.AreNotEquivalent statement verifies if both the first and second parameter collections do not contain the same items. It means that the assert fails even if one item in the first collection is present in the second collection. In the example, if we remove or replace one of the items from any of the two collections secondArray or the thirdArray, the assertion will pass as the items will not match.

thirdArray.Remove("MiddleName");
thirdArray.Add("FullName");
CollectionAssert.AreNotEquivalent(thirdArray, secondArray);

The following are the method syntax and the overloaded methods for the CollectionAssert.AreNotEquivalent assert to specify the custom error message and the formatting for the message.

This statement verifies if all the items in the collection are of the specified/expected type in the second parameter. The following code verifies if all the elements of the collection thirdArray is of type, string. The assertion will pass as the items are string:

CollectionAssert.AllItemsAreInstancesOfType(thirdArray, typeof(string))

The following are the syntax and the overloaded methods for the CollectionAssert.AllItemsAreInstacesOfType assert, with parameters for custom error messages and to specify the formats or the placeholders for the parameter values in the message:

This statement verifies whether the collection in the first parameter contains some or all of the elements of the collection in the second parameter. But all the items of the first parameter collection should be part of the collection in the second parameter. As per the example, the following assertion will pass as the items in the fourthArray are the subset of the items in the thirdArray:

CollectionAssert.IsSubsetOf(fourthArray, thirdArray)

The following are the syntax and the overloaded methods for the CollectionAssert.IsSubsetOf assert:

This statement verifies whether the collection in the first parameter contains at least one element which is not present in the second parameter collection. As per the example, the following assertion will fail as the items in the fourthArray are the subset of the items in the thirdArray. It means that there are no items in fourthArray which are not present in thirdArray.

CollectionAssert.IsNotSubsetOf(fourthArray, thirdArray)

Try adding a new element to the fourthArray which is not present in thirdArray such as:

fourthArray.Add("FullName");

Now try the same CollectionAssert statement. The assertion will fail as the fourthArray is not a subset of the thirdArray collection.

The following is the syntax and the overloaded methods for CollectionAssert. The IsNotSubsetOf assert is to specify the custom error message and the formats for the error message:

This verifies whether the items in the collection are unique. The following assertion will pass as per the same collection. The assertion fails if we add a third item, LastName, which duplicates the existing item:

firstArray.Add("LastName")

The syntax for this method and its two overloaded methods are given here. The additional parameters are to specify the custom error message and the formats for the error message.

This assert verifies if any of the elements of the collection specified as the first parameter contain the element specified as the second parameter. The following assert will pass as the FirstName is an element in the fourthArray collection:

CollectionAssert.Contains(fourthArray, "FirstName")

We can specify the custom error message and custom formats for the assertion failure. This assert has two overloaded methods in addition to the default method:

This is the exact opposite of the CollectionAssert.Contains statement. This assert verifies if any of the elements in the first parameter collection is not equal to the value specified as the second parameter:

CollectionAssert.Contains(fourthArray, "Phone Number")

We can specify the custom error message and custom formatters for the assertion failure. This assert has two overloaded methods in addition to the default method:

This method verifies if both the collections are equal. The following assertion fails as the number of items added to the firstArray is different from the thirdArray.

CollectionAssert.AreEqual(firstArray, thirdArray)

The assertion will pass if we add the same items from firstArray to the thirdArray or assign the firstArray to thirdArray which makes both the arrays equal:

thirdArray = firstArray;

This assert type has six overloaded methods:

The parameter String and Object[] can be used when we need a custom error message and formatters for the error message in case of assertion failure.

IComparer can be used if we have the custom objects in the collection and if we want to use a particular property of the object for comparison. For example, if a collection contains a list of Employee objects, having the FirstName, LastName, and EmployeeID of each employee, we may want to sort the elements in the collection based on the FirstName of the employees. We may want to compare the two collections containing the employees list based on the FirstName of the employees. To do this, we have to create the custom comparer.

Consider the following Employee class, which has a EmployeeComparer class that compares the FirstName in the Employee implemented from the IComparable interface:

public class Employee : IComparable
{
public string FirstName { get; set; }
public string LastName { get; set; }
public int ID { get; set; }
public Employee (string firstName, string lastName, int employeeID)
{
FirstName = firstName;
LastName = lastName;
ID = employeeID;
}
public int CompareTo(Object obj)
{
Employee emp = (Employee)obj;
return FirstName.CompareTo(emp.FirstName);
}
public class EmployeeComparer : IComparer
{
public int Compare(Object one, Object two)
{
Employee emp1 = (Employee)one;
Employee emp2 = (Employee)two;
return emp1.CompareTo(two);
}
}

Now create two collections of the type ArrayList and add employees to the lists. The first names of the employees are the same in both the lists but the last names and the IDs vary.

ArrayList EmployeesListOne = new ArrayList();
EmployeesListOne.Add(new TestLibrary.Employee("Richard", "King", 1801));
EmployeesListOne.Add(new TestLibrary.Employee("James", "Miller", 1408));
EmployeesListOne.Add(new TestLibrary.Employee("Jim", "Tucker", 3234));
EmployeesListOne.Add(new TestLibrary.Employee("Murphy", "Young", 3954));
EmployeesListOne.Add(new TestLibrary.Employee("Shelly", "Watts", 7845));
ArrayList EmployeesListTwo = new ArrayList();
EmployeesListTwo.Add(new TestLibrary.Employee("Richard", "Smith", 4763));
EmployeesListTwo.Add(new TestLibrary.Employee("James", "Wright", 8732));
EmployeesListTwo.Add(new TestLibrary.Employee("Jim", "White", 1829));
EmployeesListTwo.Add(new TestLibrary.Employee("Murphy", "Adams", 2984));
EmployeesListTwo.Add(new TestLibrary.Employee("Shelly", "Johnson", 1605));

Now, in the test method, use CollectionAssert.AreEqual to compare the preceding collections.

CollectionAssert.AreEqual(EmployeesListOne, EmployeesListTwo, "The collections '{0}' and '{1}' are not equal", "EmployeesListOne", "EmployeesListTwo");

This assertion will fail because the objects in the collection are not the same. Even if you update the employee object properties to be the same in both the collections, it will fail because the objects are not the same. The error message will be the specified custom message with the specified formatters. But we can use the custom comparer we created to compare the collection objects based on the FirstName element which is used in the comparer. We can create the custom comparer on any of the object properties:

TestLibrary.Employee.EmployeeComparer comparer = new TestLibrary.Employee.EmployeeComparer();
CollectionAssert.AreEqual(EmployeesListOne, EmployeesListTwo, comparer, "The collections '{0}' and '{1}' are not equal", "EmployeesListOne", "EmployeesListTwo");

The assertion will pass now as the comparison is done on the first name of the elements in both the collection.

This is similar to CollectionAssert.AreEqual but this will verify if the collections are not equal. This assert type also has multiple overloaded methods similar to the CollectionAssert.AreEqual: