/// <summary>
/// Apply the item constraint to each item in the collection,
/// succeeding only if the expected number of items pass.
/// </summary>
/// <param name="actual">The value to be tested</param>
/// <returns>A ConstraintResult</returns>
public override ConstraintResult ApplyTo <TActual>(TActual actual)
{
var enumerable = ConstraintUtils.RequireActual <IEnumerable>(actual, nameof(actual));
var itemList = new Collection <object>();
var matchCount = 0;
foreach (var item in enumerable)
{
if (_itemConstraint != null)
{
if (_itemConstraint.ApplyTo(item).IsSuccess)
{
matchCount++;
}
}
else
{
matchCount++;
}
// We intentionally add one item too many because we use it to trigger
// the ellipsis when we call "MsgUtils.FormatCollection" later on.
if (itemList.Count <= MsgUtils.DefaultMaxItems)
{
itemList.Add(item);
}
}
return(new ExactCountConstraintResult(this, actual, matchCount == _expectedCount, matchCount, itemList));
}
public override ConstraintResult ApplyTo <TActual>(TActual actual)
{
var instCheck = Is.InstanceOf <HttpRequestMessage>().ApplyTo(actual);
if (!instCheck.IsSuccess)
{
return(instCheck);
}
var message = actual as HttpRequestMessage;
var results = new List <ConstraintResult>();
if (uri != null)
{
results.Add(uri.ApplyTo <Uri>(message.RequestUri));
}
if (method != null)
{
results.Add(method.ApplyTo <HttpMethod>(message.Method));
}
if (content != null)
{
results.Add(content.ApplyTo <HttpContent>(message.Content));
}
return(new CombinedResult(this, actual, results));
}
/// <summary>
/// Apply the item constraint to each item in the collection,
/// succeeding only if the expected number of items pass.
/// </summary>
/// <param name="actual"></param>
/// <returns></returns>
public override ConstraintResult ApplyTo <TActual>(TActual actual)
{
var enumerable = ConstraintUtils.RequireActual <IEnumerable>(actual, nameof(actual));
int count = 0;
if (_itemConstraint == null)
{
foreach (object item in enumerable)
{
count++;
}
}
else
{
foreach (object item in enumerable)
{
if (_itemConstraint.ApplyTo(item).IsSuccess)
{
count++;
}
}
}
return(new ConstraintResult(this, actual, count == _expectedCount));
}
/// <summary>
/// Apply the item constraint to each item in the collection,
/// succeeding only if the expected number of items pass.
/// </summary>
/// <param name="actual"></param>
/// <returns></returns>
public override ConstraintResult ApplyTo <TActual>(TActual actual)
{
if (!(actual is IEnumerable))
{
throw new ArgumentException("The actual value must be an IEnumerable", "actual");
}
int count = 0;
if (_itemConstraint == null)
{
foreach (object item in (IEnumerable)actual)
{
count++;
}
}
else
{
foreach (object item in (IEnumerable)actual)
{
if (_itemConstraint.ApplyTo(item).IsSuccess)
{
count++;
}
}
}
return(new ConstraintResult(this, actual, count == _expectedCount));
}
public override ConstraintResult ApplyTo <TActual>(TActual actual)
{
writer.WriteLine($"writing {actual}");
var result = constraint.ApplyTo(actual);
writer.WriteLine("status ", result.Status);
return(result);
}
/// <summary>
/// Sets an expectation on a value produced off the provided parameter value.
/// </summary>
/// <typeparam name="T">The type of the parameter used to produce the test value.</typeparam>
/// <typeparam name="TValue">The type of the value to test.</typeparam>
/// <param name="parameter">The parameter.</param>
/// <param name="valueSelector"></param>
/// <param name="constraint">A NUnit constraint used to set the expectation.</param>
/// <returns>The parameter value.</returns>
public static T That <T, TValue>(this Parameter <T> parameter, Func <T, Task <TValue> > valueSelector, IConstraint constraint)
{
_ = parameter ?? throw new ArgumentNullException(nameof(parameter));
return(Moq.Match.Create <T>(item =>
{
var value = valueSelector(item).GetAwaiter().GetResult();
return constraint.ApplyTo(value).IsSuccess;
}));
}
/// <inheritdoc />
public override ConstraintResult ApplyTo <TActual>(TActual actual)
{
if (actual is T item)
{
var value = _valueSelector(item);
return(_constraint.ApplyTo(value));
}
throw new NotSupportedException();
}
/// <summary>
/// Apply a constraint to a referenced value, succeeding if the constraint
/// is satisfied and throwing an assertion exception on failure.
/// </summary>
/// <param name="actual">The actual value to test</param>
/// <param name="expression">A Constraint to be applied</param>
/// <param name="message">The message that will be displayed on failure</param>
/// <param name="args">Arguments to be used in formatting the message</param>
static public void That <T>(ref T actual, IResolveConstraint expression, string message = null, params object[] args)
{
IConstraint constraint = expression.Resolve();
IncrementAssertCount();
var result = constraint.ApplyTo(ref actual);
if (!result.IsSuccess)
{
ReportFailure(result, message, args);
}
}
/// <summary>
/// Apply a constraint to a <see cref="TCLite.ActualValueDelegate"/>,
/// succeeding if the constraint is satisfied and throwing an
/// assertion exception on failure.
/// </summary>
/// <param name="del">An ActualValueDelegate returning the value to be tested</param>
/// <param name="expr">A Constraint expression to be applied</param>
/// <param name="message">The message that will be displayed on failure</param>
/// <param name="args">Arguments to be used in formatting the message</param>
static public void That <T>(ActualValueDelegate <T> del, IResolveConstraint expr, string message = null, params object[] args)
{
IConstraint constraint = expr.Resolve();
IncrementAssertCount();
var result = constraint.ApplyTo(del);
if (!result.IsSuccess)
{
ReportFailure(result, message, args);
}
}
/// <inheritdoc cref="Assert.That{T}(T,IResolveConstraint,string,object[])"/>
/// <remarks> Delegating to a different name to emphasize that behavior of other Ensure overloads may differ in behavior to Assert.That, and to reduce the number of completion options Intellisense pops up with.</remarks>
public static void Ensure <T>(T actual, IConstraint constraint, string message = null, params object[] args)
{
constraint = constraint.Resolve();
TestExecutionContext.CurrentContext.IncrementAssertCount();
var result = constraint.ApplyTo(actual);
if (!result.IsSuccess)
{
MessageWriter writer = new TextMessageWriter(message, args);
result.WriteMessageTo(writer);
// If an exception was thrown its stack trace should be displayed, not the stack trace of this assertion exception.
throw new AssertionExceptionWithTrimmedStackTrace(writer.ToString(), (result.ActualValue as Exception)?.StackTrace);
}
}
public override ConstraintResult ApplyTo <TActual>(TActual actual)
{
var instCheck = Is.InstanceOf <HttpContent>().ApplyTo(actual);
if (!instCheck.IsSuccess)
{
return(instCheck);
}
var httpContent = actual as HttpContent;
if (content != null)
{
Task <string> task = httpContent.ReadAsStringAsync();
task.Wait();
return(new CombinedResult(this, actual, new List <ConstraintResult> {
content.ApplyTo(task.Result)
}));
}
return(new ConstraintResult(this, actual, true));
}
public override ConstraintResult ApplyTo <TActual>(TActual actual)
{
var instCheck = Is.InstanceOf <Uri>().ApplyTo(actual);
if (!instCheck.IsSuccess)
{
return(instCheck);
}
var uri = actual as Uri;
var results = new List <ConstraintResult>();
if (path != null)
{
results.Add(path.ApplyTo <string>(uri.AbsolutePath));
}
if (query != null)
{
results.Add(query.ApplyTo <string>(uri.Query));
}
return(new CombinedResult(this, actual, results));
}
public override ConstraintResult ApplyTo <TActual>(TActual actual)
{
var constraintResult = _inner.ApplyTo(actual);
return(constraintResult);
}
/// <summary>
/// Sets an expectation on the value of the parameter being used.
/// </summary>
/// <typeparam name="T">The type of the parameter.</typeparam>
/// <param name="parameter">The parameter.</param>
/// <param name="constraint">A NUnit constraint used to set the expectation.</param>
/// <returns>The parameter value.</returns>
public static T That <T>(this Parameter <T> parameter, IConstraint constraint)
{
_ = parameter ?? throw new ArgumentNullException(nameof(parameter));
return(Moq.Match.Create <T>(item => constraint.ApplyTo(item).IsSuccess));
}