public void ApplyTo_EquivalentCollections_Passes()
{
var constraint = Has.Properties.EqualTo(new { Test = "243" });
ConstraintResult result = constraint.ApplyTo(new { Test = "243" });
Assert.That(result, Has.Property <ConstraintResult>(r => r.IsSuccess).True, result.ToString());
}
/// <summary>
/// Write the generic 'Actual' line for a constraint
/// </summary>
/// <param name="result">The ConstraintResult for which the actual value is to be written</param>
private void WriteActualLine(ConstraintResult result)
{
Write(Pfx_Actual);
result.WriteActualValueTo(this);
WriteLine();
//WriteLine(MsgUtils.FormatValue(result.ActualValue));
}
public void ApplyTo_EquivalentJObjects_Passes()
{
JsonEqualsConstraint constraint = new JsonEqualsConstraint(JObject.FromObject(new { Name = "FOO" }));
ConstraintResult result = constraint.ApplyTo(JObject.FromObject(new { Name = "FOO" }));
Assert.That(result, Has.Property <ConstraintResult>(r => r.IsSuccess).True, result.ToString());
}
public override ConstraintResult ApplyTo <TActual>(TActual actual)
{
var trueResult = new ConstraintResult(new TrueConstraint(), true);
trueResult.Status = ConstraintStatus.Success;
return(trueResult);
}
public void ApplyTo_MultiplePropertiesOneNotEqualStrict_Fails()
{
var constraint = Has.Properties.NotEqualTo(new { Test = "243", Age = 42 }).Strict();
ConstraintResult result = constraint.ApplyTo(new { Test = "244", Age = 42 });
Assert.That(result, Has.Property <ConstraintResult>(r => r.IsSuccess).False, result.ToString());
}
/// <inheritdoc/>
public override ConstraintResult ApplyTo <TActual>(TActual actual)
{
ConstraintResult nested = valueConstraint.Resolve().ApplyTo(XPathEvaluate(actual));
Description = "XML with XPath " + xPath + " evaluated to " + nested.ActualValue;
return(new HasXPathConstraintResult(this, actual, nested));
}
public EventRaisedArgConstraintResult(
BaseEventRaisedConstraint constraint,
bool eventWasRaised,
ConstraintResult argResult) : base(constraint, eventWasRaised && (argResult?.IsSuccess ?? true))
{
this.argConstraintResult = argResult;
}
public void ApplyTo_EquivalentCollections_Passes()
{
EnumerableEqualsConstraint constraint = new EnumerableEqualsConstraint(new [] { 1, 2, 3, 4, 5 });
ConstraintResult result = constraint.ApplyTo(new[] { 1, 2, 3, 4, 5 });
Assert.That(result, Has.Property <ConstraintResult>(r => r.IsSuccess).True, result.ToString());
}
private static void ReportFailure(ConstraintResult result, string message, object[] args)
{
MessageWriter writer = new TextMessageWriter(message, args);
result.WriteMessageTo(writer);
throw new InconclusiveException(writer.ToString());
}
private ConstraintResult ApplyToRetry(Func <ConstraintResult> resultFactory)
{
var result = new ConstraintResult(this, this, ConstraintStatus.Failure);
for (int counter = 0; counter < this._retrySettings.RetryCount; counter++)
{
try {
result = resultFactory();
if (result.IsSuccess)
{
TestContext.WriteLine($"Constraint {result.Status}: {result.Name} {result.Description} - Success");
return(result);
}
TestContext.WriteLine($"Constraint {result.Status}: {result.Name} {result.Description} - Retrying");
}
catch (Exception ex) {
TestContext.WriteLine($"Constraint exception: {ex} - Retrying");
}
Thread.Sleep(this._retrySettings.TimeGap);
}
return(result);
}
private static void IssueWarning(ConstraintResult result, string message, object[] args)
{
MessageWriter writer = new TextMessageWriter(message, args);
result.WriteMessageTo(writer);
Assert.Warn(writer.ToString());
}
public void ApplyTo_SinglePropertyNotEqual_Passes()
{
var constraint = Has.Properties.NotEqualTo(new { Test = "243" });
ConstraintResult result = constraint.ApplyTo(new { Test = "244" });
Assert.That(result, Has.Property <ConstraintResult>(r => r.IsSuccess).True, result.ToString());
}
public ConstraintResult Test(string caption, T value)
{
var message = new StringBuilder();
if (value is IComparable comparableValue)
{
if (lowerBound != null)
{
var lowerResult = lowerBound.CompareTo(comparableValue);
if (lowerResult < 0 || (!isLowerBoundIncluded && lowerResult == 0))
{
var includedText = isLowerBoundIncluded ? "or equal to " : "";
message.Append($"{caption} must be greater than {includedText}{lowerResult}");
}
}
if (upperBound != null)
{
var upperResult = upperBound.CompareTo(value);
if (upperResult < 0 || (!isUpperBoundIncluded && upperResult == 0))
{
var includedText = isUpperBoundIncluded ? "or equal to " : "";
message.Append($"{caption} must be less than {includedText}{upperResult}");
}
}
}
return(message.Length > 0
? ConstraintResult.Failed(message.ToString())
: ConstraintResult.Passed());
}
public void ApplyTo_DifferentCollections_Fails()
{
EnumerableEqualsConstraint constraint = new EnumerableEqualsConstraint(new[] { 1, 2, 3, 4, 5 });
ConstraintResult result = constraint.ApplyTo(new[] { 1, 2, 2, 4, 5 });
Assert.That(result, Has.Property <ConstraintResult>(r => r.IsSuccess).False, result.ToString());
Assert.That(result.ToString(), Is.EqualTo(" Expected: element at [2] to be: 3\r\n But was: 2\r\n"));
}
private static void ReportFailure(ConstraintResult result, string message, params object[] args)
{
MessageWriter writer = new TextMessageWriter(message, args);
result.WriteMessageTo(writer);
ReportFailure(writer.ToString());
}
private static void HandleConstraintResult([NotNull] ConstraintResult result, [CanBeNull] Func <string> messageProvider)
{
if (result.IsSuccess == false)
{
var mParts = new[] {
messageProvider?.Try().OrDefault(),
result.Description
};
Assert.Ignore(mParts.NonNull().JoinLines());
}
}
public void ApplyTo_DifferentJObjects_Fails()
{
JsonEqualsConstraint constraint = new JsonEqualsConstraint(JObject.FromObject(new { Name = "FOO" }));
ConstraintResult result = constraint.ApplyTo(JObject.FromObject(new { Name = "FOX" }));
Assert.That(result, Has.Property <ConstraintResult>(r => r.IsSuccess).False, result.ToString());
Assert.That(result.ToString(), Is.EqualTo("JTokens did not match." +
"\r\n Value at 'Name' was not equals." +
"\r\n Expected: FOX" +
"\r\n But was: FOO\r\n\r\n"));
}
/// <summary>
/// Applies the constraint to an actual value, returning a ConstraintResult.
/// </summary>
/// <param name="actual">The value to be tested</param>
/// <returns>A ConstraintResult</returns>
public override ConstraintResult ApplyTo <TActual>(TActual actual)
{
foreach (var constraint in _constraints)
{
ConstraintResult result = constraint.ApplyTo(actual);
if (!result.IsSuccess)
{
_beingMatched = constraint;
return(new ConjuctionConstraintResult(this, actual, result));
}
}
return(new ConstraintResult(this, actual, true));
}
ConstraintResult CaptureResult(ConstraintResult result)
{
capturedResult = result;
// If failure result is due to an AssertionException, report that assertion failure directly,
// and return a dummy "success" constraint to avoid the redundant unexpected AssertionException report.
if (result.IsSuccess is false && result.ActualValue is AssertionException ex)
{
Assert.Fail(ex.Message);
capturedResult = new ConstraintResult(resolvedParent, null, isSuccess: false); // result returned by above AssertThat
result = new ConstraintResult(resolvedParent, null, isSuccess: true); // result returned to Assert.That
}
return(result);
}
private string getMessage(ConstraintResult result)
{
string message = string.Empty;
if (!result.IsSuccess)
{
var writer = new TextMessageWriter();
result.WriteMessageTo(writer);
message = writer.ToString();
}
return(message);
}
public void ApplyTo_DifferentCollections_Fails()
{
var constraint = Has.Properties.EqualTo(new { Test = "222" });
ConstraintResult result = constraint.ApplyTo(new { Test = "243" });
Assert.That(result, Has.Property <ConstraintResult>(r => r.IsSuccess).False, result.ToString());
Assert.That(result.ToString(), Is.EqualTo("Properties of the object did not match." +
"\r\n The property 'Test <System.String>' was not equals." +
"\r\n String lengths are both 3. Strings differ at index 1." +
"\r\n Expected: \"222\"" +
"\r\n But was: \"243\"" +
"\r\n ------------^" +
"\r\n " +
"\r\n"));
}
public override ConstraintResult ApplyTo <TActual>(TActual actual)
{
ConstraintResult matches = new ConstraintResult(this, null, true);
foreach (var constraint in _constraints)
{
_inner = constraint;
matches = new AgeResult(constraint, constraint.ApplyTo(actual));
if (!matches.IsSuccess)
{
break;
}
}
return(matches);
}
protected override ConstraintResult matches(object current)
{
ConstraintResult result = new ConstraintResult(this, current, true);
ISpecification <T> spec = (ISpecification <T>)current;
foreach (var value in _values)
{
result = new SpecificationResult(Delegate, Delegate.ApplyTo(spec.IsSatisfiedBy(value)));
if (!result.IsSuccess)
{
break;
}
}
return(result);
}
/// <summary>
/// Applies the constraint to an actual value, returning a ConstraintResult.
/// </summary>
/// <param name="actual">The value to be tested</param>
/// <returns>A ConstraintResult</returns>
public override ConstraintResult ApplyTo <TActual>(TActual actual)
{
_beingMatched = new TypeRevealingConstraint(typeof(IEnumerable));
ConstraintResult result = _beingMatched.ApplyTo(actual);
if (result.IsSuccess)
{
var collection = (IEnumerable)actual;
// ReSharper disable PossibleMultipleEnumeration
ushort count = calculateCount(collection);
_beingMatched = new CountConstraint(_countConstraint, collection);
// ReSharper restore PossibleMultipleEnumeration
result = _beingMatched.ApplyTo(count);
}
return(result);
}
/// <summary>
/// Applies the constraint to an actual value, returning a ConstraintResult.
/// </summary>
/// <param name="actual">The value to be tested</param>
/// <returns>A ConstraintResult</returns>
public override ConstraintResult ApplyTo <TActual>(TActual actual)
{
ConstraintResult result = null;
Exception ex = null;
try
{
T deserialized = getDeserializedObject((T)((object)actual));
result = _constraintOverDeserialized.ApplyTo(deserialized);
}
catch (Exception caught)
{
ex = caught;
}
return(new SerializationResult(ex, result, this, actual, (result?.IsSuccess).GetValueOrDefault()));
}
/// <summary>
/// Applies the constraint to an actual value, returning a ConstraintResult.
/// </summary>
/// <param name="actual">The value to be tested</param>
/// <returns>A ConstraintResult</returns>
public override ConstraintResult ApplyTo <TActual>(TActual actual)
{
Exception ex = null;
ConstraintResult result = null;
T deserialized = default(T);
try
{
deserialized = getDeserializedObject(actual?.ToString());
result = _constraintOverDeserialized.ApplyTo(deserialized);
}
catch (Exception caught)
{
ex = caught;
}
return(new DeserializationResult(ex, deserialized, result, this, actual, (result?.IsSuccess).GetValueOrDefault()));
}
private static void ReportFailure(ConstraintResult result, string message, params object[] args)
{
MessageWriter writer = new TextMessageWriter(message, args);
result.WriteMessageTo(writer);
string formattedMessage = writer.ToString();
string stackTrace = GetStackTrace();
// Failure is recorded in <assertion> element in all cases
TestExecutionContext.CurrentContext.CurrentResult.RecordAssertion(
AssertionStatus.Failed, formattedMessage, stackTrace);
// If we are outside any multiple assert block, then throw
if (TestExecutionContext.CurrentContext.MultipleAssertLevel == 0)
{
throw new AssertionException(formattedMessage);
}
}
/// <inheritdoc />
public ConstraintResult ApplyTo <TActual>(ref TActual actual)
{
TActual copy = actual;
ConstraintResult result;
try {
result = this.ApplyToRetry(resultFactory: delegate {
TActual copy2 = copy;
ConstraintResult result2 = this._wrapped.ApplyTo(actual: ref copy2);
copy = copy2;
return(result2);
});
}
finally {
actual = copy;
}
return(result);
}
/// <summary>
/// Applies the constraint to an actual value, returning a ConstraintResult.
/// </summary>
/// <param name="actual">The value to be tested</param>
/// <returns>A ConstraintResult</returns>
public override ConstraintResult ApplyTo <TActual>(TActual actual)
{
// it is ok to iterate the collection as most of the times it will be a small controlled collection
// ReSharper disable AssignNullToNotNullAttribute
var collection = (actual as IEnumerable).Cast <object>().ToArray();
// ReSharper restore AssignNullToNotNullAttribute
ConstraintResult result = sameNumberOfElementsAndConstraints(collection, _constraints.Length);
if (result.IsSuccess)
{
for (int i = 0; i < collection.Length && result.IsSuccess; i++)
{
_beingMatched = new IndexedConstraint(collection, i, _constraints[i]);
result = _beingMatched.ApplyTo(collection.GetValue(i));
}
}
return(result);
}
public void ApplyTo_DifferentJArrays_Fails()
{
JsonEqualsConstraint constraint = new JsonEqualsConstraint(JArray.FromObject(new [] { "ONE", "TWO", "THREE", "FOUR" }))
.AllowArrayOutOfOrder();
ConstraintResult result = constraint.ApplyTo(JArray.FromObject(new[] { "ONE", "TWO", "FOUR", "FIVE" }));
Assert.That(result, Has.Property <ConstraintResult>(r => r.IsSuccess).False, result.ToString());
string str = result.ToString();
Assert.That(result.ToString(), Is.EqualTo("JTokens did not match." +
"\r\n Value at '' was not equals." +
"\r\n Expected: <missing>" +
"\r\n But was: THREE" +
"\r\n" +
"\r\n Value at '' was not equals." +
"\r\n Expected: FIVE" +
"\r\n But was: <extra>" +
"\r\n" +
"\r\n"));
}
