private void AssertDefaultValue(MemberInfo memberInfo)
{
ExtractMemberInfo(memberInfo, out Type memberType, out Func <object, object> memberGetter);
// Resolve the default value for the current member type and check it matches
var factory = DefaultValueFactory.MakeGenericMethod(memberType);
var defaultValue = factory.Invoke(this, new object[0]);
var value = memberGetter.Invoke(Subject);
var equal = value == null && defaultValue == null;
if (!equal)
{
// Ensure Equals() is called on a non-null instance
if (value != null)
{
equal = value.Equals(defaultValue);
}
else
{
equal = defaultValue.Equals(value);
}
}
Scope = Scope
.ForCondition(equal)
.FailWith($"Expected a default '{memberType.FullName}' value for '{memberInfo.Name}'.")
.Then;
}
public XmlReaderValidator(XmlReader subjectReader, XmlReader otherReader, string because, object[] reasonArgs)
{
assertion = Execute.Assertion.BecauseOf(because, reasonArgs);
this.subjectReader = subjectReader;
this.otherReader = otherReader;
}
protected StringValidator(string subject, string expected, string because, object[] becauseArgs)
{
assertion = Execute.Assertion.BecauseOf(because, becauseArgs);
this.subject = subject;
this.expected = expected;
}
public static Continuation AssertCollectionHasNotTooManyItems <T>(this IAssertionScope scope, ICollection <object> subject, ICollection <T> expectation)
{
return(scope
.ForCondition(subject.Count <= expectation.Count)
.FailWith(", but {0}{3}contains {1} item(s) more than{3}{2}.",
subject,
subject.Count - expectation.Count,
expectation,
Environment.NewLine));
}
private AndConstraint <object> AssertSubject()
{
var type = Subject.GetType();
var assertion = GetAssertion(type);
Scope = Execute.Assertion;
assertion.Invoke(type.Name, type, Subject);
return(new AndConstraint <object>(Subject));
}
public static Continuation AssertEitherCollectionIsNotEmpty <T>(this IAssertionScope scope, ICollection <object> subject, ICollection <T> expectation)
{
return(scope
.ForCondition((subject.Count > 0) || (expectation.Count == 0))
.FailWith(", but found an empty collection.")
.Then
.ForCondition((subject.Count == 0) || (expectation.Count > 0))
.FailWith(", but {0}{2}contains {1} item(s).",
subject,
subject.Count,
Environment.NewLine));
}
/// <summary>
/// Asserts that the thrown exception has a message that matches <paramref name = "expectedWildcardPattern" />.
/// </summary>
/// <param name = "expectedWildcardPattern">
/// The wildcard pattern with which the exception message is matched, where * and ? have special meanings.
/// </param>
/// <param name = "because">
/// A formatted phrase as is supported by <see cref = "string.Format(string,object[])" /> explaining why the assertion
/// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
/// </param>
/// <param name = "becauseArgs">
/// Zero or more objects to format using the placeholders in <see cref = "because" />.
/// </param>
public virtual ExceptionAssertions <TException> WithMessage(string expectedWildcardPattern, string because = "",
params object[] becauseArgs)
{
IAssertionScope assertion = Execute.Assertion.BecauseOf(because, becauseArgs).UsingLineBreaks;
assertion
.ForCondition(Subject.Any())
.FailWith("Expected exception with message {0}{reason}, but no exception was thrown.", expectedWildcardPattern);
outerMessageAssertion.Execute(Subject.Select(exc => exc.Message).ToArray(), expectedWildcardPattern, because, becauseArgs);
return(this);
}
public AndConstraint <object> NotBeGenerated()
{
var type = Subject.GetType();
var memberInfos = GetMemberInfos(type);
Scope = Execute.Assertion;
foreach (var memberInfo in memberInfos)
{
AssertDefaultValue(memberInfo);
}
return(new AndConstraint <object>(Subject));
}
public AndConstraint <object> BeGenerated()
{
var type = Subject.GetType();
var assertion = GetAssertion(type);
Scope = Execute.Assertion;
// Assert the value and output any fail messages
var message = assertion.Invoke(null, type, Subject);
Scope = Scope
.ForCondition(message == null)
.FailWith(message)
.Then;
return(new AndConstraint <object>(Subject));
}
private void AssertMember(string path, MemberInfo memberInfo, object instance)
{
ExtractMemberInfo(memberInfo, out Type memberType, out Func <object, object> memberGetter);
// Create a trace path for the current member
path = string.Concat(path, ".", memberInfo.Name);
// Resolve the assertion and value for the member type
var value = memberGetter.Invoke(instance);
var assertion = GetAssertion(memberType);
var message = assertion.Invoke(path, memberType, value);
// Register an assertion for each member
Scope = Scope
.ForCondition(message == null)
.FailWith(message)
.Then;
}
public void Validate()
{
if ((expected != null) || (subject != null))
{
if (ValidateAgainstNulls())
{
if (IsLongOrMultiline(expected) || IsLongOrMultiline(subject))
{
assertion = assertion.UsingLineBreaks;
}
if (ValidateAgainstSuperfluousWhitespace())
{
if (ValidateAgainstLengthDifferences())
{
ValidateAgainstMismatch();
}
}
}
}
}
public void Validate()
{
if ((Expected is not null) || (Subject is not null))
{
if (ValidateAgainstNulls())
{
if (IsLongOrMultiline(Expected) || IsLongOrMultiline(Subject))
{
Assertion = Assertion.UsingLineBreaks;
}
if (ValidateAgainstSuperfluousWhitespace())
{
if (ValidateAgainstLengthDifferences())
{
ValidateAgainstMismatch();
}
}
}
}
}
public static Continuation AssertIsNotNull <T>(this IAssertionScope assertionScope, T instance, string subjectName, string itemName, string accessorName)
where T : class
=> assertionScope.ForCondition(!(instance is null))
