Tips

Edit this page

General tips

  • If your assertion ends with Should().BeTrue(), there is most likely a better way to write it.
  • By having Should() as early as possible in the assertion, we are able to include more information in the failure messages.

Improved assertions

The examples below show how you might improve your existing assertions to both get more readable assertions and much more informative failure messages.

If you see something missing, please consider submitting a pull request.

Collections

Assertion Improvement
actual.Any().Should().BeTrue();

actual.Should().NotBeEmpty();

Expected True, but found False.

Expected collection not to be empty.

Assertion Improvement
actual.Any().Should().BeFalse();

actual.Should().BeEmpty();

Expected False, but found True.

Expected collection to be empty, but found {SomeProperty: 0, OtherProperty: }.

Assertion Improvement
actual.Any(x => x.SomeProperty).Should().BeTrue();

actual.Should().Contain(x => x.SomeProperty);

Expected True, but found False.

Collection {SomeProperty: 0, OtherProperty: Actual} should have an item matching (x.OtherProperty == value(UnitTests2.CollectionTests+<>c__DisplayClass5_0).expectedValue).

Assertion Improvement
actual.Any(x => x.SomeProperty).Should().BeFalse();

actual.Should().NotContain(x => x.SomeProperty);

Expected False, but found True.

Expected Collection {SomeProperty: 0, OtherProperty: Unexpected} to not have any items matching (x.OtherProperty == value(UnitTests2.CollectionTests+<>c__DisplayClass7_0).unexpectedValue).

Assertion Improvement
actual.All(x => x.SomeProperty).Should().BeTrue();

// now fails on empty collection;
actual.Should().OnlyContain(x => x.SomeProperty)

Expected True, but found False.

Expected collection to contain only items matching (x.OtherProperty == value(UnitTests2.CollectionTests+<>c__DisplayClass9_0).expectedValue), but {SomeProperty: 0, OtherProperty: Actual} do(es) not match.

Assertion Improvement
actual.Contains(expected).Should().BeTrue();

actual.Should().Contain(expected);

Expected True, but found False.

Expected collection {"Actual"} to contain "Expected".

Assertion Improvement
actual.Contains(unexpected).Should().BeFalse();

actual.Should().NotContain(unexpected);

Expected False, but found True.

Expected collection {"Expected"} to not contain "Expected".

Assertion Improvement
actual.Any(x => x == unexpected).Should().BeFalse();

actual.Should().NotContain(unexpected);

Expected False, but found True.

Expected collection {"Unexpected"} to not contain "Unexpected".

Assertion Improvement
actual.Count().Should().Be(k);

actual.Should().HaveCount(k);

Expected value to be 2, but found 3.

Expected collection to contain 2 item(s), but found 3.

Assertion Improvement
actual.Count().Should().BeGreaterThan(k);

actual.Should().HaveCountGreaterThan(k);

Expected a value greater than 4, but found 3.

Expected collection to contain more than 4 item(s), but found 3.

Assertion Improvement
actual.Count().Should().BeGreaterOrEqualTo(k);

actual.Should().HaveCountGreaterOrEqualTo(k);

Expected a value greater or equal to 4, but found 3.

Expected collection to contain at least 4 item(s), but found 3.

Assertion Improvement
actual.Count().Should().BeLessThan(k);

actual.Should().HaveCountLessThan(k);

Expected a value less than 2, but found 3.

Expected collection to contain fewer than 2 item(s), but found 3.

Assertion Improvement
actual.Count().Should().BeLessOrEqualTo(k);

actual.Should().HaveCountLessOrEqualTo(k);

Expected a value less or equal to 2, but found 3.

Expected collection to contain at most 2 item(s), but found 3.

Assertion Improvement
actual.Count().Should().NotBe(k);

actual.Should().NotHaveCount(k);

Did not expect 3.

Expected collection to not contain 3 item(s), but found 3.

Assertion Improvement
actual.Should().HaveCount(1);

actual.Should().ContainSingle();

Expected collection to contain 1 item(s), but found 3.

Expected collection to contain a single item, but found {"", "", ""}.

Assertion Improvement
actual.Should().HaveCount(0);

actual.Should().BeEmpty();

Expected collection to contain 0 item(s), but found 3.

Expected collection to be empty, but found {"", "", ""}.

Assertion Improvement
actual.Should().HaveCount(expected.Count());

