When writing unit tests, having assertions is a fundamental requirement. They are, ultimately, the "test" part of a unit test. But many developers are
unfamiliar with the assertion libraries that come with the popular unit testing frameworks, so don't get the full range of their benefits.
Too many times in my career, I've seen developer exclusively utilize Assert.True(...) with some conditional check inside it.
And while this will fail the test when the conditional is no longer met, all you get from the failure is a message that says:
Expected: True But was: FalseWhich means to even figure out what's wrong, you have to, at minimum, look at the unit test code to see what it was even testing.
My hope is that, after reading through this post (and bookmarking it for frequent reference), you'll be able to write unit tests that easily provide you with enough detail in the failure messages that you can make some educated guesses about why it's failing without ever looking at the code.
For example, here's some NUnit failure messages -- can you guess what the test was attempting to validate?
Expected: 100 +/- 8 Percent But was: 91
Expected: equivalent to < "bar", "baz" > But was: < "foo", "bar", "baz", "bin", <string.Empty> > Extra (3): < "foo" , "bin" , <string.Empty> >
In this post, I cover the assertion options and syntax for each of the three most popular .NET unit testing frameworks: NUnit, xUnit and MSTest. Plus, I throw in a few personal opinions about the frameworks along the way.
The Framework Options
Here are the three frameworks I'm going to focus on in this post:
NUnit Note: NUnit has two variants of it's syntax, which I will call "NUnit Constraint" (or just "NUnit") and "NUnit Classic" styles.
XUnit.net
MSTest (Visual Studio)
Personally, I greatly prefer the NUnit Constraint-style asserts and will push to use NUnit on any project I can because of this. NUnit's Constraint-style assert syntax is the easiest to read, has the most useful out-of-the-box failure messages (particularly for dealing with collections), and has more features built-in than the other options.
xUnit.net has become the preferred testing framework for the Microsoft .NET codebase, and the framework itself has some nice features, but it still lags a bit behind NUnit in my opinion.
MSTest is easily my least favorite, as it has the worst documentation, the least features, and the syntax is a bit clunky. But it has the huge benefit of being built-in to Visual Studio, so takes the least effort to get up-and-running, though NuGet packages make the other two extremely simple as well.
All three frameworks support both the .NET Full Framework and .NET Core/netstandard, so you shouldn't have any issues using them across all your projects.
How Asserts Work
The implementation for asserts are pretty straightforward. Unit tests will fail if an unexpected and uncaught Exception occurs. The failure message reported by the
testing framework is the Exception.Message value. (Plus, most framework runners will also show you the full stacktrace of the Exception).
So Asserts are just shortcuts for throwing an Exception when a comparison isn't true. In most cases, the Assert methods will take in an "expected" value (ie: what you want the result to be if your code is working correctly), an "actual" value (ie: the value your code actually generated), and an optional "message". Given those inputs, the Assert method will compare the actual value to the expected value and if the comparison fails, it will generated an Exception with a Message field that contains some hopefully useful information about the actual and expected values and the comparison attempted, as well as the additional "message" if you provided one.
So if you take the case of Assert.That(actual, Is.GreaterThan(5)), you could just as well write this code to get the same result:
if (actual < 5) throw new Exception("Expected a value greater than 5, but got " + actual)
Syntax Examples
When it comes to syntax, the NUnit Constraint-style syntax is different than the others -- something I think makes it much more readable and usable.
xUnit.net, MSTest and the NUnit Classic-style assertions all follow the pattern of Assert.Something(expectedValue, actualValue). The NUnit Constraint-style
syntax attempts to read more like an English-language sentence, like Assert.That(actualValue, Is.SomethingTo(expectedValue)).
A word about custom messages
All of the assertion options allow you to provide a custom message to show in addition to the assertion's own output upon failure. This message optional but is the most effective way of providing useful output when your tests fail, since you can add whatever data you deem important at the time you're writing the test.
But, we're all generally pretty lazy when it comes to writing unit tests, and in my experience we'll only include a custom message on rare occasions. The rest of the time, we rely on the default output from the assertions themselves.
In those cases where you do want to provide your own messages, the assertion methods take a final string parameter that you can use to provide that message, like this:
Assert.GreaterOrEqual(0, price, "Price should never be less than 0");. This way your output can explain the failure with output like this:
Price should never be less than 0 Expected: greater than or equal to 0 But was: -2.52
Equality Checks
This first set of equality checks are effectively checking object.Equals() to determine if the two values are equal.
/// <summary>
/// Assertions that test for equality using object.Equals() to compare the actual value
/// to the expected value
/// </summary>
[Test]
public void EqualityChecks()
{
bool valueToTest_bool = true;
string valueToTest_string = "some result";
DateTime valueToTest_datetime = new DateTime(2019, 01, 01);
var valueToTest_obj = new { Foo = "bar", Baz = true };
var expectedValue_obj_equal = new { Foo = "bar", Baz = true };
var expectedValue_obj_notequal = new { Foo = "zoom", Baz = false }; ;
Assert.That(valueToTest_bool, Is.EqualTo(true));
Assert.That(valueToTest_string, Is.EqualTo("some result"));
Assert.That(valueToTest_datetime, Is.EqualTo(new DateTime(2019, 01, 01)));
Assert.That(valueToTest_obj, Is.EqualTo(expectedValue_obj_equal));
Assert.That(valueToTest_bool, Is.Not.EqualTo(false));
Assert.That(valueToTest_string, Is.Not.EqualTo("some other result"));
Assert.That(valueToTest_datetime, Is.Not.EqualTo(new DateTime(2019, 12, 01)));
Assert.That(valueToTest_obj, Is.Not.EqualTo(expectedValue_obj_notequal));
}
Sample Output:
Expected: <{ Foo=zoom, Baz=False }>
But was: <{ Foo=bar, Baz=True }>
Expected: not equal to 2019-01-01 00:00:00
But was: 2019-01-01 00:00:00
Expected string length 17 but was 11. Strings differ at index 5.
Expected: "some other result"
But was: "some result"
----------------^
Note that the string comparison has an "arrow" showing where the different occurred.
/// <summary>
/// Assertions that test for equality using object.Equals() to compare the actual value
/// to the expected value
/// </summary>
[Test]
public void EqualityChecks()
{
bool valueToTest_bool = true;
string valueToTest_string = "some result";
DateTime valueToTest_datetime = new DateTime(2019, 01, 01);
var valueToTest_obj = new { Foo = "bar", Baz = true };
var expectedValue_obj_equal = new { Foo = "bar", Baz = true };
var expectedValue_obj_notequal = new { Foo = "zoom", Baz = false }; ;
// (important: expected value comes first!)
Assert.AreEqual(true, valueToTest_bool);
Assert.AreEqual("some result", valueToTest_string);
Assert.AreEqual(new DateTime(2019, 01, 01), valueToTest_datetime);
Assert.AreEqual(expectedValue_obj_equal, valueToTest_obj);
Assert.AreNotEqual(false, valueToTest_bool);
Assert.AreNotEqual("some other result", valueToTest_string);
Assert.AreNotEqual(new DateTime(2019, 12, 01), valueToTest_datetime);
Assert.AreNotEqual(expectedValue_obj_notequal, valueToTest_obj);
}
Sample Output:
Expected: <{ Foo=zoom, Baz=False }>
But was: <{ Foo=bar, Baz=True }>
Expected: not equal to 2019-01-01 00:00:00
But was: 2019-01-01 00:00:00
Expected string length 17 but was 11. Strings differ at index 5.
Expected: "some other result"
But was: "some result"
----------------^
Note that the string comparison has an "arrow" showing where the different occurred.
/// <summary>
/// Assertions that test for equality using object.Equals() to compare the actual value
/// to the expected value
/// </summary>
[Fact]
public void EqualityChecks()
{
string valueToTest_string = "some result";
DateTime valueToTest_datetime = new DateTime(2019, 01, 01);
var valueToTest_obj = new { Foo = "bar", Baz = true };
var expectedValue_obj_equal = new { Foo = "bar", Baz = true };
var expectedValue_obj_notequal = new { Foo = "zoom", Baz = false }; ;
// (important: expected value comes first!)
Assert.Equal("some result", valueToTest_string);
Assert.Equal(new DateTime(2019, 01, 01), valueToTest_datetime);
Assert.Equal(expectedValue_obj_equal, valueToTest_obj);
Assert.NotEqual("some other result", valueToTest_string);
Assert.NotEqual(new DateTime(2019, 12, 01), valueToTest_datetime);
Assert.NotEqual(expectedValue_obj_notequal, valueToTest_obj);
}
Sample Output:
Xunit.Sdk.EqualException: Assert.Equal() Failure
Expected: { Foo = zoom, Baz = False }
Actual: { Foo = bar, Baz = True }
Xunit.Sdk.NotEqualException: Assert.NotEqual() Failure
Expected: Not 2019-01-01T00:00:00.0000000
Actual: 2019-01-01T00:00:00.0000000
Xunit.Sdk.EqualException: Assert.Equal() Failure
↓ (pos 5)
Expected: some other result
Actual: some result
↑ (pos 5)
Note that the string comparison has an "arrow" showing where the different occurred.
/// <summary>
/// Assertions that test for equality using object.Equals() to compare the actual value
/// to the expected value
/// </summary>
[TestMethod]
public void EqualityChecks()
{
bool valueToTest_bool = true;
string valueToTest_string = "some result";
DateTime valueToTest_datetime = new DateTime(2019, 01, 01);
var valueToTest_obj = new { Foo = "bar", Baz = true };
var expectedValue_obj_equal = new { Foo = "bar", Baz = true };
var expectedValue_obj_notequal = new { Foo = "zoom", Baz = false }; ;
// (important: expected value comes first!)
Assert.AreEqual(true, valueToTest_bool);
Assert.AreEqual("some result", valueToTest_string);
Assert.AreEqual(new DateTime(2019, 01, 01), valueToTest_datetime);
Assert.AreEqual(expectedValue_obj_equal, valueToTest_obj);
Assert.AreNotEqual(false, valueToTest_bool);
Assert.AreNotEqual("some other result", valueToTest_string);
Assert.AreNotEqual(new DateTime(2019, 12, 01), valueToTest_datetime);
Assert.AreNotEqual(expectedValue_obj_notequal, valueToTest_obj);
}
Sample Output:
Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: Assert.AreEqual failed. Expected:<{ Foo=zoom, Baz=False }>. Actual:<{ Foo=bar, Baz=True }>.
Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: Assert.AreNotEqual failed. Expected any value except:<1/1/2019 12:00:00 AM>. Actual:<1/1/2019 12:00:00 AM>.
Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: Assert.AreEqual failed. Expected:<some other result>. Actual:<some result>.
This second set of equality checks are utilizing object.ReferenceEquals() to determine if the two objects are actually referring to the same exact object in memory
/// <summary>
/// Assertions that test for equality using object.ReferenceEquals() to determine if both values point to
/// the exact same object.
/// </summary>
[Test]
public void SameObjectChecks()
{
var valueToTest = new {Foo = "bar", Baz = true};
var expectedValue_same = valueToTest;
var expectedValue_notsame = new { Foo = "bar", Baz = true }; ;
Assert.That(valueToTest, Is.SameAs(expectedValue_same));
Assert.That(valueToTest, Is.Not.SameAs(expectedValue_notsame));
}
Sample Output:
Expected: same as <{ Foo=bar, Baz=True }>
But was: <{ Foo=bar, Baz=True }>
Expected: not same as <{ Foo=bar, Baz=True }>
But was: <{ Foo=bar, Baz=True }>
/// <summary>
/// Assertions that test for equality using object.ReferenceEquals() to determine if both values point to
/// the exact same object.
/// </summary>
[Test]
public void SameObjectChecks()
{
var valueToTest = new {Foo = "bar", Baz = true};
var expectedValue_same = valueToTest;
var expectedValue_notsame = new { Foo = "bar", Baz = true }; ;
// (important: expected value comes first!)
Assert.AreSame(expectedValue_same, valueToTest);
Assert.AreNotSame(expectedValue_notsame, valueToTest);
}
Sample Output:
Expected: same as <{ Foo=bar, Baz=True }>
But was: <{ Foo=bar, Baz=True }>
Expected: not same as <{ Foo=bar, Baz=True }>
But was: <{ Foo=bar, Baz=True }>
/// <summary>
/// Assertions that test for equality using object.ReferenceEquals() to determine if both values point to
/// the exact same object.
/// </summary>
[Fact]
public void SameObjectChecks()
{
var valueToTest = new { Foo = "bar", Baz = true };
var expectedValue_same = valueToTest;
var expectedValue_notsame = new { Foo = "bar", Baz = true }; ;
// (important: expected value comes first!)
Assert.Same(expectedValue_same, valueToTest);
Assert.NotSame(expectedValue_notsame, valueToTest);
}
Sample Output:
Xunit.Sdk.SameException: Assert.Same() Failure
Expected: { Foo = bar, Baz = True }
Actual: { Foo = bar, Baz = True }
Xunit.Sdk.NotSameException: Assert.NotSame() Failure
/// <summary>
/// Assertions that test for equality using object.ReferenceEquals() to determine if both values point to
/// the exact same object.
/// </summary>
[TestMethod]
public void SameObjectChecks()
{
var valueToTest = new { Foo = "bar", Baz = true };
var expectedValue_same = valueToTest;
var expectedValue_notsame = new { Foo = "bar", Baz = true }; ;
// (important: expected value comes first!)
Assert.AreSame(expectedValue_same, valueToTest);
Assert.AreNotSame(expectedValue_notsame, valueToTest);
}
Sample Output:
Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: Assert.AreSame failed. Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: Assert.AreNotSame failed.
Comparision Checks
This first set will check your value against null
/// <summary>
/// Assertions that test for null values
/// </summary>
[Test]
public void NullChecks()
{
var valueToTest = new { Foo = (object) null, Baz = new object() };
Assert.That(valueToTest.Foo, Is.Null);
Assert.That(valueToTest.Baz, Is.Not.Null);
}
Sample Output:
Expected: not null But was: null Expected: null But was: <System.Object>
/// <summary>
/// Assertions that test for null values
/// </summary>
[Test]
public void NullChecks()
{
var valueToTest = new { Foo = (object) null, Baz = new object() };
Assert.Null(valueToTest.Foo);
Assert.IsNull(valueToTest.Foo);
Assert.NotNull(valueToTest.Baz);
Assert.IsNotNull(valueToTest.Baz);
}
Sample Output:
Expected: not null But was: null Expected: null But was: <System.Object>
/// <summary>
/// Assertions that test for null values
/// </summary>
[Fact]
public void NullChecks()
{
var valueToTest = new { Foo = (object)null, Baz = new object() };
Assert.Null(valueToTest.Foo);
Assert.NotNull(valueToTest.Baz);
}
Sample Output:
Xunit.Sdk.NotNullException: Assert.NotNull() Failure
Xunit.Sdk.NullException: Assert.Null() Failure
Expected: (null)
Actual: Object { }
/// <summary>
/// Assertions that test for null values
/// </summary>
[TestMethod]
public void NullChecks()
{
var valueToTest = new {Foo = (object) null, Baz = new object()};
Assert.IsNull(valueToTest.Foo);
Assert.IsNotNull(valueToTest.Baz);
}
Sample Output:
Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: Assert.IsNotNull failed. Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: Assert.IsNull failed.
This next set will compare values relative to each other (greater than, less than, etc).
A benefit of using NUnit
This is an area where I think NUnit really outshines the other frameworks. With the other frameworks,
you're mostly limited to Assert.IsTrue(some_condition), which only gives you a pass/fail
result. With NUnit's Constraint model, you get a much richer syntax that provides significantly more
detail in the built-in failure message.
Note that you can take it even further with NUnit and not just compare two values, but provide a
margin of error using the .Within() helpers. This is particularly helpful when comparing
floating-point numbers where the actual value may suffer from slight variations from your expected value.
/// <summary>
/// Assertions that compare the value to a set of constraints
/// </summary>
[Test]
public void ComparisonChecks()
{
int bigNumber = int.MaxValue;
int smallNumber = int.MinValue;
int zero = 0;
double notANumber = double.NaN; // NaN == 0D / 0D
double infinity = double.PositiveInfinity;
bool trueValue = true;
bool falseValue = false;
DateTime jan1 = new DateTime(2019, 01, 01);
Assert.That(bigNumber, Is.GreaterThan(smallNumber));
Assert.That(bigNumber, Is.GreaterThanOrEqualTo(smallNumber));
Assert.That(smallNumber, Is.LessThan(bigNumber));
Assert.That(smallNumber, Is.LessThanOrEqualTo(bigNumber));
Assert.That(trueValue, Is.True);
Assert.That(falseValue, Is.False);
Assert.That(bigNumber, Is.Positive);
Assert.That(bigNumber, Is.Not.Negative);
Assert.That(smallNumber, Is.Negative);
Assert.That(smallNumber, Is.Not.Positive);
Assert.That(zero, Is.Zero);
Assert.That(bigNumber, Is.Not.Zero);
Assert.That(notANumber, Is.NaN);
Assert.That(infinity, Is.Not.NaN);
Assert.That(zero, Is.InRange(-100, 5));
Assert.That(zero, Is.Not.InRange(1, 10));
Assert.That(jan1, Is.InRange(new DateTime(2018, 01, 01), new DateTime(2019, 12, 31)));
Assert.That(zero, Is.AnyOf(42, 0, 100));
Assert.That(2.333333d, Is.EqualTo(2.3).Within(0.5));
Assert.That(jan1, Is.EqualTo(new DateTime(2019, 01, 10)).Within(10).Days);
Assert.That(95, Is.EqualTo(100).Within(8).Percent);
}
Sample Output:
Expected: not greater than or equal to -2147483648 But was: 2147483647 Expected: less than 2147483647 But was: 2147483647 Expected: False But was: True Expected: 0 But was: 2147483647 Expected: NaN But was: ∞ Expected: in range (1,10) But was: 0 Expected: not in range (1/1/2018 12:00:00 AM,12/31/2019 12:00:00 AM) But was: 2019-01-01 00:00:00 Expected: any of < 42, 0, 100 > But was: 33 Expected: 5.2999999999999998d +/- 0.5d But was: 2.3333330000000001d Expected: not equal to 2019-01-10 00:00:00 +/- 10.00:00:00 But was: 2019-01-01 00:00:00 Expected: 100 +/- 8 Percent But was: 76
/// <summary>
/// Assertions that compare the value to a set of constraints
/// </summary>
[Test]
public void ComparisonChecks()
{
int bigNumber = int.MaxValue;
int smallNumber = int.MinValue;
int zero = 0;
double notANumber = double.NaN; // NaN == 0D / 0D
double infinity = double.PositiveInfinity;
bool trueValue = true;
bool falseValue = false;
Assert.Greater(bigNumber, smallNumber);
Assert.GreaterOrEqual(bigNumber, smallNumber);
Assert.Less(smallNumber, bigNumber);
Assert.LessOrEqual(smallNumber, bigNumber);
Assert.True(trueValue);
Assert.False(falseValue);
Assert.Positive(bigNumber);
Assert.Negative(smallNumber);
Assert.Zero(zero);
Assert.NotZero(bigNumber);
Assert.IsNaN(notANumber);
}
Sample Output:
Expected: greater than or equal to 2147483647 But was: -2147483648 Expected: less than -2147483648 But was: 2147483647 Expected: False But was: True Expected: 0 But was: 2147483647 Expected: NaN But was: ∞
/// <summary>
/// Assertions that compare the value to a set of constraints
/// </summary>
[Fact]
public void ComparisonChecks()
{
int bigNumber = int.MaxValue;
int smallNumber = int.MinValue;
int zero = 0;
double notANumber = double.NaN; // NaN == 0D / 0D
double infinity = double.PositiveInfinity;
bool trueValue = true;
bool falseValue = false;
DateTime jan1 = new DateTime(2019, 01, 01);
// Constraint-style asserts:
Assert.True(bigNumber > smallNumber);
Assert.True(bigNumber >= smallNumber);
Assert.True(smallNumber < bigNumber);
Assert.True(smallNumber <= bigNumber);
Assert.True(trueValue);
Assert.False(falseValue);
Assert.InRange(zero, -100, 5);
Assert.NotInRange(zero, 1, 10);
Assert.InRange(jan1, new DateTime(2018, 01, 01), new DateTime(2019, 12, 31));
}
Sample Output:
Xunit.Sdk.TrueException: Assert.True() Failure Expected: True Actual: False Xunit.Sdk.InRangeException: Assert.InRange() Failure Range: (-100 - 5) Actual: 23 Xunit.Sdk.InRangeException: Assert.InRange() Failure Range: (1/1/2018 12:00:00 AM - 12/31/2018 12:00:00 AM) Actual: 1/1/2019 12:00:00 AM
/// <summary>
/// Assertions that compare the value to a set of constraints
/// </summary>
[TestMethod]
public void ComparisonChecks()
{
int bigNumber = int.MaxValue;
int smallNumber = int.MinValue;
bool trueValue = true;
bool falseValue = false;
Assert.IsTrue(bigNumber > smallNumber);
Assert.IsTrue(bigNumber >= smallNumber);
Assert.IsTrue(smallNumber < bigNumber);
Assert.IsTrue(smallNumber <= bigNumber);
Assert.IsTrue(trueValue);
Assert.IsFalse(falseValue);
}
Sample Output:
Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: Assert.IsTrue failed. Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: Assert.IsFalse failed.
String Checks
Verify the contents of a string, from simple patters (StartsWith, Contains) to more complicated Regular Expression matching.
/// <summary>
/// String-specific checks
/// </summary>
[Test]
public void StringChecks()
{
var valueToTest = "Foo Bar Baz Bin";
Assert.That("", Is.Empty);
Assert.That(valueToTest, Is.Not.Empty);
Assert.That(valueToTest, Does.Contain("Bar"));
Assert.That(valueToTest, Does.Not.Contain("Bang"));
Assert.That(valueToTest, Does.StartWith("Foo"));
Assert.That(valueToTest, Does.Not.StartWith("Bar"));
Assert.That(valueToTest, Does.EndWith("Bin"));
Assert.That(valueToTest, Does.Not.EndWith("Baz"));
Assert.That(valueToTest, Is.EqualTo("foo bar baz bin").IgnoreCase);
Assert.That(valueToTest, Is.Not.EqualTo("something else").IgnoreCase);
Assert.That(valueToTest, Does.Match("^Foo.*Bin$")); // param is a regex pattern
Assert.That(valueToTest, Does.Not.Match("^Foo.*Bar$")); // param is a regex pattern
}
Sample Output:
Expected: <empty> But was: "asdf" Expected: <empty> But was: "Foo Bar Baz Bin" Expected: not String containing "Bar" But was: "Foo Bar Baz Bin" Expected: String containing "Bang" But was: "Foo Bar Baz Bin" Expected: not String starting with "Foo" But was: "Foo Bar Baz Bin" Expected: String starting with "Bar" But was: "Foo Bar Baz Bin" Expected: not String ending with "Bin" But was: "Foo Bar Baz Bin" Expected: String ending with "Baz" But was: "Foo Bar Baz Bin" Expected: not equal to "foo bar baz bin", ignoring case But was: "Foo Bar Baz Bin" Expected string length 14 but was 15. Strings differ at index 0. Expected: "something else", ignoring case But was: "Foo Bar Baz Bin" -----------^ Expected: not String matching "^Foo.*Bin$" But was: "Foo Bar Baz Bin" Expected: String matching "^Foo.*Bar$" But was: "Foo Bar Baz Bin"
/// <summary>
/// String-specific checks
/// </summary>
[Test]
public void StringChecks()
{
var valueToTest = "Foo Bar Baz Bin";
StringAssert.Contains("Bar", valueToTest);
StringAssert.DoesNotContain("Bang", valueToTest);
StringAssert.StartsWith("Foo", valueToTest);
StringAssert.DoesNotStartWith("Bar", valueToTest);
StringAssert.EndsWith("Bin", valueToTest);
StringAssert.DoesNotEndWith("Baz", valueToTest);
StringAssert.AreEqualIgnoringCase("foo bar baz bin", valueToTest);
StringAssert.AreNotEqualIgnoringCase("something else", valueToTest);
StringAssert.IsMatch("^Foo.*Bin$", valueToTest); //first param is a regex pattern
StringAssert.DoesNotMatch("^Foo.*Bar$", valueToTest); //first param is a regex pattern
}
Sample Output:
Expected: not String containing "Bar" But was: "Foo Bar Baz Bin" Expected: String containing "Bang" But was: "Foo Bar Baz Bin" Expected: not String starting with "Foo" But was: "Foo Bar Baz Bin" Expected: String starting with "Bar" But was: "Foo Bar Baz Bin" Expected: not String ending with "Bin" But was: "Foo Bar Baz Bin" Expected: String ending with "Baz" But was: "Foo Bar Baz Bin" Expected: not equal to "foo bar baz bin", ignoring case But was: "Foo Bar Baz Bin" Expected string length 14 but was 15. Strings differ at index 0. Expected: "something else", ignoring case But was: "Foo Bar Baz Bin" -----------^ Expected: not String matching "^Foo.*Bin$" But was: "Foo Bar Baz Bin" Expected: String matching "^Foo.*Bar$" But was: "Foo Bar Baz Bin"
/// <summary>
/// String-specific checks
/// </summary>
[Fact]
public void StringChecks()
{
var valueToTest = "Foo Bar Baz Bin";
Assert.Contains("Bar", valueToTest);
Assert.DoesNotContain("Bang", valueToTest);
Assert.StartsWith("Foo", valueToTest);
Assert.EndsWith("Bin", valueToTest);
Assert.Equal("foo bar baz bin", valueToTest, ignoreCase: true);
Assert.NotEqual("something else", valueToTest, StringComparer.InvariantCultureIgnoreCase);
Assert.Matches("^Foo.*Bin$", valueToTest); //first param is a regex pattern
Assert.Matches(new Regex("^Foo.*Bin$"), valueToTest);
Assert.DoesNotMatch("^Foo.*Bar$", valueToTest); //first param is a regex pattern
Assert.DoesNotMatch(new Regex("^Foo.*Bar$"), valueToTest);
}
Sample Output:
Xunit.Sdk.DoesNotContainException: Assert.DoesNotContain() Failure
Found: Bar
In value: Foo Bar Baz Bin
Xunit.Sdk.ContainsException: Assert.Contains() Failure
Not found: Bang
In value: Foo Bar Baz Bin
Xunit.Sdk.StartsWithException: Assert.StartsWith() Failure:
Expected: Bin
Actual: Foo...
Xunit.Sdk.EndsWithException: Assert.EndsWith() Failure:
Expected: Foo
Actual: ···Bin
Xunit.Sdk.EqualException: Assert.Equal() Failure
↓ (pos 0)
Expected: something else
Actual: Foo Bar Baz Bin
↑ (pos 0)
Xunit.Sdk.NotEqualException: Assert.NotEqual() Failure
Expected: Not "foo bar baz bin"
Actual: "Foo Bar Baz Bin"
Xunit.Sdk.MatchesException: Assert.Matches() Failure:
Regex: ^Foo.*Bar$
Value: Foo Bar Baz Bin
Xunit.Sdk.DoesNotMatchException: Assert.DoesNotMatch() Failure:
Regex: ^Foo.*Bin
Value: Foo Bar Baz Bin
/// <summary>
/// String-specific checks
/// </summary>
[TestMethod]
public void StringChecks()
{
var valueToTest = "Foo Bar Baz Bin";
StringAssert.Contains(valueToTest, "Bar");
StringAssert.StartsWith(valueToTest, "Foo");
StringAssert.EndsWith(valueToTest, "Bin");
StringAssert.Matches(valueToTest, new Regex( "^Foo.*Bin$"));
StringAssert.DoesNotMatch(valueToTest, new Regex( "^Foo.*Bar$"));
}
Sample Output:
Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: StringAssert.Contains failed. String 'Foo Bar Baz Bin' does not contain string 'asdf'. . Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: StringAssert.StartsWith failed. String 'Foo Bar Baz Bin' does not start with string 'Bar'. . Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: StringAssert.EndsWith failed. String 'Foo Bar Baz Bin' does not end with string 'Far'. . Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: StringAssert.Matches failed. String 'Foo Bar Baz Bin' does not match pattern '^Foo.*Bar$'. . Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: StringAssert.DoesNotMatch failed. String 'Foo Bar Baz Bin' matches pattern '^Foo.*Bin$'. .
Type Checks
Verify whether an object is a certain type, or could be used as a certain type.
/// <summary>
/// Tests related to object types and inheritance
/// </summary>
[Test]
public void TypeChecks()
{
IList<string> stringList = new List<string>();
IEnumerable<int> intEnumerable = new int[] { };
Assert.That("foo", Is.AssignableFrom(typeof(string)));
Assert.That("foo", Is.AssignableFrom<string>());
Assert.That("foo", Is.Not.AssignableFrom(typeof(int)));
Assert.That("foo", Is.Not.AssignableFrom<int>());
Assert.That(stringList, Is.InstanceOf(typeof(List<string>)));
Assert.That(stringList, Is.InstanceOf<List<string>>());
Assert.That(intEnumerable, Is.Not.InstanceOf(typeof(List<int>)));
Assert.That(intEnumerable, Is.Not.InstanceOf<List<int>>());
Assert.That(stringList, Is.AssignableTo(typeof(IEnumerable<string>)));
Assert.That(stringList, Is.AssignableTo<IEnumerable<string>>());
Assert.That(stringList, Is.Not.AssignableTo(typeof(string[])));
Assert.That(stringList, Is.Not.AssignableTo<string[]>());
Assert.That(intEnumerable, Is.TypeOf(typeof(int[]))); //must be exact type
Assert.That(intEnumerable, Is.TypeOf<int[]>()); //must be exact type
Assert.That(stringList, Is.Not.TypeOf(typeof(IEnumerable<string>))); //must be exact type
Assert.That(stringList, Is.Not.TypeOf<IEnumerable<string>>()); //must be exact type
}
Sample Output:
Expected: not assignable from <System.String> But was: <System.String> Expected: assignable from <System.Int32> But was: <System.String> Expected: not instance of <System.Collections.Generic.List`1[System.String]> But was: <System.Collections.Generic.List`1[System.String]> Expected: instance of <System.Collections.Generic.List`1[System.Int32]> But was: <System.Int32[]> Expected: not assignable to <System.Collections.Generic.IEnumerable`1[System.String]> But was: <System.Collections.Generic.List`1[System.String]> Expected: assignable to <System.String[]> But was: <System.Collections.Generic.List`1[System.String]> Expected: not <System.Int32[]> But was: <System.Int32[]> Expected: <System.Collections.Generic.IEnumerable`1[System.String]> But was: <System.Collections.Generic.List`1[System.String]>
/// <summary>
/// Tests related to object types and inheritance
/// </summary>
[Test]
public void TypeChecks()
{
IList<string> stringList = new List<string>();
IEnumerable<int> intEnumerable = new int[] { };
Assert.IsAssignableFrom(typeof(string), "foo");
Assert.IsAssignableFrom<string>("foo");
Assert.IsNotAssignableFrom(typeof(int), "foo");
Assert.IsNotAssignableFrom<int>("foo");
Assert.IsInstanceOf(typeof(List<string>), stringList);
Assert.IsInstanceOf<List<string>>(stringList);
Assert.IsNotInstanceOf(typeof(List<int>), intEnumerable);
Assert.IsNotInstanceOf<List<int>>(intEnumerable);
}
Sample Output:
Expected: not assignable from <System.String> But was: <System.String> Expected: assignable from <System.Int32> But was: <System.String> Expected: not instance of <System.Collections.Generic.List`1[System.String]> But was: <System.Collections.Generic.List`1[System.String]> Expected: instance of <System.Collections.Generic.List`1[System.Int32]> But was: <System.Int32[]>
/// <summary>
/// Tests related to object types and inheritance
/// </summary>
[Fact]
public void TypeChecks()
{
IList<string> stringList = new List<string>();
IEnumerable<int> intEnumerable = new int[] { };
Assert.IsAssignableFrom<string>("foo");
Assert.IsType<List<string>>(stringList);
Assert.IsNotType<List<int>>(intEnumerable);
}
Sample Output:
Xunit.Sdk.IsAssignableFromException: Assert.IsAssignableFrom() Failure Expected: typeof(int) Actual: typeof(string) Xunit.Sdk.IsTypeException: Assert.IsType() Failure Expected: System.Collections.Generic.List`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]] Actual: System.Collections.Generic.List`1[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]] Xunit.Sdk.IsNotTypeException: Assert.IsNotType() Failure Expected: typeof(System.Collections.Generic.List<string>) Actual: typeof(System.Collections.Generic.List<string>)
/// <summary>
/// Tests related to object types and inheritance
/// </summary>
[TestMethod]
public void TypeChecks()
{
IList<string> stringList = new List<string>();
IEnumerable<int> intEnumerable = new int[] { };
Assert.IsInstanceOfType(stringList, typeof(List<string>));
Assert.IsNotInstanceOfType(intEnumerable, typeof(List<int>));
}
Sample Output:
Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: Assert.IsNotInstanceOfType failed. Wrong Type:<System.Collections.Generic.List`1[System.String]>. Actual type:<System.Collections.Generic.List`1[System.String]>. Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: Assert.IsInstanceOfType failed. Expected type:<System.Collections.Generic.List`1[System.Int32]>. Actual type:<System.Int32[]>.
Collection Checks
Verify the contents of a collection meet some expectations.
/// <summary>
/// Checks specific to collections
/// </summary>
[Test]
public void CollectionChecks()
{
var objArr = new object[] {new object(), 42, "my string"};
var stringArr = new object[] {"foo", "bar", "baz", "bin", ""};
var intList = Enumerable.Range(0, 100);
Assert.That(stringArr, Is.All.TypeOf<string>());
Assert.That(intList, Is.All.GreaterThanOrEqualTo(0));
Assert.That(objArr, Is.All.Not.Null);
Assert.That(intList, Is.Unique);
Assert.That(intList, Is.EqualTo(Enumerable.Range(0, 100)));
Assert.That(intList, Is.Not.EqualTo(Enumerable.Range(1, 5)));
Assert.That(stringArr, Is.EquivalentTo(new string[] { "bar", "baz", "", "bin", "foo" }));
Assert.That(stringArr, Is.Not.EquivalentTo(new string[] { "bar", "baz" }));
Assert.That(stringArr, Has.Member("foo"));
Assert.That(stringArr, Does.Contain("foo"));
Assert.That(stringArr, Contains.Item("foo"));
Assert.That(stringArr, Has.No.Member("zoom"));
Assert.That(stringArr, Does.Not.Contain("zoom"));
Assert.That(Enumerable.Range(5, 20), Is.SubsetOf(intList));
Assert.That(Enumerable.Range(-1, 1), Is.Not.SubsetOf(intList));
Assert.That(intList, Is.SupersetOf(Enumerable.Range(5, 20)));
Assert.That(intList, Is.Not.SupersetOf(Enumerable.Range(-1, 1)));
Assert.That(new int[] { }, Is.Empty);
Assert.That(intList, Is.Not.Empty);
Assert.That(new int[] { 1, 2, 3 }, Is.Ordered);
Assert.That(new int[] { 2, 1, 3 }, Is.Not.Ordered);
string[] sarray = new string[] { "a", "aa", "aaa" };
Assert.That(sarray, Is.Ordered.By("Length"));
Assert.That(sarray, Is.Ordered.Ascending.By("Length"));
Assert.That(intList, Has.Exactly(100).Items);
Assert.That(intList, Has.Exactly(50).Items.GreaterThanOrEqualTo(50));
Assert.That(intList, Has.None.LessThan(0));
Assert.That(objArr, Has.Some.TypeOf<string>());
Assert.That(intList, Has.All.GreaterThanOrEqualTo(0));
}
Sample Output:
Expected: all items <System.Int32> But was: < "foo", "bar", "baz", "bin", <string.Empty> > First non-matching item at index [0]: "foo" Expected: all items greater than or equal to 3 But was: < 0, 1, 2, 3, 4, 5, 6, 7, 8, 9... > First non-matching item at index [0]: 0 Expected: all items unique But was: < 0, 1, 2, 3, 4, 5, 6, 7, 8, 9... > Expected: equivalent to < "bar", "baz", <string.Empty>, "bin", "foo", "extra" > But was: < "foo", "bar", "baz", "bin", <string.Empty> > Missing (1): < "extra" > Expected: some item equal to "extra" But was: < "foo", "bar", "baz", "bin", <string.Empty> > Expected: subset of < 0, 1, 2, 3, 4, 5, 6, 7, 8, 9... > But was: < -5, -4, -3, -2, -1, 0, 1, 2, 3, 4... > Expected: superset of < -5, -4, -3, -2, -1, 0, 1, 2, 3, 4... > But was: < 0, 1, 2, 3, 4, 5, 6, 7, 8, 9... > Expected: <empty> But was: < 0, 1, 2, 3, 4, 5, 6, 7, 8, 9... > Expected: collection ordered But was: < 2, 1, 3 > Ordering breaks at index [1]: 1 Expected: collection ordered by "Length" But was: < "aa", "a", "aaa" > Ordering breaks at index [1]: "a" Expected: exactly 50 items greater than or equal to 51 But was: 49 items < 0, 1, 2, 3, 4, 5, 6, 7, 8, 9... >
/// <summary>
/// Checks specific to collections
/// </summary>
[Test]
public void CollectionChecks()
{
var objArr = new object[] {new object(), 42, "my string"};
var stringArr = new object[] {"foo", "bar", "baz", "bin", ""};
var intList = Enumerable.Range(0, 100);
CollectionAssert.AllItemsAreInstancesOfType(stringArr, typeof(string));
CollectionAssert.AllItemsAreNotNull(objArr);
CollectionAssert.AllItemsAreUnique(intList);
CollectionAssert.AreEqual(Enumerable.Range(0, 100), intList);
CollectionAssert.AreNotEqual(Enumerable.Range(1, 5), intList);
CollectionAssert.AreEquivalent(new string[] { "bar", "baz", "", "bin", "foo" }, stringArr);
CollectionAssert.AreNotEquivalent(new string[] { "bar", "baz" }, stringArr);
CollectionAssert.Contains(stringArr, "foo");
CollectionAssert.DoesNotContain(stringArr, "zoom");
CollectionAssert.IsSubsetOf(Enumerable.Range(5, 20), intList);
CollectionAssert.IsNotSubsetOf(Enumerable.Range(-1, 1), intList);
CollectionAssert.IsEmpty(new int[] { });
CollectionAssert.IsNotEmpty(new int[] { 1, 2 });
CollectionAssert.IsOrdered(new int[] { 1, 2, 3 });
}
Sample Output:
Expected: all items unique But was: < 0, 1, 2, 3, 4, 5, 6, 7, 8, 9... > Expected and actual are both <System.Linq.Enumerable+<RangeIterator>d__113> Values differ at index [100] Expected: equivalent to < "bar", "baz", <string.Empty>, "bin", "foo", "extra" > But was: < "foo", "bar", "baz", "bin", <string.Empty> > Missing (1): < "extra" > Expected: some item equal to "extra" But was: < "foo", "bar", "baz", "bin", <string.Empty> > Expected: subset of < 0, 1, 2, 3, 4, 5, 6, 7, 8, 9... > But was: < -5, -4, -3, -2, -1, 0, 1, 2, 3, 4... > Expected: <empty> But was: < 1, 2 > Expected: collection ordered But was: < 2, 1, 3 > Ordering breaks at index [1]: 1
/// <summary>
/// Checks specific to collections
/// </summary>
[Fact]
public void CollectionChecks()
{
var objArr = new object[] { new object(), 42, "my string" };
var stringArr = new string[] { "foo", "bar", "baz", "bin", "" };
var intList = Enumerable.Range(0, 100);
Assert.All(stringArr, s => Assert.IsType<string>(s));
Assert.All(objArr, Assert.NotNull );
Assert.Equal(Enumerable.Range(0, 100), intList);
Assert.NotEqual(Enumerable.Range(1, 5), intList);
Assert.Contains("foo", stringArr);
Assert.DoesNotContain("zoom", stringArr);
Assert.Subset(intList.ToHashSet(), Enumerable.Range(5, 20).ToHashSet());
Assert.Superset(Enumerable.Range(5, 20).ToHashSet(), intList.ToHashSet());
Assert.Empty(new int[] { });
Assert.NotEmpty(new int[] { 1, 2 });
}
Sample Output:
Xunit.Sdk.AllException: Assert.All() Failure: 5 out of 5 items in the collection did not pass.
[4]: Item:
Xunit.Sdk.IsTypeException: Assert.IsType() Failure
Expected: System.Int32
Actual: System.String
...
[3]: Item: bin
Xunit.Sdk.IsTypeException: Assert.IsType() Failure
Expected: System.Int32
Actual: System.String
...
[2]: Item: baz
Xunit.Sdk.IsTypeException: Assert.IsType() Failure
Expected: System.Int32
Actual: System.String
...
[1]: Item: bar
Xunit.Sdk.IsTypeException: Assert.IsType() Failure
Expected: System.Int32
Actual: System.String
...
[0]: Item: foo
Xunit.Sdk.IsTypeException: Assert.IsType() Failure
Expected: System.Int32
Actual: System.String
Xunit.Sdk.EqualException: Assert.Equal() Failure
Expected: <RangeIterator>d__113 [1, 2, 3, 4, 5, ...]
Actual: <RangeIterator>d__113 [0, 1, 2, 3, 4, ...]
Xunit.Sdk.ContainsException: Assert.Contains() Failure
Not found: extra
In value: String[] ["foo", "bar", "baz", "bin", ""]
Xunit.Sdk.SubsetException: Assert.Subset() Failure
Expected: HashSet<Int32> [0, 1, 2, 3, 4, ...]
Actual: HashSet<Int32> [-5, -4, -3, -2, -1, ...]
Xunit.Sdk.SupersetException: Assert.Superset() Failure
Expected: HashSet<Int32> [-5, -4, -3, -2, -1, ...]
Actual: HashSet<Int32> [0, 1, 2, 3, 4, ...]
Xunit.Sdk.EmptyException: Assert.Empty() Failure
Collection: [1, 2]
/// <summary>
/// Checks specific to collections
/// </summary>
[TestMethod]
public void CollectionChecks()
{
var objArr = new object[] { new object(), 42, "my string" };
var stringArr = new object[] { "foo", "bar", "baz", "bin", "" };
var intList = Enumerable.Range(0, 100).ToList();
CollectionAssert.AllItemsAreInstancesOfType(stringArr, typeof(string));
CollectionAssert.AllItemsAreNotNull(objArr);
CollectionAssert.AllItemsAreUnique(intList);
CollectionAssert.AreEqual(Enumerable.Range(0, 100).ToList(), intList);
CollectionAssert.AreNotEqual(Enumerable.Range(1, 5).ToList(), intList);
CollectionAssert.AreEquivalent(new string[] { "bar", "baz", "", "bin", "foo" }, stringArr);
CollectionAssert.AreNotEquivalent(new string[] { "bar", "baz" }, stringArr);
CollectionAssert.Contains(stringArr, "foo");
CollectionAssert.DoesNotContain(stringArr, "zoom");
CollectionAssert.IsSubsetOf(Enumerable.Range(5, 20).ToList(), intList);
CollectionAssert.IsNotSubsetOf(Enumerable.Range(-1, 1).ToList(), intList);
}
Sample Output:
Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: CollectionAssert.AllItemsAreInstancesOfType failed. Element at index 0 is not of expected type. Expected type:<System.Int32>. Actual type:<System.String>. Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: CollectionAssert.AllItemsAreUnique failed. Duplicate item found:<10>. Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: CollectionAssert.AreEqual failed. (Different number of elements.) Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: CollectionAssert.AreEquivalent failed. The number of elements in the collections do not match. Expected:<6>. Actual:<5>. Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: CollectionAssert.Contains failed. Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: CollectionAssert.IsSubsetOf failed.
Exception Checks
If your code throws an exception, then it automatically fails the test (that's how Asserts work afterall). But sometimes you want to be deterministic in your tests. So these Exception Asserts allow you to do more detailed validation of the Exception you expect to be thrown.
/// <summary>
/// Exception-specific checks
/// </summary>
[Test]
public void ExceptionChecks()
{
void MethodThatThrows() { throw new ArgumentException(); }
Assert.That(() => { return; }, Throws.Nothing);
Assert.That(MethodThatThrows, Throws.ArgumentException);
Assert.That(MethodThatThrows, Throws.TypeOf<ArgumentException>());
Assert.That(() => throw new Exception("message"),
Throws.InstanceOf<Exception>()
.And.With.Property(nameof(Exception.Message)).EqualTo("message"));
// Require an ApplicationException - derived types fail!
Assert.That(() => throw new ApplicationException("message"),
Throws.TypeOf<ApplicationException>());
// Allow both ApplicationException and any derived type
Assert.That(() => throw new ApplicationException("message"),
Throws.InstanceOf<Exception>());
}
Sample Output:
Expected: No Exception to be thrown But was: <System.NotImplementedException: opps! Expected: <System.ArgumentException> But was: <System.NotImplementedException: opps! Expected: instance of <System.Exception> and property Message equal to "message" But was: "opps!" Expected: instance of <System.NotImplementedException> But was: <System.ApplicationException: message
/// <summary>
/// Exception-specific checks
/// </summary>
[Test]
public void ExceptionChecks()
{
void MethodThatThrows() { throw new ArgumentException(); }
Assert.DoesNotThrow(() => { return; });
Assert.Throws<ArgumentException>(MethodThatThrows);
Assert.Throws<ArgumentException>( () => throw new ArgumentException());
Exception ex = Assert.Throws<Exception>(() => throw new Exception("message"));
Assert.That(ex.Message, Is.EqualTo("message"));
Assert.Throws(Is.TypeOf<Exception>().And.Message.EqualTo("message"),
() => throw new Exception("message"));
// Require an ApplicationException - derived types fail!
Assert.Throws<ApplicationException>(() => throw new ApplicationException("message"));
// Allow both ApplicationException and any derived type
Assert.Throws(Is.InstanceOf<Exception>(), () => throw new ApplicationException("message"));
}
Sample Output:
Expected: No Exception to be thrown But was: <System.NotImplementedException: opps! Expected: <System.ArgumentException> But was: <System.NotImplementedException: opps! Expected: <System.Exception> But was: <System.NotImplementedException: message Expected: <System.NotImplementedException> and property Message equal to "message" But was: <System.Exception: opps! Expected: instance of <System.NotImplementedException> But was: <System.ApplicationException: message
/// <summary>
/// Exception-specific checks
/// </summary>
[Fact]
public void ExceptionChecks()
{
void MethodThatThrows() { throw new ArgumentException(); }
Assert.Throws<ArgumentException>(() => MethodThatThrows());
Exception ex = Assert.Throws<Exception>((Action)(() => throw new Exception("message")));
Assert.Equal("message", ex.Message);
}
Sample Output:
Xunit.Sdk.ThrowsException: Assert.Throws() Failure Expected: typeof(System.ArgumentException) Actual: typeof(System.NotImplementedException): opps!
/// <summary>
/// Exception-specific checks
/// </summary>
[TestMethod]
public void ExceptionChecks()
{
void MethodThatThrows() { throw new ArgumentException(); }
Assert.ThrowsException<ArgumentException>(() => MethodThatThrows());
Assert.ThrowsException<ArgumentException>(() => throw new ArgumentException());
Exception ex = Assert.ThrowsException<Exception>(() => throw new Exception("message"));
Assert.AreEqual("message", ex.Message);
}
Sample Output:
Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException: Assert.ThrowsException failed. Threw exception NotImplementedException, but exception ArgumentException was expected. Exception Message: opps!
Dynamically Set Test Results
This set of Asserts allow you to directly set the staus of a test as Pass, Fail, Ignored or Inconclusive (which isn't supported in most runners)
/// <summary>
/// Assert calls that dynamically change the test results
/// </summary>
[Test]
public void ForcedResults()
{
Assert.Pass("immediately end the test with a passing result");
Assert.Fail("immediately end the test with a failure result");
Assert.Ignore("dynamically cause a test or suite to be ignored at runtime");
Assert.Inconclusive("indicates that the test could not be completed with the data available");
}
/// <summary>
/// Assert calls that dynamically change the test results
/// </summary>
[Fact]
public void ForcedResults()
{
//There is no Assert.Fail option, but you can just thrown an exception.
//Tip: Create your own Assert.Fail method to wrap throwing an exception
throw new Exception("immediately end the test with a failure result");
//There's not a built-in Assert.Skip (aka Ignore), but there is a somewhat complicated
//way to do it. Example code here: https://github.com/xunit/samples.xunit/tree/master/DynamicSkipExample
}
/// <summary>
/// Assert calls that dynamically change the test results
/// </summary>
[TestMethod]
public void ForcedResults()
{
Assert.Inconclusive("indicates that the test could not be completed with the data available");
Assert.Fail("immediately end the test with a failure result");
}
NUnit Specialized Asserts
NUnit provides some additional Assert options that are useful in some specialized cases.
Multiple Asserts
Normally, once an Assert fails, execution of the test halts and no additional Asserts are attempted. NUnit provides Assert.Multiple
that wraps your Assert calls and will attempt to run all your Assert statements and provide a consolidated failure message with all of the
Asserts that failed.
/// <summary>
/// Syntax for executing multiple assertions in the same test (ie: all asserts are run)
/// </summary>
[Test]
public void MultipleCriteriaChecks()
{
object aNumber = 5.0;
Assert.Multiple(() =>
{
Assert.That(aNumber, Is.AssignableTo<double>());
Assert.That(aNumber, Is.InRange(0.0, 10.0));
}
);
}
Sample Output:
Expected: assignable to <System.String> But was: <System.Double> ... Expected: in range (0,10) But was: -5.0d
Additionally, the NUnit Constraint-style syntax allows you to chain assert conditions with .And. or .Or., so that a single Assert
can match on multiple conditions at once.
/// <summary>
/// Syntax for executing multiple assertions in the same test (ie: all asserts are run)
/// </summary>
[Test]
public void MultipleCriteriaChecks()
{
object aNumber = 5.0;
Assert.That(aNumber, Is.AssignableTo<int>().Or.AssignableTo<double>());
Assert.That(aNumber, Is.GreaterThanOrEqualTo(0).And.LessThanOrEqualTo(10));
}
Sample Output:
Expected: assignable to <System.Int32> or assignable to <System.Double> But was: "5.0" Expected: greater than or equal to 0 and less than or equal to 10 But was: -5.0d
Filesystem Asserts
NUnit also provides a set of File- and Directory-specific asserts for dealing with paths and file-related data.
/// <summary>
/// File- and Directory-specific checks
/// </summary>
[Test]
public void FileChecks()
{
var realFilePath = Assembly.GetExecutingAssembly().Location;
var realFileInfo = new FileInfo(realFilePath);
var realDirectoryPath = Path.GetDirectoryName(realFilePath);
var realDirectoryInfo = new DirectoryInfo(realDirectoryPath);
var nonexistantFilePath = "E:/ fake.folder / this.is.fake";
var nonexistantFileInfo = new FileInfo(nonexistantFilePath);
var nonexistantDirectoryPath = Path.GetDirectoryName(nonexistantFilePath);
var nonexistantDirectoryInfo = new DirectoryInfo(nonexistantDirectoryPath);
Assert.That(realFilePath, Does.Exist);
Assert.That(realFileInfo, Does.Exist);
Assert.That(nonexistantFilePath, Does.Not.Exist);
Assert.That(nonexistantFileInfo, Does.Not.Exist);
Assert.That(realDirectoryPath, Does.Exist);
Assert.That(realDirectoryInfo, Does.Exist);
Assert.That(nonexistantDirectoryPath, Does.Not.Exist);
Assert.That(nonexistantDirectoryInfo, Does.Not.Exist);
Assert.That(realDirectoryInfo, Is.Not.Empty);
Assert.That("/folder1/./junk/../folder2", Is.SamePath("/folder1/folder2"));
Assert.That("/folder1/./junk/../folder2/..", Is.Not.SamePath("/folder1/folder2"));
Assert.That("/folder1/./junk/../folder2", Is.SamePath("/FOLDER1/folder2").IgnoreCase);
Assert.That("/folder1/./junk/../folder2", Is.Not.SamePath("/FOLDER1/folder2").RespectCase);
Assert.That("/folder1/./junk/../folder2/./foo", Is.SamePathOrUnder("/folder1/folder2"));
Assert.That("/folder1/./junk/../folder2/./foo", Is.SubPathOf("/folder1"));
}
Sample Output:
Expected: file or directory exists But was: "E:/ fake.folder / this.is.fake" Expected: not file or directory exists But was: "C:\Users\wrigh\AppData\Local\NCrunch\15220\6\NUnit.FullFramework\bin\Debug\NUnit.FullFramework.dll" Expected: not file or directory exists But was: "C:\Users\wrigh\AppData\Local\NCrunch\15220\6\NUnit.FullFramework\bin\Debug" Expected: file or directory exists But was: "E:\fake.folder" Expected: not Path matching "/folder1/folder2" But was: "/folder1/./junk/../folder2" Expected: Path under or matching "/folder1/folder2/x" But was: "/folder1/./junk/../folder2/./foo"
/// <summary>
/// File- and Directory-specific checks
/// </summary>
[Test]
public void FileChecks()
{
var realFilePath = Assembly.GetExecutingAssembly().Location;
var realFileInfo = new FileInfo(realFilePath);
var realDirectoryPath = Path.GetDirectoryName(realFilePath);
var realDirectoryInfo = new DirectoryInfo(realDirectoryPath);
var nonexistantFilePath = "E:/ fake.folder / this.is.fake";
var nonexistantFileInfo = new FileInfo(nonexistantFilePath);
var nonexistantDirectoryPath = Path.GetDirectoryName(nonexistantFilePath);
var nonexistantDirectoryInfo = new DirectoryInfo(nonexistantDirectoryPath);
// see: https://github.com/nunit/docs/wiki/File-Assert
FileAssert.Exists(realFileInfo);
FileAssert.Exists(realFilePath);
FileAssert.DoesNotExist(nonexistantFileInfo);
FileAssert.DoesNotExist(nonexistantFilePath);
DirectoryAssert.Exists(realDirectoryPath);
DirectoryAssert.Exists(realDirectoryInfo);
DirectoryAssert.DoesNotExist(nonexistantDirectoryPath);
DirectoryAssert.DoesNotExist(nonexistantDirectoryInfo);
}
Sample Output:
Expected: file exists But was: <E:/fake.folder/this.is.fake> Expected: not file exists But was: <C:\Users\wrigh\AppData\Local\NCrunch\15220\3\NUnit.FullFramework\bin\Debug\NUnit.FullFramework.dll> Expected: not directory exists But was: "C:\Users\wrigh\AppData\Local\NCrunch\15220\3\NUnit.FullFramework\bin\Debug" Expected: directory exists But was: "E:\fake.folder"
