AreEnumerablesEqualComparer_ExpectedAndActualHaveSameObjectsInSameOrder_ShouldNotThrowAssertFailedExceptionIfEqualsOverride()
{
var comparer =
new GenericComparer <EqualityTestObject, EqualityTestObject>(
(expected, actual) => expected.Equals(actual));
var expected = new List <EqualityTestObject>
{
new EqualityTestObject(), new EqualityTestObject {
BooleanPropertyTest = true
}
};
var actual = new List <EqualityTestObject>
{
new EqualityTestObject(), new EqualityTestObject {
BooleanPropertyTest = true
}
};
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
CollectionAsserter.AreEnumerablesEqual <EqualityTestObject>(expected, actual, comparer);
});
}
public async Task DoesNotThrowGenericExceptionAsync_ActionIsNull_ShouldThrowArgumentNullException()
{
await Assert.ThrowsExceptionAsync <ArgumentNullException>(
async() =>
{
await ExceptionAsserter.DoesNotThrowExceptionAsync <TestException>(null);
});
}
public void IsNull_ConditionIsNull_ShouldNotThrowAssertFailedException()
{
var o = default(TestObject);
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
Asserter.IsNull(() => o);
});
}
public void AreEnumerablesEqual_ExpectedAndActualAreNull_ShouldNotThrowAssertFailedException()
{
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
CollectionAsserter.AreEnumerablesEqual <NoEqualityTestObject>(
default(IEnumerable <NoEqualityTestObject>),
default(IEnumerable <NoEqualityTestObject>));
});
}
public void IsTrue_ConditionIsTrueBooleanMethodResult_ShouldNotThrowAssertFailedException()
{
var o = new TestObject();
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
Asserter.IsTrue(() => o.BooleanMethodTest(true));
});
}
public void IsFalseNullable_ConditionIsFalseBooleanMethodResult_ShouldNotThrowAssertFailedException()
{
var o = new TestObject();
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
Asserter.IsFalse(() => o.NullableBooleanMethodTest(false));
});
}
public void ConstructorShouldSetExpectedException()
{
// arrange
var exception = new Exception();
// act
var target = new ExceptionAsserter <Exception>(exception);
// assert
Assert.AreEqual(exception, target.Exception);
}
public void VerifyShouldNotReturnNull()
{
// arrange
var assert = new ExceptionAsserter <Exception>(new Exception());
// act
var actual = assert.Verify(e => true);
// assert
Assert.IsNotNull(actual);
}
public void IsInRangeDouble_ConditionIsMinimum_ShouldNotThrowAssertFailedException()
{
double condition = 5;
double minimum = condition;
double maximum = 15;
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
Asserter.IsInRange(condition, minimum, maximum);
});
}
public void IsInRangeDecimal_ConditionIsInRange_ShouldNotThrowAssertFailedException()
{
decimal condition = 10;
decimal minimum = 5;
decimal maximum = 15;
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
Asserter.IsInRange(condition, minimum, maximum);
});
}
public void IsFalse_ConditionIsSimpleAndBinaryExpressionThatReturnsFalse_ShouldNotThrowAssertFailedException()
{
var o = new TestObject {
BooleanPropertyTest = true
};
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
Asserter.IsFalse(() => !(o.BooleanPropertyTest && o.BooleanMethodTest(true)));
});
}
public void IsTrue_ConditionIsTrueBooleanProperty_ShouldNotThrowAssertFailedException()
{
var o = new TestObject {
BooleanPropertyTest = true
};
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
Asserter.IsTrue(() => o.BooleanPropertyTest);
});
}
public void IsFalseNullable_ConditionIsFalseBooleanProperty_ShouldNotThrowAssertFailedException()
{
var o = new TestObject {
NullableBooleanPropertyTest = false
};
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
Asserter.IsFalse(() => o.NullableBooleanPropertyTest);
});
}
public void IsInRangeULong_ConditionIsMaximum_ShouldNotThrowAssertFailedException()
{
ulong condition = 15;
ulong minimum = 5;
ulong maximum = condition;
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
Asserter.IsInRange(condition, minimum, maximum);
});
}
public void IsInRangeUShort_ConditionIsInRange_ShouldNotThrowAssertFailedException()
{
ushort condition = 10;
ushort minimum = 5;
ushort maximum = 15;
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
Asserter.IsInRange(condition, minimum, maximum);
});
}
public void IsInRangeSByte_ConditionIsInRange_ShouldNotThrowAssertFailedException()
{
sbyte condition = 10;
sbyte minimum = 5;
sbyte maximum = 15;
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
Asserter.IsInRange(condition, minimum, maximum);
});
}
public void IsInRangeInt_ConditionIsMaximum_ShouldNotThrowAssertFailedException()
{
int condition = 15;
int minimum = 5;
int maximum = condition;
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
Asserter.IsInRange(condition, minimum, maximum);
});
}
public void AreEnumerablesEqual_ExpectedAndActualAreSameReference_ShouldNotThrowAssertFailedException()
{
var expected = new List <NoEqualityTestObject> {
new NoEqualityTestObject(), new NoEqualityTestObject {
BooleanPropertyTest = true
}
};
List <NoEqualityTestObject> actual = expected;
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
CollectionAsserter.AreEnumerablesEqual <NoEqualityTestObject>(expected, actual);
});
}
IsTrue_ConditionIsComplexAndOrBinaryExpressionThatReturnsTrueForLeftPart_ShouldNotThrowAssertFailedException()
{
var o = new TestObject {
BooleanPropertyTest = true
};
var p = new TestObject {
BooleanPropertyTest = false
};
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
Asserter.IsTrue(() => (o.BooleanPropertyTest && o.BooleanMethodTest(true)) || !p.BooleanPropertyTest);
});
}
public void AreEnumerablesEqualComparer_ExpectedAndActualAreNull_ShouldNotThrowAssertFailedException()
{
var comparer =
new GenericComparer <NoEqualityTestObject, NoEqualityTestObject>(
(expected, actual) => expected.Equals(actual));
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
CollectionAsserter.AreEnumerablesEqual <NoEqualityTestObject>(
default(IEnumerable <NoEqualityTestObject>),
default(IEnumerable <NoEqualityTestObject>),
comparer);
});
}
public void VerifyShouldAssertFailedVerification()
{
// arrange
var assert = new ExceptionAsserter <Exception>(new Exception());
try
{
// act
assert.Verify(e => false);
}
catch (AssertFailedException)
{
// assert
return;
}
Assert.Fail("An exception was expected, but not thrown.");
}
public void VerifyShouldAssertFailedVerificationWithMessage()
{
// arrange
var assert = new ExceptionAsserter <Exception>(new Exception());
try
{
// act
assert.Verify(exception => false, "A '{0}' message.", "test");
}
catch (AssertFailedException ex)
{
// assert
Assert.AreEqual("Assert.IsTrue failed. A 'test' message.", ex.Message);
return;
}
Assert.Fail("An exception was expected, but not thrown.");
}
AreEnumerablesEquivalent_ExpectedAndActualHaveSameObjectsInSameOrder_ShouldNotThrowAssertFailedExceptionIfEqualsOverride()
{
var expected = new List <EqualityTestObject> {
new EqualityTestObject(), new EqualityTestObject {
BooleanPropertyTest = true
}
};
var actual = new List <EqualityTestObject> {
new EqualityTestObject(), new EqualityTestObject {
BooleanPropertyTest = true
}
};
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
CollectionAsserter.AreEnumerablesEquivalent <EqualityTestObject>(expected, actual);
});
}
AreEnumerablesEqual_ExpectedAndActualHaveSameReferenceObjectsInSameOrder_ShouldNotThrowAssertFailedException()
{
var o = new NoEqualityTestObject();
var p = new NoEqualityTestObject {
BooleanPropertyTest = true
};
var expected = new List <NoEqualityTestObject> {
o, p
};
var actual = new List <NoEqualityTestObject> {
o, p
};
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
CollectionAsserter.AreEnumerablesEqual <NoEqualityTestObject>(expected, actual);
});
}
public void VerifyShouldNotAllowNullVerificationFunctionWithMessage()
{
// arrange
var assert = new ExceptionAsserter <Exception>(new Exception());
var verification = default(Func <Exception, bool>);
try
{
// act
assert.Verify(verification, string.Empty);
}
catch (AssertFailedException ex)
{
// asseert
Assert.AreEqual(GetExpectedMessage(nameof(verification)), ex.Message);
return;
}
Assert.Fail("An exception was expected, but not thrown.");
}