actual.Should().HaveSameCount(expected);

Expected collection to contain 2 item(s), but found 3.

Expected collection to have 2 item(s), but found 3.

Assertion Improvement
actual.Count().Should().NotBe(unexpected.Count());

actual.Should().NotHaveSameCount(unexpected);

Did not expect 2.

Expected collection to not have 2 item(s), but found 2.

Assertion Improvement
actual.Where(x => x.SomeProperty).Should().NotBeEmpty();

actual.Should().Contain(x => x.SomeProperty);

Expected collection not to be empty.

Collection {SomeProperty: 0, OtherProperty: Actual} should have an item matching (x.OtherProperty == value(UnitTests2.CollectionTests+<>c__DisplayClass39_0).expectedValue).

Assertion Improvement
actual.Where(x => x.SomeProperty).Should().BeEmpty();

actual.Should().NotContain(x => x.SomeProperty);

Expected collection to be empty, but found {SomeProperty: 0, OtherProperty: Expected}.

Expected Collection {SomeProperty: 0, OtherProperty: Expected} to not have any items matching (x.OtherProperty == value(UnitTests2.CollectionTests+<>c__DisplayClass41_0).expectedValue).

Assertion Improvement
actual.Where(x => x.SomeProperty).Should().HaveCount(1);

actual.Should().ContainSingle(x => x.SomeProperty);

Expected collection to contain 1 item(s), but found 0.

Expected collection to contain a single item matching (x.OtherProperty == value(UnitTests2.CollectionTests+<>c__DisplayClass43_0).expectedValue), but no such item was found.

Assertion Improvement
actual.Should().OnlyContain(e => !e.SomeProperty);

actual.Should().NotContain(x => x.SomeProperty);

Expected collection to contain only items matching (x.OtherProperty != value(UnitTests2.CollectionTests+<>c__DisplayClass44_0).unexpectedValue), but {SomeProperty: 0, OtherProperty: Unexpected} do(es) not match.

Expected Collection {SomeProperty: 0, OtherProperty: Unexpected} to not have any items matching (x.OtherProperty == value(UnitTests2.CollectionTests+<>c__DisplayClass45_0).unexpectedValue).

Assertion Improvement
actual.Should().NotBeNull().And.NotBeEmpty();

actual.Should().NotBeNullOrEmpty();

Expected collection not to be empty.

Expected collection not to be empty.

Assertion Improvement
actual.ElementAt(k).Should().Be(expected);

actual.Should().HaveElementAt(k, expected);

Expected string to be 
"Expected" with a length of 8, but 
"Unexpected" has a length of 10.

Expected "Expected" at index 0, but found "Unexpected".

Assertion Improvement
actual[k].Should().Be(expected);

actual.Should().HaveElementAt(k, expected);

Expected string to be 
"Expected" with a length of 8, but 
"Unexpected" has a length of 10.

Expected "Expected" at index 0, but found "Unexpected".

Assertion Improvement
actual.Skip(k).First().Should().Be(expected);

actual.Should().HaveElementAt(k, expected);

Expected string to be 
"Expected" with a length of 8, but 
"Unexpected" has a length of 10.

Expected "Expected" at index 1, but found "Unexpected".

Assertion Improvement
actual.OrderBy(x => x.SomeProperty)
    .Should().Equal(actual);

actual.Should().BeInAscendingOrder(x => x.SomeProperty);

Expected collection to be equal to {SomeProperty: 2, OtherProperty: , SomeProperty: 1, OtherProperty: }, but {SomeProperty: 1, OtherProperty: , SomeProperty: 2, OtherProperty: } differs at index 0.

Expected collection {SomeProperty: 2, OtherProperty: , SomeProperty: 1, OtherProperty: } to be ordered" by SomeProperty" and result in {SomeProperty: 1, OtherProperty: , SomeProperty: 2, OtherProperty: }.

Assertion Improvement
actual.OrderByDescending(x => x.SomeProperty)
    .Should().Equal(actual);

actual.Should().BeInDescendingOrder(x => x.SomeProperty);

Expected collection to be equal to {SomeProperty: 1, OtherProperty: , SomeProperty: 2, OtherProperty: }, but {SomeProperty: 2, OtherProperty: , SomeProperty: 1, OtherProperty: } differs at index 0.

