C# Constraints.Constraint类代码示例

        /// <summary>
        /// Test whether the constraint is satisfied by a given value
        /// </summary>
        /// <param name="actual">The value to be tested</param>
        /// <returns>True for if the base constraint fails, false if it succeeds</returns>
        public override bool Matches(object actual)
        {
            this.actual = actual;
            if ( this.caseInsensitive )
                baseConstraint = baseConstraint.IgnoreCase;

            return !baseConstraint.Matches(actual);
        }

        /// <summary>
        /// Constructs an AttributeConstraint for a specified attriute
        /// Type and base constraint.
        /// </summary>
        /// <param name="type"></param>
        /// <param name="baseConstraint"></param>
        public AttributeConstraint(Type type, Constraint baseConstraint)
            : base( baseConstraint )
        {
            this.expectedType = type;

            if (!typeof(Attribute).IsAssignableFrom(expectedType))
                throw new ArgumentException(string.Format(
                    "Type {0} is not an attribute", expectedType), "type");
        }

		/// <summary>
		/// Set all modifiers applied to the prefix into
		/// the base constraint before matching
		/// </summary>
		protected void PassModifiersToBase()
		{
			if ( this.caseInsensitive )
				baseConstraint = baseConstraint.IgnoreCase;
			if ( this.tolerance != null )
				baseConstraint = baseConstraint.Within( tolerance );
			if ( this.compareAsCollection )
				baseConstraint = baseConstraint.AsCollection;
			if ( this.compareWith != null )
				baseConstraint = baseConstraint.Comparer( compareWith );
		}

        /// <summary>
        /// Apply the item constraint to each item in the collection,
        /// failing if any item fails.
        /// </summary>
        /// <param name="actual"></param>
        /// <returns></returns>
        public override bool Matches(object actual)
        {
            this.actual = actual;
            if ( actual == null || !(actual is ICollection) )
                return false;

            if ( this.caseInsensitive )
                itemConstraint = itemConstraint.IgnoreCase;
            foreach(object item in (ICollection)actual)
                if (!itemConstraint.Matches(item))
                    return false;

            return true;
        }

 public virtual Constraint SetConstraint(Constraint constraint)
 {
     baseConstraint = constraint;
     return this;
 }

 /// <summary>
 /// Abstract method that produces a constraint by applying
 /// the operator to its left and right constraint arguments.
 /// </summary>
 public abstract Constraint ApplyOperator(Constraint left, Constraint right);

		/// <summary>
		/// Initializes a new instance of the <see cref="T:NotConstraint"/> class.
		/// </summary>
		/// <param name="baseConstraint">The base constraint to be negated.</param>
		public NotConstraint(Constraint baseConstraint)
			: base( baseConstraint ) { }

 public void IsOrderedBy(IEnumerable collection, Constraint constraint)
 {
     Assert.That(collection, constraint);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="T:ThrowsConstraint"/> class,
 /// using a constraint to be applied to the exception.
 /// </summary>
 /// <param name="baseConstraint">A constraint to apply to the caught exception.</param>
 public ThrowsConstraint(Constraint baseConstraint)
     : base(baseConstraint) { }

		/// <summary>
		/// Construct a SomeItemsConstraint on top of an existing constraint
		/// </summary>
		/// <param name="itemConstraint"></param>
		public NoItemConstraint(Constraint itemConstraint)
			: base( itemConstraint ) 
        {
            this.DisplayName = "none";
        }

		/// <summary>
		/// Construct a SomeItemsConstraint on top of an existing constraint
		/// </summary>
		/// <param name="itemConstraint"></param>
		public NoItemConstraint(Constraint itemConstraint)
			: base( itemConstraint ) { }

		/// <summary>
		/// Construct given a base constraint
		/// </summary>
		/// <param name="baseConstraint"></param>
		protected PrefixConstraint( Constraint baseConstraint )
		{
			this.baseConstraint = baseConstraint;
		}

		/// <summary>
		/// Construct an AllItemsConstraint on top of an existing constraint
		/// </summary>
		/// <param name="itemConstraint"></param>
		public AllItemsConstraint(Constraint itemConstraint)
			: base( itemConstraint ) { }

		/// <summary>
		/// Construct a SomeItemsConstraint on top of an existing constraint
		/// </summary>
		/// <param name="itemConstraint"></param>
		public SomeItemsConstraint(Constraint itemConstraint)
			: base( itemConstraint ) { }

 /// <summary>
 /// Returns a constraint that will apply the argument
 /// to the members of a collection, succeeding if
 /// none of them succeed.
 /// </summary>
 public override Constraint ApplyPrefix(Constraint constraint)
 {
     return new ExactCountConstraint(expectedCount, constraint);
 }