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

Assertion Improvement 
actual.Date.Should().Be(expected.Date);


actual.Should().BeSameDateAs(expected);


Expected date and time to be <2017-01-01>, but found <2017-01-02>.


Expected a date and time with date <2017-01-01>, but found <2017-01-02 21:00:00>.
Assertion Improvement 
actual.Date.Should().NotBe(unexpected.Date);


actual.Should().NotBeSameDateAs(unexpected);


Expected date and time not to be <2017-01-01>, but it is.


Expected a date and time that does not have date <2017-01-01>, but found it does.
Assertion Improvement 
actual.Year.Should().Be(expected.Year);


actual.Should().HaveYear(expected.Year);


Expected actual.Year to be 2018, but found 2017 (difference of -1).


Expected the year part of actual to be 2018, but found 2017.
Assertion Improvement 
actual.Year.Should().NotBe(unexpected.Year);


actual.Should().NotHaveYear(unexpected.Year);


Did not expect the year part of actual to be 2017, but it was.


Did not expect actual.Year to be 2017.
Assertion Improvement 
actual.Month.Should().Be(expected.Month);


actual.Should().HaveMonth(expected.Month);


Expected actual.Month to be 2, but found 1.


Expected the month part of actual to be 2, but found 1.
Assertion Improvement 
actual.Month.Should().NotBe(unexpected.Month);


actual.Should().NotHaveMonth(unexpected.Month);


Did not expect actual.Month to be 1.


Did not expect the month part of actual to be 1, but it was.
Assertion Improvement 
actual.Day.Should().Be(expected.Day);


actual.Should().HaveDay(expected.Day);


Expected actual.Day to be 2, but found 1.


Expected the day part of actual to be 2, but found 1.
Assertion Improvement 
actual.Day.Should().NotBe(unexpected.Day);


actual.Should().NotHaveDay(unexpected.Day);


Did not expect actual.Day to be 1.


Did not expect the day part of actual to be 1, but it was.
Assertion Improvement 
actual.Hour.Should().Be(expected.Hour);


actual.Should().HaveHour(expected.Hour);


Expected actual.Hour to be 19, but found 16 (difference of -3).


Expected the hour part of actual to be 19, but found 16.
Assertion Improvement 
actual.Hour.Should().NotBe(unexpected.Hour);


actual.Should().NotHaveHour(unexpected.Hour);


Did not expect actual.Hour to be 16.


Did not expect the hour part of actual to be 16, but it was.
Assertion Improvement 
actual.Minute.Should().Be(expected.Minute);


actual.Should().HaveMinute(expected.Minute);


Expected actual.Minute to be 31, but found 30 (difference of -1).


Expected the minute part of actual to be 31, but found 30.
Assertion Improvement 
actual.Minute.Should().NotBe(unexpected.Minute);


actual.Should().NotHaveMinute(unexpected.Minute);


Did not expect actual.Minute to be 30.


Did not expect the minute part of actual to be 30, but it was.
Assertion Improvement 
actual.Second.Should().Be(expected.Second);


actual.Should().HaveSecond(expected.Second);


Expected actual.Second to be 18, but found 17 (difference of -1).


Expected the seconds part of actual to be 18, but found 17.
Assertion Improvement 
actual.Second.Should().NotBe(unexpected.Second);


actual.Should().NotHaveSecond(unexpected.Second);


Did not expect actual.Second to be 17.


Did not expect the seconds part of actual to be 17, but it was.

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 = () => throw new InvalidOperationException("Problems, errorCode2 and more Problems");

act.Should().ThrowExactly<InvalidOperationException>()
    .Which.Message.Should().Contain("errorCode1");


Action act = () => throw new InvalidOperationException("Problems, errorCode2 and more Problems");

// using wildcards
act.Should().ThrowExactly<InvalidOperationException>()
    .WithMessage("*errorCode1*");


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.
Assertion Improvement 
Action act = () => throw new InvalidOperationException("Problems, errorCode2 and more Problems");

act.Should().Throw<Exception>()
    .Which.Message.Should().Contain("errorCode1");


Action act = () => throw new InvalidOperationException("Problems, errorCode2 and more Problems");

// using wildcards
act.Should().Throw<Exception>()
    .WithMessage("*errorCode1*");


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.
Assertion Improvement 
Action act = () => throw new Exception("Problems, errorCode2 and more Problems", new InvalidOperationException());

act.Should().Throw<Exception>()
    .Which.InnerException.Should().BeAssignableTo<ArgumentException>();


Action act = () => throw new Exception("Problems, errorCode2 and more Problems", new InvalidOperationException());

act.Should().Throw<Exception>()
    .WithInnerException<ArgumentException>();


Expected action to be assignable to System.ArgumentException, but System.InvalidOperationException is not.


Expected inner System.ArgumentException, but found System.InvalidOperationException with message "Operation is not valid due to the current state of the object."
Assertion Improvement 
Action act = () => throw new Exception("Problems, errorCode2 and more Problems", new ArgumentNullException());

act.Should().Throw<Exception>()
    .Which.InnerException.Should().BeOfType<ArgumentException>();


Action act = () => throw new Exception("Problems, errorCode2 and more Problems", new ArgumentNullException());

act.Should().Throw<Exception>()
    .WithInnerExceptionExactly<ArgumentException>();


Expected type to be System.ArgumentException, but found System.ArgumentNullException.


Expected inner System.ArgumentException, but found System.ArgumentNullException with message "Value cannot be null."

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().AllBeAssignableTo<T>();


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


Expected type to be "T", but found [System.String],

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.Should().ThrowExactly<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.Should().ThrowExactly<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.Should().Throw<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.Should().ThrowExactly<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.