Expected collection {SomeProperty: 1, OtherProperty: , SomeProperty: 2, OtherProperty: } to be ordered" by SomeProperty" and result in {SomeProperty: 2, OtherProperty: , SomeProperty: 1, OtherProperty: }.

Assertion Improvement
actual.Select(e1 => e1.SomeProperty).Should()
    .Equal(expected.Select(e2 => e2.SomeProperty));

actual.Should()
    .Equal(expected, 
        (e1, e2) => e1.SomeProperty == e2.SomeProperty);

Expected collection to be equal to {"Expected", "Expected"}, but {"Actual", "Actual"} differs at index 0.

Expected collection to be equal to {SomeProperty: 1, OtherProperty: Expected, SomeProperty: 2, OtherProperty: Expected}, but {SomeProperty: 1, OtherProperty: Actual, SomeProperty: 2, OtherProperty: Actual} differs at index 0.

Assertion Improvement
actual.Intersect(expected).Should().BeEmpty();

actual.Should().NotIntersectWith(expected);

Expected collection to be empty, but found {SomeProperty: 1, OtherProperty: Expected}.

Did not expect collection to intersect with {SomeProperty: 1, OtherProperty: Expected}, but found the following shared items {SomeProperty: 1, OtherProperty: Expected}.

Assertion Improvement
actual.Intersect(expected).Should().NotBeEmpty();

actual.Should().IntersectWith(expected);

Expected collection not to be empty.

Expected collection to intersect with {SomeProperty: 1, OtherProperty: Expected}, but {SomeProperty: 1, OtherProperty: Actual} does not contain any shared items.

Assertion Improvement
actual.Select(x => x.SomeProperty)
    .Should().NotContainNulls();

actual.Should().NotContainNulls(e => e.OtherProperty);

Expected collection not to contain nulls, but found one at index 0.

Expected collection not to contain <null>s on e.OtherProperty, but found {SomeProperty: 1, OtherProperty: }.

Assertion Improvement
actual.Should().HaveSameCount(actual.Distinct());

actual.Should().OnlyHaveUniqueItems();

Expected collection to have 1 item(s), but found 2.

Expected collection to only have unique items, but item SomeProperty: 1, OtherProperty:  is not unique.

Assertion Improvement
actual.Select(x => x.SomeProperty)
    .Should().OnlyHaveUniqueItems();

actual.Should().OnlyHaveUniqueItems(x => x.SomeProperty);

Expected collection to only have unique items, but item 1 is not unique.

Expected collection to only have unique items on x.SomeProperty, but item SomeProperty: 1, OtherProperty:  is not unique.

Assertion Improvement
// From the assertion it is unclear what is being tested.
actual.FirstOrDefault().Should().BeNull();

// The first element is null.
actual.Should().HaveElementAt(0, null);

Expected string to be <null>, but found "".

Expected <null> at index 0, but found "".

Comparable and Numerics

Assertion Improvement
actual.Should().BeGreaterThan(0);

actual.Should().BePositive();

Expected a value greater than 0, but found -1.

Expected positive value, but found -1

Assertion Improvement
actual.Should().BeLessThan(0);

actual.Should().BeNegative();

Expected a value less than 0, but found 1.

Expected negative value, but found 1

Assertion Improvement
(lower <= actual && actual <= upper).Should().BeTrue();

actual.Should().BeInRange(lower, upper);

Expected True, but found False.

Expected value to be between 1 and 5, but found 6.

Assertion Improvement
(lower <= actual && actual <= upper).Should().BeFalse();

actual.Should().NotBeInRange(lower, upper);

Expected False, but found True.

Expected value to not be between 1 and 5, but found 4.

DateTimes

Dictionaries

Assertion Improvement
actual.ContainsKey(expected).Should().BeTrue();

actual.Should().ContainKey(expected);

Expected True, but found False.

Expected dictionary {[0, ]} to contain key 1.

Assertion Improvement
actual.ContainsKey(expected).Should().BeFalse();

actual.Should().NotContainKey(expected);

Expected False, but found True.

Dictionary {[0, ]} should not contain key 0, but found it anyhow.

Assertion Improvement
actual.ContainsValue(expected).Should().BeTrue();

actual.Should().ContainValue(expected);

Expected True, but found False.

Expected dictionary {[0, ]} to contain value "expected".

