public void IsNotEmpty()
{
List <int> list = new List <int>();
list.Add(42);
EmptyException ex = Assert.Throws <EmptyException>(() => Assert.Empty(list));
Assert.Equal("Assert.Empty() failure", ex.Message);
}
public void CallsIEquatable()
{
EquatableObject obj1 = new EquatableObject();
EquatableObject obj2 = new EquatableObject();
Assert.Equal(obj1, obj2);
Assert.True(obj1.Equals__Called);
Assert.Same(obj2, obj1.Equals_Other);
}
public void When_comparing_object_with_overriden_equality_behavior_to_derived_object_Should_use_overriden_behavior()
{
var obj = new CustomEqualityObject();
var derivedObj = new DerivedCustomEqualityObject();
Assert.Equal(obj, derivedObj);
Assert.True(obj.EqualsCalled);
Assert.Equal(obj.EqualsCalledOn, derivedObj);
}
public void EqualsUInt32()
{
uint valueType = 35;
UInt32 referenceValue = 35;
Assert.True(valueType == referenceValue);
Assert.Equal(referenceValue, valueType);
Assert.Equal <uint>(valueType, 35);
Assert.Equal <uint>(referenceValue, 35);
}
public void EqualsUInt64()
{
ulong valueType = 35;
UInt64 referenceValue = 35;
Assert.True(valueType == referenceValue);
Assert.Equal(referenceValue, valueType);
Assert.Equal <ulong>(valueType, 35);
Assert.Equal <ulong>(referenceValue, 35);
}
public void EqualsUInt16()
{
ushort valueType = 35;
UInt16 referenceValue = 35;
Assert.True(valueType == referenceValue);
Assert.Equal(referenceValue, valueType);
Assert.Equal <ushort>(valueType, 35);
Assert.Equal <ushort>(referenceValue, 35);
}
public void EqualsSByte()
{
sbyte valueType = 35;
SByte referenceValue = 35;
Assert.True(valueType == referenceValue);
Assert.Equal(referenceValue, valueType);
Assert.Equal <sbyte>(valueType, 35);
Assert.Equal <sbyte>(referenceValue, 35);
}
public void EqualsInt32()
{
int valueType = 35;
Int32 referenceValue = 35;
Assert.True(valueType == referenceValue);
Assert.Equal(referenceValue, valueType);
Assert.Equal(valueType, 35);
Assert.Equal(referenceValue, 35);
}
public void GotExpectedException()
{
StubAccessor accessor = new StubAccessor();
Exception ex =
Assert.Throws(typeof(InvalidOperationException), () => accessor.FailingProperty);
Assert.NotNull(ex);
Assert.IsType <InvalidOperationException>(ex);
}
public void CorrectExceptionType()
{
DoesNotThrowException ex =
Assert.Throws <DoesNotThrowException>(
() => Assert.DoesNotThrow(
() => { throw new NotImplementedException("Exception Message"); }));
Assert.Equal("Assert.DoesNotThrow() failure", ex.UserMessage);
Assert.Equal("(No exception)", ex.Expected);
Assert.Equal("System.NotImplementedException: Exception Message", ex.Actual);
}
public void NotEqualFailsString()
{
try
{
Assert.NotEqual("actual", "actual");
}
catch (NotEqualException exception)
{
Assert.Equal("Assert.NotEqual() Failure", exception.UserMessage);
}
}
public void SingleWithMultiItemCollectionThrows()
{
ArrayList collection = new ArrayList {
"Hello", "World"
};
Exception ex = Record.Exception(() => Assert.Single(collection));
Assert.IsType <SingleException>(ex);
Assert.Equal("The collection contained 2 elements instead of 1.", ex.Message);
}
public void ExpectExceptionButCodeDoesNotThrow()
{
try
{
Assert.Throws <ArgumentException>(delegate { });
}
catch (AssertActualExpectedException exception)
{
Assert.Equal("(No exception was thrown)", exception.Actual);
}
}
public void ExpectExceptionButCodeThrowsDerivedException()
{
try
{
Assert.Throws <Exception>(delegate { throw new InvalidOperationException(); });
}
catch (AssertException exception)
{
Assert.Equal("Assert.Throws() Failure", exception.UserMessage);
}
}
public void AssertFalseThrowsExceptionWhenTrue()
{
try
{
Assert.False(true);
}
catch (AssertException exception)
{
Assert.Equal("Assert.False() Failure", exception.UserMessage);
}
}
public void ItemInContainer()
{
List <int> list = new List <int> {
42
};
DoesNotContainException ex =
Assert.Throws <DoesNotContainException>(() => Assert.DoesNotContain(42, list));
Assert.Equal("Assert.DoesNotContain() failure: Found: 42", ex.Message);
}
public void EqualsDecimal()
{
decimal valueType = 35;
Decimal referenceValue = 35;
Assert.True(valueType == referenceValue);
Assert.Equal(referenceValue, valueType);
Assert.Equal <decimal>(valueType, 35);
Assert.Equal(valueType, 35M);
Assert.Equal <decimal>(referenceValue, 35);
}
public void NotEqual_UserMessageIsInTheExceptionMessage()
{
string userMessage = "my message";
var ex = Xunit.Assert.Throws <NotEqualException>(() =>
{
Assert.NotEqual(1.0, 1.0, 0, userMessage);
});
Xunit.Assert.Contains(userMessage, ex.Message);
}
public void NullThrowsExceptionWhenNotNull()
{
try
{
Assert.Null(new object());
}
catch (AssertException exception)
{
Assert.Equal("Assert.Null() Failure", exception.UserMessage);
}
}
public void NotEqual_ToleranceValueIsInTheExceptionMessage()
{
double tolerance = 0.1;
var exception = Xunit.Assert.Throws <NotEqualException>(() =>
{
Assert.NotEqual(1.0, 1.0, tolerance);
});
Xunit.Assert.Contains("+/- " + tolerance, exception.Message);
}
public void ExpectedAndActualAreUsedInMessage()
{
string expectedMessage =
"Message" + Environment.NewLine +
"Expected: 2" + Environment.NewLine +
"Actual: 1";
AssertActualExpectedException ex =
new AssertActualExpectedException(2, 1, "Message");
Assert.Equal(expectedMessage, ex.Message);
}
public void DifferentVisibleValueDifferentTypes()
{
string expectedMessage =
"Message" + Environment.NewLine +
"Expected: 2" + Environment.NewLine +
"Actual: 1";
AssertActualExpectedException ex =
new AssertActualExpectedException("2", 1, "Message");
Assert.Equal(expectedMessage, ex.Message);
}
public void SameVisibleValueDifferentTypes()
{
string expectedMessage =
"Message" + Environment.NewLine +
"Expected: 1 (System.String)" + Environment.NewLine +
"Actual: 1 (System.Int32)";
AssertActualExpectedException ex =
new AssertActualExpectedException("1", 1, "Message");
Assert.Equal(expectedMessage, ex.Message);
}
public void ExpectExceptionButCodeThrowsDerivedException()
{
StubAccessor accessor = new StubAccessor();
try
{
Assert.Throws(typeof(Exception), () => accessor.FailingProperty);
}
catch (AssertException exception)
{
Assert.Equal("Assert.Throws() Failure", exception.UserMessage);
}
}
public void NotSameFailsWith()
{
object actual = new object();
try
{
Assert.NotSame(actual, actual);
}
catch (NotSameException exception)
{
Assert.Equal("Assert.NotSame() Failure", exception.UserMessage);
}
}
public void ExpectExceptionButCodeDoesNotThrow()
{
StubAccessor accessor = new StubAccessor();
try
{
Assert.Throws <ArgumentException>(() => accessor.SuccessfulProperty);
}
catch (AssertActualExpectedException exception)
{
Assert.Equal("(No exception was thrown)", exception.Actual);
}
}
public void OneStringOneNullDoesNotShowDifferencePoint()
{
string actualValue = null;
string expectedValue = "first test 1";
string expectedMessage =
"Message" + Environment.NewLine +
"Expected: first test 1" + Environment.NewLine +
"Actual: (null)";
AssertActualExpectedException ex =
new AssertActualExpectedException(expectedValue, actualValue, "Message");
Assert.Equal(expectedMessage, ex.Message);
}
void CanSerializeAndDeserializeObjectsInATest()
{
BinaryFormatter bf = new BinaryFormatter();
using (Stream ms = new MemoryStream())
{
bf.Serialize(ms, new SerializableObject());
ms.Position = 0;
object o = bf.Deserialize(ms);
Assert.IsType(typeof(SerializableObject), o);
Assert.DoesNotThrow(delegate { SerializableObject o2 = (SerializableObject)o; });
}
}
public void OneStringAddsValueToEndOfTheOtherString()
{
string actualValue = "first test";
string expectedValue = "first test 1";
string expectedMessage =
"Message" + Environment.NewLine +
"Position: First difference is at position 10" + Environment.NewLine +
"Expected: first test 1" + Environment.NewLine +
"Actual: first test";
AssertActualExpectedException ex =
new AssertActualExpectedException(expectedValue, actualValue, "Message");
Assert.Equal(expectedMessage, ex.Message);
}
public void StringsDifferInTheMiddle()
{
string actualValue = "first test";
string expectedValue = "first failure";
string expectedMessage =
"Message" + Environment.NewLine +
"Position: First difference is at position 6" + Environment.NewLine +
"Expected: first failure" + Environment.NewLine +
"Actual: first test";
AssertActualExpectedException ex =
new AssertActualExpectedException(expectedValue, actualValue, "Message");
Assert.Equal(expectedMessage, ex.Message);
}
