File: Has.cs

package info (click to toggle)
mono 4.6.2.7+dfsg-1
  • links: PTS, VCS
  • area: main
  • in suites: stretch
  • size: 778,148 kB
  • ctags: 914,052
  • sloc: cs: 5,779,509; xml: 2,773,713; ansic: 432,645; sh: 14,749; makefile: 12,361; perl: 2,488; python: 1,434; cpp: 849; asm: 531; sql: 95; sed: 16; php: 1
file content (144 lines) | stat: -rw-r--r-- 4,451 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
// ****************************************************************
// Copyright 2007, Charlie Poole
// This is free software licensed under the NUnit license. You may
// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
// ****************************************************************

using System;
using NUnit.Framework.Constraints;

namespace NUnit.Framework.SyntaxHelpers
{
	/// <summary>
	/// Summary description for HasNoPrefixB.
	/// </summary>
	public class Has
	{
        /// <summary>
        /// Nested class that allows us to restrict the number
        /// of key words that may appear after Has.No.
        /// </summary>
		public class HasNoPrefixBuilder
		{
            /// <summary>
            /// Return a ConstraintBuilder conditioned to apply
            /// the following constraint to a property.
            /// </summary>
            /// <param name="name">The property name</param>
            /// <returns>A ConstraintBuilder</returns>
			public ConstraintBuilder Property(string name)
			{
				return new ConstraintBuilder().Not.Property(name);
			}

            /// <summary>
            /// Return a Constraint that succeeds if the expected object is
            /// not contained in a collection.
            /// </summary>
            /// <param name="expected">The expected object</param>
            /// <returns>A Constraint</returns>
            public Constraint Member(object expected)
			{
				return new NotConstraint( new CollectionContainsConstraint(expected) ) ;
			}
		}

		#region Prefix Operators
		/// <summary>
		/// Has.No returns a ConstraintBuilder that negates
		/// the constraint that follows it.
		/// </summary>
		public static HasNoPrefixBuilder No
		{
			get { return new HasNoPrefixBuilder(); }
		}

		/// <summary>
		/// Has.AllItems returns a ConstraintBuilder, which will apply
		/// the following constraint to all members of a collection,
		/// succeeding if all of them succeed.
		/// </summary>
		public static ConstraintBuilder All
		{
			get { return new ConstraintBuilder().All; }
		}

		/// <summary>
		/// Has.Some returns a ConstraintBuilder, which will apply
		/// the following constraint to all members of a collection,
		/// succeeding if any of them succeed. It is a synonym
		/// for Has.Item.
		/// </summary>
		public static ConstraintBuilder Some
		{
			get { return new ConstraintBuilder().Some; }
		}

		/// <summary>
		/// Has.None returns a ConstraintBuilder, which will apply
		/// the following constraint to all members of a collection,
		/// succeeding only if none of them succeed.
		/// </summary>
		public static ConstraintBuilder None
		{
			get { return new ConstraintBuilder().None; }
		}

		/// <summary>
		/// Returns a new ConstraintBuilder, which will apply the
		/// following constraint to a named property of the object
		/// being tested.
		/// </summary>
		/// <param name="name">The name of the property</param>
		public static ConstraintBuilder Property( string name )
		{
			return new ConstraintBuilder().Property(name);
		}
		#endregion

		#region Property Constraints
		/// <summary>
		/// Returns a new PropertyConstraint checking for the
		/// existence of a particular property value.
		/// </summary>
		/// <param name="name">The name of the property to look for</param>
		/// <param name="expected">The expected value of the property</param>
		public static Constraint Property( string name, object expected )
		{
			return new PropertyConstraint( name, new EqualConstraint( expected ) );
		}

        /// <summary>
        /// Returns a new PropertyConstraint for the Length property
        /// </summary>
        /// <param name="length"></param>
        /// <returns></returns>
		public static Constraint Length( int length )
		{
			return Property( "Length", length );
		}

		/// <summary>
		/// Returns a new PropertyConstraint or the Count property
		/// </summary>
		/// <param name="count"></param>
		/// <returns></returns>
		public static Constraint Count( int count )
		{
			return Property( "Count", count );
		}
		#endregion

		#region Member Constraint
		/// <summary>
		/// Returns a new CollectionContainsConstraint checking for the
		/// presence of a particular object in the collection.
		/// </summary>
		/// <param name="expected">The expected object</param>
		public static Constraint Member( object expected )
		{
			return new CollectionContainsConstraint( expected );
		}
		#endregion
	}
}