Assertion Improvement
actual.ContainsValue(expected).Should().BeFalse();

actual.Should().NotContainValue(expected);

Expected False, but found True.

Dictionary {[0, expected]} should not contain value "expected", but found it anyhow.

Assertion Improvement
actual.Should().ContainKey(expectedKey)
    .And.ContainValue(expectedValue);

actual.Should().Contain(expectedKey, expectedValue);

Expected dictionary {[0, ]} to contain value "expected".

Expected dictionary to contain value "expected" at key 0, but found "".

Assertion Improvement
actual.Should().ContainKey(expected.Key)
    .And.ContainValue(expected.Value);

actual.Should().Contain(expected);

Expected dictionary {[0, ]} to contain value "expected".

Expected dictionary to contain value "expected" at key 0, but found "".

Exceptions

Assertion Improvement
Action act = () => func();

act.ShouldThrowExactly<InvalidOperationException>()
    .Which.Message.Should().Contain("expectedMessage");

Action act = () => func();

// using wildcards
act.ShouldThrowExactly<InvalidOperationException>()
    .WithMessage("*expectedMessage*");

Expected string "Problems, errorCode2 and more Problems" to contain "errorCode1".

Expected exception message to match the equivalent of 
"*errorCode1*", but 
"Problems, errorCode2 and more Problems" does not.

Nullables

Assertion Improvement
actual.HasValue.Should().BeTrue();

actual.Should().HaveValue();

Expected True, but found False.

Expected a value.

Assertion Improvement
actual.HasValue.Should().BeFalse();

actual.Should().NotHaveValue();

Expected False, but found True.

Did not expect a value, but found 1.

Strings

Assertion Improvement
actual.StartsWith(expectedPrefix).Should().BeTrue();

actual.Should().StartWith(expectedPrefix);

Expected True, but found False.

Expected string to start with 
"Expected", but 
"ActualString" differs near "Act" (index 0).

Assertion Improvement
actual.EndsWith(expectedSuffix).Should().BeTrue();

actual.Should().EndWith(expectedSuffix);

Expected True, but found False.

Expected string "ActualString" to end with "Expected".

Assertion Improvement
actual.Should().NotBeNull().And.NotBeEmpty();

actual.Should().NotBeNullOrEmpty();

Did not expect empty string.

Expected string not to be <null> or empty, but found "".

Assertion Improvement
string.IsNullOrEmpty(actual).Should().BeTrue();

actual.Should().BeNullOrEmpty();

Expected True, but found False.

Expected string to be <null> or empty, but found "Actual".

Assertion Improvement
string.IsNullOrEmpty(actual).Should().BeFalse();

actual.Should().NotBeNullOrEmpty();

Expected False, but found True.

Expected string not to be <null> or empty, but found "".

Assertion Improvement
string.IsNullOrWhiteSpace(actual).Should().BeTrue();

actual.Should().BeNullOrWhiteSpace();

Expected True, but found False.

Expected string to be <null> or whitespace, but found "Actual".

Assertion Improvement
string.IsNullOrWhiteSpace(actual).Should().BeFalse();

actual.Should().NotBeNullOrWhiteSpace();

Expected False, but found True.

Expected string not to be <null> or whitespace, but found " ".

Assertion Improvement
actual.Length.Should().Be(k);

actual.Should().HaveLength(k);

Expected value to be 4, but found 6.

Expected string with length 4, but found string "Actual" with length 6.

Types

Assertion Improvement
actual.GetType().Should().Be(typeof(T));

actual.Should().BeOfType<T>();

Expected type to be UnitTests2.MyClass, but found UnitTests2.MyIdenticalClass.

Expected type to be UnitTests2.MyClass, but found UnitTests2.MyIdenticalClass.

Assertion Improvement
actual.GetType().Should().NotBe(typeof(T));

actual.Should().NotBeOfType<T>();

Expected type not to be [UnitTests2.MyClass, UnitTests2, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null], but it is.

Expected type not to be [UnitTests2.MyClass, UnitTests2, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null], but it is.

Assertion Improvement
(actual is T).Should().BeTrue();

actual.Should().BeAssignableTo<T>();

Expected True, but found False.

Expected object to be assignable to UnitTests2.MyClass, but UnitTests2.MyIdenticalClass is not.

Assertion Improvement
(actual as T).Should().NotBeNull();

actual.Should().BeAssignableTo<T>();

Expected object not to be <null>.

Expected object to be assignable to UnitTests2.MyClass, but UnitTests2.MyIdenticalClass is not.

Assertion Improvement
(actual is T).Should().BeFalse();

actual.Should().NotBeAssignableTo<T>();

Expected False, but found True.

Expected object to not be assignable to UnitTests2.MyClass, but UnitTests2.MyClass is.

Assertion Improvement
(actual as T).Should().BeNull();

actual.Should().NotBeAssignableTo<T>();

Expected object to be <null>, but found SomeProperty: 1, OtherProperty: actual.

Expected object to not be assignable to UnitTests2.MyClass, but UnitTests2.MyClass is.

MSTest Migration

The examples below show how you might write equivalent MSTest assertions using Fluent Assertions including the failure message from each case. We think this is both a useful migration guide and a convincing argument for switching.

If you see something missing, please consider submitting a pull request.

Assert

MSTest Fluent Assertions
Assert.IsTrue(actual);

actual.Should().BeTrue();

Assert.IsTrue failed.

Expected True, but found False.

MSTest Fluent Assertions
Assert.IsFalse(actual);

actual.Should().BeFalse();

Assert.IsFalse failed.

Expected False, but found True.

MSTest Fluent Assertions
Assert.IsNull(actual);

actual.Should().BeNull();

Assert.IsNull failed.

Expected object to be <null>, but found System.Object (HashCode=51904525).

MSTest Fluent Assertions
Assert.IsNotNull(actual);

actual.Should().NotBeNull();

Assert.IsNotNull failed.

Expected object not to be <null>.

MSTest Fluent Assertions
Assert.AreEqual(expected, actual);

actual.Should().Be(expected);

Assert.AreEqual failed. Expected:<SomeProperty: 2, OtherProperty: expected>. Actual:<SomeProperty: 1, OtherProperty: actual>.

Expected object to be SomeProperty: 2, OtherProperty: expected, but found SomeProperty: 1, OtherProperty: actual.

MSTest Fluent Assertions
Assert.AreEqual(expected, actual, delta);

actual.Should().BeApproximately(expected, delta);

Assert.AreEqual failed. Expected a difference no greater than <0.5> between expected value <2> and actual value <1.25>.

Expected value 1.25 to approximate 2.0 +/- 0.5, but it differed by 0.75.

MSTest Fluent Assertions
Assert.AreNotEqual(expected, actual);

actual.Should().NotBe(expected);

Assert.AreNotEqual failed. Expected any value except:<SomeProperty: 1, OtherProperty: expected>. Actual:<SomeProperty: 1, OtherProperty: expected>.

Did not expect object to be equal to SomeProperty: 1, OtherProperty: expected.

MSTest Fluent Assertions
Assert.AreNotEqual(expected, actual, delta);

actual.Should().NotBeApproximately(expected, delta);

Assert.AreNotEqual failed. Expected a difference greater than <0.5> between expected value <2> and actual value <2>.

Expected value 2.0 to not approximate 2.0 +/- 0.5, but it only differed by 0.0.

MSTest Fluent Assertions
Assert.AreSame(expected, actual);

actual.Should().BeSameAs(expected);

Assert.AreSame failed.

Expected object to refer to 
SomeProperty: 1, OtherProperty: actual, but found 
SomeProperty: 1, OtherProperty: actual.

MSTest Fluent Assertions
Assert.AreNotSame(expected, actual);

actual.Should().NotBeSameAs(expected);

Assert.AreNotSame failed.

Did not expect reference to object SomeProperty: 1, OtherProperty: actual.

MSTest Fluent Assertions
Assert.IsInstanceOfType(actual, typeof(T));

actual.Should().BeOfType<T>();

Assert.IsInstanceOfType failed.  Expected type:<UnitTests2.MyIdenticalClass>. Actual type:<UnitTests2.MyClass>.

Expected type to be UnitTests2.MyIdenticalClass, but found UnitTests2.MyClass.

MSTest Fluent Assertions
Assert.IsNotInstanceOfType(actual, typeof(T));

actual.Should().NotBeOfType<T>();

Assert.IsNotInstanceOfType failed. Wrong Type:<UnitTests2.MyClass>. Actual type:<UnitTests2.MyClass>.

