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")); }