Constraint
The Constraint class is the base of all built-in constraints
within NUnit. It provides the operator overloads used to combine
constraints.
using NUnit.Framework.Internal;
using System;
using System.Globalization;
using System.Reflection;
using System.Text;
namespace NUnit.Framework.Constraints
{
public abstract class Constraint : IConstraint, IResolveConstraint
{
private Lazy<string> _displayName;
public virtual string DisplayName => _displayName.Value;
public virtual string Description { get; set; }
public object[] Arguments { get; set; }
public ConstraintBuilder Builder { get; set; }
public ConstraintExpression And {
get {
ConstraintBuilder constraintBuilder = Builder;
if (constraintBuilder == null) {
constraintBuilder = new ConstraintBuilder();
constraintBuilder.Append(this);
}
constraintBuilder.Append(new AndOperator());
return new ConstraintExpression(constraintBuilder);
}
}
public ConstraintExpression With => And;
public ConstraintExpression Or {
get {
ConstraintBuilder constraintBuilder = Builder;
if (constraintBuilder == null) {
constraintBuilder = new ConstraintBuilder();
constraintBuilder.Append(this);
}
constraintBuilder.Append(new OrOperator());
return new ConstraintExpression(constraintBuilder);
}
}
protected Constraint(params object[] args)
{
Arguments = args;
_displayName = new Lazy<string>(delegate {
Type type = GetType();
string text = type.Name;
if (type.GetTypeInfo().IsGenericType)
text = text.Substring(0, text.Length - 2);
if (text.EndsWith("Constraint", StringComparison.Ordinal))
text = text.Substring(0, text.Length - 10);
return text;
});
}
public abstract ConstraintResult ApplyTo<TActual>(TActual actual);
public virtual ConstraintResult ApplyTo<TActual>(ActualValueDelegate<TActual> del)
{
if (AsyncInvocationRegion.IsAsyncOperation(del)) {
using (AsyncInvocationRegion asyncInvocationRegion = AsyncInvocationRegion.Create(del)) {
return ApplyTo(asyncInvocationRegion.WaitForPendingOperationsToComplete(del()));
}
}
return ApplyTo(GetTestObject(del));
}
public virtual ConstraintResult ApplyTo<TActual>(ref TActual actual)
{
return ApplyTo(actual);
}
protected virtual object GetTestObject<TActual>(ActualValueDelegate<TActual> del)
{
return del();
}
public override string ToString()
{
string stringRepresentation = GetStringRepresentation();
if (Builder != null)
return $"""{stringRepresentation}""";
return stringRepresentation;
}
protected virtual string GetStringRepresentation()
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("<");
stringBuilder.Append(DisplayName.ToLower());
object[] arguments = Arguments;
foreach (object o in arguments) {
stringBuilder.Append(" ");
stringBuilder.Append(_displayable(o));
}
stringBuilder.Append(">");
return stringBuilder.ToString();
}
private static string _displayable(object o)
{
if (o == null)
return "null";
string format = (o is string) ? "\"{0}\"" : "{0}";
return string.Format(CultureInfo.InvariantCulture, format, new object[1] {
o
});
}
public static Constraint operator &(Constraint left, Constraint right)
{
return new AndConstraint(((IResolveConstraint)left).Resolve(), ((IResolveConstraint)right).Resolve());
}
public static Constraint operator |(Constraint left, Constraint right)
{
return new OrConstraint(((IResolveConstraint)left).Resolve(), ((IResolveConstraint)right).Resolve());
}
public static Constraint operator !(Constraint constraint)
{
return new NotConstraint(((IResolveConstraint)constraint).Resolve());
}
public DelayedConstraint After(int delayInMilliseconds)
{
return new DelayedConstraint((Builder == null) ? this : Builder.Resolve(), delayInMilliseconds);
}
public DelayedConstraint After(int delayInMilliseconds, int pollingInterval)
{
return new DelayedConstraint((Builder == null) ? this : Builder.Resolve(), delayInMilliseconds, pollingInterval);
}
IConstraint IResolveConstraint.Resolve()
{
if (Builder != null)
return Builder.Resolve();
return this;
}
}
}