Expected type not to be [UnitTests2.MyClass, UnitTests2, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null], but it is.

MSTest Fluent Assertions
Assert.IsTrue(actual == expected);

// refer to the exact same object in memory
actual.Should().BeSameAs(expected);

Assert.IsTrue failed.

Expected object to refer to 
SomeProperty: 2, OtherProperty: expected, but found 
SomeProperty: 1, OtherProperty: actual.

MSTest Fluent Assertions
Assert.IsFalse(actual == expected);

// refer to the different object in memory
actual.Should().NotBeSameAs(expected);

Assert.IsFalse failed.

Did not expect reference to object 
SomeProperty: 1, OtherProperty: expected.

MSTest Fluent Assertions
Assert.IsTrue(actual != expected);

// refer to the different object in memory
actual.Should().NotBeSameAs(expected);

Assert.IsTrue failed.

Did not expect reference to object 
SomeProperty: 1, OtherProperty: expected.

MSTest Fluent Assertions
Assert.IsFalse(actual != expected);

// refer to the exact same object in memory
actual.Should().BeSameAs(expected)

Assert.IsFalse failed.

Expected object to refer to 
SomeProperty: 2, OtherProperty: expected, but found 
SomeProperty: 1, OtherProperty: actual.

MSTest Fluent Assertions
Assert.IsTrue(actual > expected);

actual.Should().BeGreaterThan(expected);

Assert.IsTrue failed.

Expected a value greater than 2, but found 1.

MSTest Fluent Assertions
Assert.IsFalse(actual > expected);

actual.Should().BeLessOrEqualTo(expected);

Assert.IsFalse failed.

Expected a value less or equal to 1, but found 2.

MSTest Fluent Assertions
Assert.IsTrue(actual >= expected);

actual.Should().BeGreaterOrEqualTo(expected);

Assert.IsTrue failed.

Expected a value greater or equal to 2, but found 1.

MSTest Fluent Assertions
Assert.IsFalse(actual >= expected);

actual.Should().BeLessThan(expected);

Assert.IsFalse failed.

Expected a value less than 1, but found 2.

MSTest Fluent Assertions
Assert.IsTrue(actual < expected);

actual.Should().BeLessThan(expected);

Assert.IsTrue failed.

Expected a value less than 1, but found 2.

MSTest Fluent Assertions
Assert.IsFalse(actual < expected);

actual.Should().BeGreaterOrEqualTo(expected);

Assert.IsFalse failed.

Expected a value greater or equal to 2, but found 1.

MSTest Fluent Assertions
Assert.IsTrue(actual <= expected);

actual.Should().BeLessOrEqualTo(expected);

Assert.IsTrue failed.

Expected a value less or equal to 1, but found 2.

MSTest Fluent Assertions
Assert.IsFalse(actual <= expected);

actual.Should().BeGreaterThan(expected);

Assert.IsFalse failed.

Expected a value greater than 2, but found 1.

CollectionAssert

MSTest Fluent Assertions
CollectionAssert.AllItemsAreUnique(actual);

actual.Should().OnlyHaveUniqueItems();

CollectionAssert.AllItemsAreUnique failed. Duplicate item found:<SomeProperty: 1, OtherProperty: item>.

Expected collection to only have unique items, but item SomeProperty: 1, OtherProperty: item is not unique.

MSTest Fluent Assertions
CollectionAssert.AreEqual(expected, actual);

actual.Should().Equal(expected);

CollectionAssert.AreEqual failed. (Element at index 0 do not match.)

Expected collection to be equal to {SomeProperty: 1, OtherProperty: item}, but {SomeProperty: 1, OtherProperty: different} differs at index 0.

MSTest Fluent Assertions
CollectionAssert.AreNotEqual(expected, actual);

actual.Should().NotEqual(expected);

CollectionAssert.AreNotEqual failed. (Both collection contain same elements.)

Did not expect collections {SomeProperty: 1, OtherProperty: item} and {SomeProperty: 1, OtherProperty: item} to be equal.

MSTest Fluent Assertions
CollectionAssert.AreEquivalent(expected, actual);

actual.Should().BeEquivalentTo(expected);

CollectionAssert.AreEquivalent failed. The expected collection contains 1 occurrence(s) of <SomeProperty: 2, OtherProperty: other>. The actual collection contains 0 occurrence(s).

Expected collection {SomeProperty: 1, OtherProperty: item, SomeProperty: 2, OtherProperty: item} to be equivalent to {SomeProperty: 1, OtherProperty: item, SomeProperty: 2, OtherProperty: other}, but it misses {SomeProperty: 2, OtherProperty: other}.

MSTest Fluent Assertions
CollectionAssert.AreNotEquivalent(expected, actual);

actual.Should().NotBeEquivalentTo(expected);

CollectionAssert.AreNotEquivalent failed. Both collections contain the same elements.

Expected collection {SomeProperty: 1, OtherProperty: item, SomeProperty: 2, OtherProperty: other} not be equivalent with collection {SomeProperty: 1, OtherProperty: item, SomeProperty: 2, OtherProperty: other}.

MSTest Fluent Assertions
CollectionAssert.Contains(actual, expected);

actual.Should().Contain(expected);

CollectionAssert.Contains failed.

Expected collection {SomeProperty: 2, OtherProperty: other} to contain SomeProperty: 1, OtherProperty: item.

MSTest Fluent Assertions
CollectionAssert.DoesNotContain(actual, expected);

actual.Should().NotContain(expected);

CollectionAssert.DoesNotContain failed.

Expected collection {SomeProperty: 1, OtherProperty: item} to not contain SomeProperty: 1, OtherProperty: item.

MSTest Fluent Assertions
CollectionAssert.IsSubsetOf(actual, expectedSuperset);

actual.Should().BeSubsetOf(expectedSuperset);

CollectionAssert.IsSubsetOf failed.

Expected collection to be a subset of {SomeProperty: 1, OtherProperty: item}, but items {SomeProperty: 2, OtherProperty: other} are not part of the superset.

MSTest Fluent Assertions
CollectionAssert.IsNotSubsetOf(actual, expectedSuperset);

actual.Should().NotBeSubsetOf(expectedSuperset);

CollectionAssert.IsNotSubsetOf failed.

Did not expect collection {SomeProperty: 1, OtherProperty: item} to be a subset of {SomeProperty: 1, OtherProperty: item}.

MSTest Fluent Assertions
CollectionAssert.AllItemsAreNotNull(actual);

actual.Should().NotContainNulls();

CollectionAssert.AllItemsAreNotNull failed.

Expected collection not to contain nulls, but found one at index 0.

MSTest Fluent Assertions
CollectionAssert.AllItemsAreInstancesOfType(actual, typeof(T));

actual.Should().ContainItemsAssignableTo<T>();

CollectionAssert.AllItemsAreInstancesOfType failed. Element at index 0 is not of expected type. Expected type:<UnitTests2.MyIdenticalClass>. Actual type:<UnitTests2.MyClass>.

Expected collection to contain only items of type UnitTests2.MyIdenticalClass, but item SomeProperty: 1, OtherProperty: item at index 0 is of type UnitTests2.MyClass.

StringAssert

MSTest Fluent Assertions
StringAssert.Contains(actual, expectedSubstring);

actual.Should().Contain(expectedSubstring);

StringAssert.Contains failed. String 'SomeLongString' does not contain string 'Short'. .

Expected string "SomeLongString" to contain "Short".

MSTest Fluent Assertions
StringAssert.StartWith(actual, expectedPrefix);

actual.Should().StartWith(expectedPrefix);

StringAssert.StartsWith failed. String 'LongString' does not start with string 'Short'. .

Expected string to start with 
"Short", but 
"LongString" differs near "Lon" (index 0).

MSTest Fluent Assertions
StringAssert.EndsWith(actual, expectedSuffix);

actual.Should().EndWith(expectedSuffix);

StringAssert.EndsWith failed. String 'StringLong' does not end with string 'Short'. .

Expected string "StringLong" to end with "Short".

MSTest Fluent Assertions
StringAssert.Matches(actual, expectedPattern);

actual.Should().MatchRegex(expectedPattern);

StringAssert.Matches failed. String 'SomeLong' does not match pattern '.*String.*'. .

Expected string to match regex 
".*String.*", but 
"SomeLong" does not match.

MSTest Fluent Assertions
StringAssert.DoesNotMatch(actual, expectedPattern);

actual.Should().NotMatchRegex(expectedPattern);

StringAssert.DoesNotMatch failed. String 'SomeStringLong' matches pattern '.*String.*'. .

Did not expect string to match regex 
".*String.*", but 
"SomeStringLong" matches.

Exceptions

MSTest Fluent Assertions
[ExpectedException(typeof(InvalidOperationException))]
public void MyTest()
{
    func();
}

public void MyTest()
{
    Action act = () => func();

    act.ShouldThrowExactly<InvalidOperationException>();
}

Test method threw exception System.InvalidCastException, but exception System.ArgumentNullException was expected. Exception System.InvalidCastException: Specified cast is not valid.

Expected a <System.ArgumentNullException> to be thrown, but found a <System.InvalidCastException>: System.InvalidCastException with message "Specified cast is not valid."
     at UnitTests2.ExceptionTests.<>c.<Snippet01_New>b__1_0() in C:\Path\To\UnitTests\ExceptionTests.cs:line 31
     at UnitTests2.ExceptionTests.<>c__DisplayClass1_0.<Snippet01_New>b__1() in C:\Path\To\UnitTests\ExceptionTests.cs:line 34
     at FluentAssertions.Specialized.ActionAssertions
       .InvokeSubjectWithInterception()
.

MSTest Fluent Assertions
Action act = () => func();

// MSTest V2
Assert.ThrowsException<InvalidOperationException>(act);

Action act = () => func();

act.ShouldThrowExactly<InvalidOperationException>();

Assert.ThrowsException failed. Threw exception InvalidCastException, but exception ArgumentNullException was expected. 
Exception Message: Specified cast is not valid.
Stack Trace:    at UnitTests2.ExceptionTests.<>c.<Snippet01v2_Old>b__2_0() in C:\Path\To\UnitTests\ExceptionTests.cs:line 44
   at UnitTests2.ExceptionTests.<>c__DisplayClass2_0.<Snippet01v2_Old>b__1() in C:\Path\To\UnitTests\ExceptionTests.cs:line 47
   at Microsoft.VisualStudio.TestTools.UnitTesting.Assert
     .ThrowsException[T](Action action, String message, Object[] parameters)

Expected a <System.ArgumentNullException> to be thrown, but found a <System.InvalidCastException>: System.InvalidCastException with message "Specified cast is not valid."
     at UnitTests2.ExceptionTests.<>c.<Snippet01_New>b__1_0() in C:\Path\To\UnitTests\ExceptionTests.cs:line 31
     at UnitTests2.ExceptionTests.<>c__DisplayClass1_0.<Snippet01_New>b__1() in C:\Path\To\UnitTests\ExceptionTests.cs:line 34
     at FluentAssertions.Specialized.ActionAssertions
       .InvokeSubjectWithInterception()
.

MSTest Fluent Assertions
[ExpectedException(typeof(SystemException),
                   AllowDerivedTypes = true)]
public void MyTest()
{
    func();
}

public void MyTest()
{
    Action act = () => func();

    act.ShouldThrow<InvalidOperationException>();
}

Test method threw exception System.InvalidCastException, but exception System.ArgumentException or a type derived from it was expected. Exception System.InvalidCastException: Specified cast is not valid.

Expected a <System.ArgumentException> to be thrown, but found a <System.InvalidCastException>: System.InvalidCastException with message "Specified cast is not valid."
     at UnitTests2.ExceptionTests.<>c.<Snippet02_New>b__3_0() in C:\Path\To\UnitTests\ExceptionTests.cs:line 57
     at UnitTests2.ExceptionTests.<>c__DisplayClass3_0.<Snippet02_New>b__1() in C:\Path\To\UnitTests\ExceptionTests.cs:line 60
     at FluentAssertions.Specialized
        .ActionAssertions.InvokeSubjectWithInterception().

MSTest Fluent Assertions
[ExpectedException(typeof(InvalidOperationException))]
public void MyTest()
{
    try
    {
        func();
    }
    catch (InvalidOperationException ex)
    {
        ex.Message.Should().Be(errorMessage);
        throw;
    }
}

public void MyTest()
{
    Action act = () => func();

    act.ShouldThrowExactly<InvalidOperationException>()
        .WithMessage(errorMessage);
}

Expected string to be 
"expectedMessage" with a length of 15, but 
"actualMessage" has a length of 13.

Expected exception message to match the equivalent of 
"expectedMessage", but 
"actualMessage" does not.