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

All the previously mentioned overloaded methods for Assert.AreEqual also applies to Assert.AreNotEqual, the only difference being 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 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 types of overloaded assert methods for the assert type AreSame, which checks whether objects are same or not:

This Assert is used to verify that 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 firstLst and secondLst are not the same. If they are the same, the test fails with the specified error message with the specified formatting applied to it:

List<string> firstLst = new List<string>(5);
List<string> secondLst = firstLst);
Assert.AreNotSame(firstLst, secondLst, "The test fails because the objects {0} and {1} are same", "firstLst", "secondLst");

The above test fails with the message Assert.AreNotSame failed. The test fails because the objects firstLst and secondLst are same.

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

This is useful in case the method is incomplete and cannot determine whether the output is true or false. Set the assertion to be inconclusive until the method is complete 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 used to verify whether an 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 on the error message for the assertion failure. The formatters are the placeholders for the parameters values:

For example, the following code verifies if the Test string is present in the first string. If not, the message is displayed with the specified 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 in 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 formats.

   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 the StringAssert.Matches method. 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 method, but here, it verifies if the first string ends with the string specified 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 would fail and display the message with the specified format.

    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.

These asserts verifies if any of the items in the collection is not null. The following assertion would pass as none of the items is null in firstLst.

CollectionAssert.AllItemsAreNotNull(firstLst)

The assertion fails if a third item is added, like this:

firstLst.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:

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

CollectionAssert.AreEquivalent(thirdLst, secondLst);

In the example, notice that the MiddleName is the last item in the secondLst but it is the second item in the thirdLst. But both collections have the same items, so the assertion would pass. The following are the overloaded methods for Collectionassert.AreEquivalent:

The CollectionAssert.AreNotEquivalent statement verifies if both 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 not present in the second collection. In the example, if we remove or replace one of the items from any of the two collections secondLst or thirdLst, the assertion will pass as the items will not match.

thirdLst.Remove("MiddleName"); 
thirdLst.Add("FullName"); 
CollectionAssert.AreNotEquivalent(thirdLst, secondLst);

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 type specified in the second parameter. The following code verifies if all the elements of the collection thirdLst are of the string type. The assertion would pass as the items are string:

CollectionAssert.AllItemsAreInstancesOfType(thirdLst, 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 the elements of the collection in the second parameter. Note that 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 fourthLst are the subset of items in the thirdLst:

CollectionAssert.IsSubsetOf(fourthLst, thirdLst)

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 would fail as the items in the fourthLst are the subset of items in the thirdLst. It means that there are no items in fourthLst which is not present in thirdLst.

CollectionAssert.IsNotSubsetOf(fourthLst, thirdLst)

Try adding a new element to the fourthLst which is not present in thirdLst such as:

fourthLst.Add("FullName");

Now try the same CollectionAssert statement. The assertion would pass as the fourthLst is not a subset of thirdLst collection.

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

Verifies whether the items in the collection are unique. The assertion would pass on firstLst. The assertion fails if we add a third item, LastName, which duplicates an existing item:

firstLst.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 formatting for that error message:

This assert verifies if any element of the collection specified as the first parameter contains the element specified as the second parameter. The following assert would pass as the FirstName is an element in the fourthLst collection:

CollectionAssert.Contains(fourthLst, "FirstName")

Custom error messages and formats for the assertion failure can be specified. 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 does not equal to the value specified as the second parameter:

CollectionAssert.Contains(fourthLst, "Phone Number")

Custom error messages and formatters for the assertion failure can be specified. This assert has two overloaded methods in addition to the default method:

This method verifies if both collections are equal in size. The following assertion fails as the number of items added to the firstLst is different from the thirdLst:

CollectionAssert.AreEqual(firstLst, thirdLst)

The assertion would pass if we add the same number of items as firstLst to the thirdLst, or assign the firstLst to thirdLst making both the arrays identical:

thirdLst = firstLst;

This assert type has six overloaded methods:

The parameters String and Object[] and custom formats can be used for custom error messages in case of assertion failure.

IComparer can be used if we have custom objects in the collection and 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 and compare 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 an 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 type List and add employees to the lists as shown below. The first names of the employees are the same in both lists, but the last names and the IDs vary, as shown in the following code:

            List<Employee> EmployeesListOne = new List<Employee>();
            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));

            List<Employee> EmployeesListTwo = new List<Employee>();
            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 would 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 would 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 would pass now as the comparison is done on the first name of the elements in both the collection.

This is similar to the 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: