add nunit.framework dll
authorEugene.Petrenko <eugene.petrenko@gmail.com>
Wed, 13 Jul 2011 14:35:20 +0000 (18:35 +0400)
committerEugene.Petrenko <eugene.petrenko@gmail.com>
Wed, 13 Jul 2011 14:35:20 +0000 (18:35 +0400)
nuget-extensions/lib/nunit/nunit.framework.dll [new file with mode: 0644]
nuget-extensions/lib/nunit/nunit.framework.xml [new file with mode: 0644]

diff --git a/nuget-extensions/lib/nunit/nunit.framework.dll b/nuget-extensions/lib/nunit/nunit.framework.dll
new file mode 100644 (file)
index 0000000..6856e51
Binary files /dev/null and b/nuget-extensions/lib/nunit/nunit.framework.dll differ
diff --git a/nuget-extensions/lib/nunit/nunit.framework.xml b/nuget-extensions/lib/nunit/nunit.framework.xml
new file mode 100644 (file)
index 0000000..c98e5ad
--- /dev/null
@@ -0,0 +1,10407 @@
+<?xml version="1.0"?>\r
+<doc>\r
+    <assembly>\r
+        <name>nunit.framework</name>\r
+    </assembly>\r
+    <members>\r
+        <member name="T:NUnit.Framework.CategoryAttribute">\r
+            <summary>\r
+            Attribute used to apply a category to a test\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.CategoryAttribute.categoryName">\r
+            <summary>\r
+            The name of the category\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.CategoryAttribute.#ctor(System.String)">\r
+            <summary>\r
+            Construct attribute for a given category based on\r
+            a name. The name may not contain the characters ',',\r
+            '+', '-' or '!'. However, this is not checked in the\r
+            constructor since it would cause an error to arise at\r
+            as the test was loaded without giving a clear indication\r
+            of where the problem is located. The error is handled\r
+            in NUnitFramework.cs by marking the test as not\r
+            runnable.\r
+            </summary>\r
+            <param name="name">The name of the category</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.CategoryAttribute.#ctor">\r
+            <summary>\r
+            Protected constructor uses the Type name as the name\r
+            of the category.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.CategoryAttribute.Name">\r
+            <summary>\r
+            The name of the category\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.DatapointAttribute">\r
+            <summary>\r
+            Used to mark a field for use as a datapoint when executing a theory\r
+            within the same fixture that requires an argument of the field's Type.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.DatapointsAttribute">\r
+            <summary>\r
+            Used to mark an array as containing a set of datapoints to be used\r
+            executing a theory within the same fixture that requires an argument \r
+            of the Type of the array elements.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.DescriptionAttribute">\r
+            <summary>\r
+            Attribute used to provide descriptive text about a \r
+            test case or fixture.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.DescriptionAttribute.#ctor(System.String)">\r
+            <summary>\r
+            Construct the attribute\r
+            </summary>\r
+            <param name="description">Text describing the test</param>\r
+        </member>\r
+        <member name="P:NUnit.Framework.DescriptionAttribute.Description">\r
+            <summary>\r
+            Gets the test description\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.MessageMatch">\r
+            <summary>\r
+            Enumeration indicating how the expected message parameter is to be used\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.MessageMatch.Exact">\r
+            Expect an exact match\r
+        </member>\r
+        <member name="F:NUnit.Framework.MessageMatch.Contains">\r
+            Expect a message containing the parameter string\r
+        </member>\r
+        <member name="F:NUnit.Framework.MessageMatch.Regex">\r
+            Match the regular expression provided as a parameter\r
+        </member>\r
+        <member name="F:NUnit.Framework.MessageMatch.StartsWith">\r
+            Expect a message that starts with the parameter string\r
+        </member>\r
+        <member name="T:NUnit.Framework.ExpectedExceptionAttribute">\r
+            <summary>\r
+            ExpectedExceptionAttribute\r
+            </summary>\r
+            \r
+        </member>\r
+        <member name="M:NUnit.Framework.ExpectedExceptionAttribute.#ctor">\r
+            <summary>\r
+            Constructor for a non-specific exception\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.ExpectedExceptionAttribute.#ctor(System.Type)">\r
+            <summary>\r
+            Constructor for a given type of exception\r
+            </summary>\r
+            <param name="exceptionType">The type of the expected exception</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.ExpectedExceptionAttribute.#ctor(System.String)">\r
+            <summary>\r
+            Constructor for a given exception name\r
+            </summary>\r
+            <param name="exceptionName">The full name of the expected exception</param>\r
+        </member>\r
+        <member name="P:NUnit.Framework.ExpectedExceptionAttribute.ExpectedException">\r
+            <summary>\r
+            Gets or sets the expected exception type\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.ExpectedExceptionAttribute.ExpectedExceptionName">\r
+            <summary>\r
+            Gets or sets the full Type name of the expected exception\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.ExpectedExceptionAttribute.ExpectedMessage">\r
+            <summary>\r
+            Gets or sets the expected message text\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.ExpectedExceptionAttribute.UserMessage">\r
+            <summary>\r
+            Gets or sets the user message displayed in case of failure\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.ExpectedExceptionAttribute.MatchType">\r
+            <summary>\r
+             Gets or sets the type of match to be performed on the expected message\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.ExpectedExceptionAttribute.Handler">\r
+            <summary>\r
+             Gets the name of a method to be used as an exception handler\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.ExplicitAttribute">\r
+            <summary>\r
+            ExplicitAttribute marks a test or test fixture so that it will\r
+            only be run if explicitly executed from the gui or command line\r
+            or if it is included by use of a filter. The test will not be\r
+            run simply because an enclosing suite is run.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.ExplicitAttribute.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.ExplicitAttribute.#ctor(System.String)">\r
+            <summary>\r
+            Constructor with a reason\r
+            </summary>\r
+            <param name="reason">The reason test is marked explicit</param>\r
+        </member>\r
+        <member name="P:NUnit.Framework.ExplicitAttribute.Reason">\r
+            <summary>\r
+            The reason test is marked explicit\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.IgnoreAttribute">\r
+            <summary>\r
+            Attribute used to mark a test that is to be ignored.\r
+            Ignored tests result in a warning message when the\r
+            tests are run.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.IgnoreAttribute.#ctor">\r
+            <summary>\r
+            Constructs the attribute without giving a reason \r
+            for ignoring the test.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.IgnoreAttribute.#ctor(System.String)">\r
+            <summary>\r
+            Constructs the attribute giving a reason for ignoring the test\r
+            </summary>\r
+            <param name="reason">The reason for ignoring the test</param>\r
+        </member>\r
+        <member name="P:NUnit.Framework.IgnoreAttribute.Reason">\r
+            <summary>\r
+            The reason for ignoring a test\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.IncludeExcludeAttribute">\r
+            <summary>\r
+            Abstract base for Attributes that are used to include tests\r
+            in the test run based on environmental settings.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.IncludeExcludeAttribute.#ctor">\r
+            <summary>\r
+            Constructor with no included items specified, for use\r
+            with named property syntax.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.IncludeExcludeAttribute.#ctor(System.String)">\r
+            <summary>\r
+            Constructor taking one or more included items\r
+            </summary>\r
+            <param name="include">Comma-delimited list of included items</param>\r
+        </member>\r
+        <member name="P:NUnit.Framework.IncludeExcludeAttribute.Include">\r
+            <summary>\r
+            Name of the item that is needed in order for\r
+            a test to run. Multiple itemss may be given,\r
+            separated by a comma.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.IncludeExcludeAttribute.Exclude">\r
+            <summary>\r
+            Name of the item to be excluded. Multiple items\r
+            may be given, separated by a comma.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.IncludeExcludeAttribute.Reason">\r
+            <summary>\r
+            The reason for including or excluding the test\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.PlatformAttribute">\r
+            <summary>\r
+            PlatformAttribute is used to mark a test fixture or an\r
+            individual method as applying to a particular platform only.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.PlatformAttribute.#ctor">\r
+            <summary>\r
+            Constructor with no platforms specified, for use\r
+            with named property syntax.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.PlatformAttribute.#ctor(System.String)">\r
+            <summary>\r
+            Constructor taking one or more platforms\r
+            </summary>\r
+            <param name="platforms">Comma-deliminted list of platforms</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.CultureAttribute">\r
+            <summary>\r
+            CultureAttribute is used to mark a test fixture or an\r
+            individual method as applying to a particular Culture only.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.CultureAttribute.#ctor">\r
+            <summary>\r
+            Constructor with no cultures specified, for use\r
+            with named property syntax.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.CultureAttribute.#ctor(System.String)">\r
+            <summary>\r
+            Constructor taking one or more cultures\r
+            </summary>\r
+            <param name="cultures">Comma-deliminted list of cultures</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.CombinatorialAttribute">\r
+            <summary>\r
+            Marks a test to use a combinatorial join of any argument data \r
+            provided. NUnit will create a test case for every combination of \r
+            the arguments provided. This can result in a large number of test\r
+            cases and so should be used judiciously. This is the default join\r
+            type, so the attribute need not be used except as documentation.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.PropertyAttribute">\r
+            <summary>\r
+            PropertyAttribute is used to attach information to a test as a name/value pair..\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.String,System.String)">\r
+            <summary>\r
+            Construct a PropertyAttribute with a name and string value\r
+            </summary>\r
+            <param name="propertyName">The name of the property</param>\r
+            <param name="propertyValue">The property value</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.String,System.Int32)">\r
+            <summary>\r
+            Construct a PropertyAttribute with a name and int value\r
+            </summary>\r
+            <param name="propertyName">The name of the property</param>\r
+            <param name="propertyValue">The property value</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.String,System.Double)">\r
+            <summary>\r
+            Construct a PropertyAttribute with a name and double value\r
+            </summary>\r
+            <param name="propertyName">The name of the property</param>\r
+            <param name="propertyValue">The property value</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.PropertyAttribute.#ctor">\r
+            <summary>\r
+            Constructor for derived classes that set the\r
+            property dictionary directly.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.Object)">\r
+            <summary>\r
+            Constructor for use by derived classes that use the\r
+            name of the type as the property name. Derived classes\r
+            must ensure that the Type of the property value is\r
+            a standard type supported by the BCL. Any custom\r
+            types will cause a serialization Exception when\r
+            in the client.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.PropertyAttribute.Properties">\r
+            <summary>\r
+            Gets the property dictionary for this attribute\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.CombinatorialAttribute.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.PairwiseAttribute">\r
+            <summary>\r
+            Marks a test to use pairwise join of any argument data provided. \r
+            NUnit will attempt too excercise every pair of argument values at \r
+            least once, using as small a number of test cases as it can. With\r
+            only two arguments, this is the same as a combinatorial join.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.PairwiseAttribute.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.SequentialAttribute">\r
+            <summary>\r
+            Marks a test to use a sequential join of any argument data\r
+            provided. NUnit will use arguements for each parameter in\r
+            sequence, generating test cases up to the largest number\r
+            of argument values provided and using null for any arguments\r
+            for which it runs out of values. Normally, this should be\r
+            used with the same number of arguments for each parameter.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.SequentialAttribute.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.MaxTimeAttribute">\r
+            <summary>\r
+            Summary description for MaxTimeAttribute.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.MaxTimeAttribute.#ctor(System.Int32)">\r
+            <summary>\r
+            Construct a MaxTimeAttribute, given a time in milliseconds.\r
+            </summary>\r
+            <param name="milliseconds">The maximum elapsed time in milliseconds</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.RandomAttribute">\r
+            <summary>\r
+            RandomAttribute is used to supply a set of random values\r
+            to a single parameter of a parameterized test.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.ValuesAttribute">\r
+            <summary>\r
+            ValuesAttribute is used to provide literal arguments for\r
+            an individual parameter of a test.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.ParameterDataAttribute">\r
+            <summary>\r
+            Abstract base class for attributes that apply to parameters \r
+            and supply data for the parameter.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.ParameterDataAttribute.GetData(System.Reflection.ParameterInfo)">\r
+            <summary>\r
+            Gets the data to be provided to the specified parameter\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.ValuesAttribute.data">\r
+            <summary>\r
+            The collection of data to be returned. Must\r
+            be set by any derived attribute classes.\r
+            We use an object[] so that the individual\r
+            elements may have their type changed in GetData\r
+            if necessary.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object)">\r
+            <summary>\r
+            Construct with one argument\r
+            </summary>\r
+            <param name="arg1"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object,System.Object)">\r
+            <summary>\r
+            Construct with two arguments\r
+            </summary>\r
+            <param name="arg1"></param>\r
+            <param name="arg2"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object,System.Object,System.Object)">\r
+            <summary>\r
+            Construct with three arguments\r
+            </summary>\r
+            <param name="arg1"></param>\r
+            <param name="arg2"></param>\r
+            <param name="arg3"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object[])">\r
+            <summary>\r
+            Construct with an array of arguments\r
+            </summary>\r
+            <param name="args"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.ValuesAttribute.GetData(System.Reflection.ParameterInfo)">\r
+            <summary>\r
+            Get the collection of values to be used as arguments\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.RandomAttribute.#ctor(System.Int32)">\r
+            <summary>\r
+            Construct a set of doubles from 0.0 to 1.0,\r
+            specifying only the count.\r
+            </summary>\r
+            <param name="count"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.RandomAttribute.#ctor(System.Double,System.Double,System.Int32)">\r
+            <summary>\r
+            Construct a set of doubles from min to max\r
+            </summary>\r
+            <param name="min"></param>\r
+            <param name="max"></param>\r
+            <param name="count"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.RandomAttribute.#ctor(System.Int32,System.Int32,System.Int32)">\r
+            <summary>\r
+            Construct a set of ints from min to max\r
+            </summary>\r
+            <param name="min"></param>\r
+            <param name="max"></param>\r
+            <param name="count"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.RandomAttribute.GetData(System.Reflection.ParameterInfo)">\r
+            <summary>\r
+            Get the collection of values to be used as arguments\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.RangeAttribute">\r
+            <summary>\r
+            RangeAttribute is used to supply a range of values to an\r
+            individual parameter of a parameterized test.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Int32,System.Int32)">\r
+            <summary>\r
+            Construct a range of ints using default step of 1\r
+            </summary>\r
+            <param name="from"></param>\r
+            <param name="to"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Int32,System.Int32,System.Int32)">\r
+            <summary>\r
+            Construct a range of ints specifying the step size \r
+            </summary>\r
+            <param name="from"></param>\r
+            <param name="to"></param>\r
+            <param name="step"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Int64,System.Int64,System.Int64)">\r
+            <summary>\r
+            Construct a range of longs\r
+            </summary>\r
+            <param name="from"></param>\r
+            <param name="to"></param>\r
+            <param name="step"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Double,System.Double,System.Double)">\r
+            <summary>\r
+            Construct a range of doubles\r
+            </summary>\r
+            <param name="from"></param>\r
+            <param name="to"></param>\r
+            <param name="step"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Single,System.Single,System.Single)">\r
+            <summary>\r
+            Construct a range of floats\r
+            </summary>\r
+            <param name="from"></param>\r
+            <param name="to"></param>\r
+            <param name="step"></param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.RepeatAttribute">\r
+            <summary>\r
+            RepeatAttribute may be applied to test case in order\r
+            to run it multiple times.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.RepeatAttribute.#ctor(System.Int32)">\r
+            <summary>\r
+            Construct a RepeatAttribute\r
+            </summary>\r
+            <param name="count">The number of times to run the test</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.RequiredAddinAttribute">\r
+            <summary>\r
+            RequiredAddinAttribute may be used to indicate the names of any addins\r
+            that must be present in order to run some or all of the tests in an\r
+            assembly. If the addin is not loaded, the entire assembly is marked\r
+            as NotRunnable.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.RequiredAddinAttribute.#ctor(System.String)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:RequiredAddinAttribute"/> class.\r
+            </summary>\r
+            <param name="requiredAddin">The required addin.</param>\r
+        </member>\r
+        <member name="P:NUnit.Framework.RequiredAddinAttribute.RequiredAddin">\r
+            <summary>\r
+            Gets the name of required addin.\r
+            </summary>\r
+            <value>The required addin name.</value>\r
+        </member>\r
+        <member name="T:NUnit.Framework.SetCultureAttribute">\r
+            <summary>\r
+            Summary description for SetCultureAttribute.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.SetCultureAttribute.#ctor(System.String)">\r
+            <summary>\r
+            Construct given the name of a culture\r
+            </summary>\r
+            <param name="culture"></param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.SetUICultureAttribute">\r
+            <summary>\r
+            Summary description for SetUICultureAttribute.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.SetUICultureAttribute.#ctor(System.String)">\r
+            <summary>\r
+            Construct given the name of a culture\r
+            </summary>\r
+            <param name="culture"></param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.SetUpAttribute">\r
+            <summary>\r
+            Attribute used to mark a class that contains one-time SetUp \r
+            and/or TearDown methods that apply to all the tests in a\r
+            namespace or an assembly.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.SetUpFixtureAttribute">\r
+            <summary>\r
+            SetUpFixtureAttribute is used to identify a SetUpFixture\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.SuiteAttribute">\r
+            <summary>\r
+            Attribute used to mark a static (shared in VB) property\r
+            that returns a list of tests.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.TearDownAttribute">\r
+            <summary>\r
+            Attribute used to identify a method that is called \r
+            immediately after each test is run. The method is \r
+            guaranteed to be called, even if an exception is thrown.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.TestAttribute">\r
+            <summary>\r
+            Adding this attribute to a method within a <seealso cref="T:NUnit.Framework.TestFixtureAttribute"/> \r
+            class makes the method callable from the NUnit test runner. There is a property \r
+            called Description which is optional which you can provide a more detailed test\r
+            description. This class cannot be inherited.\r
+            </summary>\r
+            \r
+            <example>\r
+            [TestFixture]\r
+            public class Fixture\r
+            {\r
+              [Test]\r
+              public void MethodToTest()\r
+              {}\r
+              \r
+              [Test(Description = "more detailed description")]\r
+              publc void TestDescriptionMethod()\r
+              {}\r
+            }\r
+            </example>\r
+            \r
+        </member>\r
+        <member name="P:NUnit.Framework.TestAttribute.Description">\r
+            <summary>\r
+            Descriptive text for this test\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.TestCaseAttribute">\r
+            <summary>\r
+            TestCaseAttribute is used to mark parameterized test cases\r
+            and provide them with their arguments.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.ITestCaseData">\r
+            <summary>\r
+            The ITestCaseData interface is implemented by a class\r
+            that is able to return complete testcases for use by\r
+            a parameterized test method.\r
+            \r
+            NOTE: This interface is used in both the framework\r
+            and the core, even though that results in two different\r
+            types. However, sharing the source code guarantees that\r
+            the various implementations will be compatible and that\r
+            the core is able to reflect successfully over the\r
+            framework implementations of ITestCaseData.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.ITestCaseData.Arguments">\r
+            <summary>\r
+            Gets the argument list to be provided to the test\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.ITestCaseData.Result">\r
+            <summary>\r
+            Gets the expected result\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.ITestCaseData.ExpectedException">\r
+            <summary>\r
+             Gets the expected exception Type\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.ITestCaseData.ExpectedExceptionName">\r
+            <summary>\r
+            Gets the FullName of the expected exception\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.ITestCaseData.TestName">\r
+            <summary>\r
+            Gets the name to be used for the test\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.ITestCaseData.Description">\r
+            <summary>\r
+            Gets the description of the test\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.ITestCaseData.Ignored">\r
+            <summary>\r
+            Gets a value indicating whether this <see cref="T:NUnit.Framework.ITestCaseData"/> is ignored.\r
+            </summary>\r
+            <value><c>true</c> if ignored; otherwise, <c>false</c>.</value>\r
+        </member>\r
+        <member name="P:NUnit.Framework.ITestCaseData.IgnoreReason">\r
+            <summary>\r
+            Gets the ignore reason.\r
+            </summary>\r
+            <value>The ignore reason.</value>\r
+        </member>\r
+        <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object[])">\r
+            <summary>\r
+            Construct a TestCaseAttribute with a list of arguments.\r
+            This constructor is not CLS-Compliant\r
+            </summary>\r
+            <param name="arguments"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object)">\r
+            <summary>\r
+            Construct a TestCaseAttribute with a single argument\r
+            </summary>\r
+            <param name="arg"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object,System.Object)">\r
+            <summary>\r
+            Construct a TestCaseAttribute with a two arguments\r
+            </summary>\r
+            <param name="arg1"></param>\r
+            <param name="arg2"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object,System.Object,System.Object)">\r
+            <summary>\r
+            Construct a TestCaseAttribute with a three arguments\r
+            </summary>\r
+            <param name="arg1"></param>\r
+            <param name="arg2"></param>\r
+            <param name="arg3"></param>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestCaseAttribute.Arguments">\r
+            <summary>\r
+            Gets the list of arguments to a test case\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestCaseAttribute.Result">\r
+            <summary>\r
+            Gets or sets the expected result.\r
+            </summary>\r
+            <value>The result.</value>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestCaseAttribute.Categories">\r
+            <summary>\r
+            Gets a list of categories associated with this test;\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestCaseAttribute.Category">\r
+            <summary>\r
+            Gets or sets the category associated with this test.\r
+            May be a single category or a comma-separated list.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestCaseAttribute.ExpectedException">\r
+            <summary>\r
+            Gets or sets the expected exception.\r
+            </summary>\r
+            <value>The expected exception.</value>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestCaseAttribute.ExpectedExceptionName">\r
+            <summary>\r
+            Gets or sets the name the expected exception.\r
+            </summary>\r
+            <value>The expected name of the exception.</value>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestCaseAttribute.ExpectedMessage">\r
+            <summary>\r
+            Gets or sets the expected message of the expected exception\r
+            </summary>\r
+            <value>The expected message of the exception.</value>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestCaseAttribute.MatchType">\r
+            <summary>\r
+             Gets or sets the type of match to be performed on the expected message\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestCaseAttribute.Description">\r
+            <summary>\r
+            Gets or sets the description.\r
+            </summary>\r
+            <value>The description.</value>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestCaseAttribute.TestName">\r
+            <summary>\r
+            Gets or sets the name of the test.\r
+            </summary>\r
+            <value>The name of the test.</value>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestCaseAttribute.Ignore">\r
+            <summary>\r
+            Gets or sets the ignored status of the test\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestCaseAttribute.Ignored">\r
+            <summary>\r
+            Gets or sets the ignored status of the test\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestCaseAttribute.IgnoreReason">\r
+            <summary>\r
+            Gets the ignore reason.\r
+            </summary>\r
+            <value>The ignore reason.</value>\r
+        </member>\r
+        <member name="T:NUnit.Framework.TestCaseSourceAttribute">\r
+            <summary>\r
+            FactoryAttribute indicates the source to be used to\r
+            provide test cases for a test method.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.TestCaseSourceAttribute.#ctor(System.String)">\r
+            <summary>\r
+            Construct with the name of the factory - for use with languages\r
+            that don't support params arrays.\r
+            </summary>\r
+            <param name="sourceName">An array of the names of the factories that will provide data</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.TestCaseSourceAttribute.#ctor(System.Type,System.String)">\r
+            <summary>\r
+            Construct with a Type and name - for use with languages\r
+            that don't support params arrays.\r
+            </summary>\r
+            <param name="sourceType">The Type that will provide data</param>\r
+            <param name="sourceName">The name of the method, property or field that will provide data</param>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestCaseSourceAttribute.SourceName">\r
+            <summary>\r
+            The name of a the method, property or fiend to be used as a source\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestCaseSourceAttribute.SourceType">\r
+            <summary>\r
+            A Type to be used as a source\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.TestFixtureAttribute">\r
+            <example>\r
+            [TestFixture]\r
+            public class ExampleClass \r
+            {}\r
+            </example>\r
+        </member>\r
+        <member name="M:NUnit.Framework.TestFixtureAttribute.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.TestFixtureAttribute.#ctor(System.Object[])">\r
+            <summary>\r
+            Construct with a object[] representing a set of arguments. \r
+            In .NET 2.0, the arguments may later be separated into\r
+            type arguments and constructor arguments.\r
+            </summary>\r
+            <param name="arguments"></param>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestFixtureAttribute.Description">\r
+            <summary>\r
+            Descriptive text for this fixture\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestFixtureAttribute.Category">\r
+            <summary>\r
+            Gets and sets the category for this fixture.\r
+            May be a comma-separated list of categories.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestFixtureAttribute.Categories">\r
+            <summary>\r
+            Gets a list of categories for this fixture\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestFixtureAttribute.Arguments">\r
+            <summary>\r
+            The arguments originally provided to the attribute\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestFixtureAttribute.Ignore">\r
+            <summary>\r
+            Gets or sets a value indicating whether this <see cref="T:NUnit.Framework.TestFixtureAttribute"/> should be ignored.\r
+            </summary>\r
+            <value><c>true</c> if ignore; otherwise, <c>false</c>.</value>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestFixtureAttribute.IgnoreReason">\r
+            <summary>\r
+            Gets or sets the ignore reason. May set Ignored as a side effect.\r
+            </summary>\r
+            <value>The ignore reason.</value>\r
+        </member>\r
+        <member name="P:NUnit.Framework.TestFixtureAttribute.TypeArgs">\r
+            <summary>\r
+            Get or set the type arguments. If not set\r
+            explicitly, any leading arguments that are\r
+            Types are taken as type arguments.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.TestFixtureSetUpAttribute">\r
+            <summary>\r
+            Attribute used to identify a method that is \r
+            called before any tests in a fixture are run.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.TestFixtureTearDownAttribute">\r
+            <summary>\r
+            Attribute used to identify a method that is called after\r
+            all the tests in a fixture have run. The method is \r
+            guaranteed to be called, even if an exception is thrown.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.TheoryAttribute">\r
+            <summary>\r
+            Adding this attribute to a method within a <seealso cref="T:NUnit.Framework.TestFixtureAttribute"/> \r
+            class makes the method callable from the NUnit test runner. There is a property \r
+            called Description which is optional which you can provide a more detailed test\r
+            description. This class cannot be inherited.\r
+            </summary>\r
+            \r
+            <example>\r
+            [TestFixture]\r
+            public class Fixture\r
+            {\r
+              [Test]\r
+              public void MethodToTest()\r
+              {}\r
+              \r
+              [Test(Description = "more detailed description")]\r
+              publc void TestDescriptionMethod()\r
+              {}\r
+            }\r
+            </example>\r
+            \r
+        </member>\r
+        <member name="T:NUnit.Framework.TimeoutAttribute">\r
+            <summary>\r
+            WUsed on a method, marks the test with a timeout value in milliseconds. \r
+            The test will be run in a separate thread and is cancelled if the timeout \r
+            is exceeded. Used on a method or assembly, sets the default timeout \r
+            for all contained test methods.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.TimeoutAttribute.#ctor(System.Int32)">\r
+            <summary>\r
+            Construct a TimeoutAttribute given a time in milliseconds\r
+            </summary>\r
+            <param name="timeout">The timeout value in milliseconds</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.RequiresSTAAttribute">\r
+            <summary>\r
+            Marks a test that must run in the STA, causing it\r
+            to run in a separate thread if necessary.\r
+            \r
+            On methods, you may also use STAThreadAttribute\r
+            to serve the same purpose.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.RequiresSTAAttribute.#ctor">\r
+            <summary>\r
+            Construct a RequiresSTAAttribute\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.RequiresMTAAttribute">\r
+            <summary>\r
+            Marks a test that must run in the MTA, causing it\r
+            to run in a separate thread if necessary.\r
+            \r
+            On methods, you may also use MTAThreadAttribute\r
+            to serve the same purpose.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.RequiresMTAAttribute.#ctor">\r
+            <summary>\r
+            Construct a RequiresMTAAttribute\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.RequiresThreadAttribute">\r
+            <summary>\r
+            Marks a test that must run on a separate thread.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.RequiresThreadAttribute.#ctor">\r
+            <summary>\r
+            Construct a RequiresThreadAttribute\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.RequiresThreadAttribute.#ctor(System.Threading.ApartmentState)">\r
+            <summary>\r
+            Construct a RequiresThreadAttribute, specifying the apartment\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.ValueSourceAttribute">\r
+            <summary>\r
+            ValueSourceAttribute indicates the source to be used to\r
+            provide data for one parameter of a test method.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.ValueSourceAttribute.#ctor(System.String)">\r
+            <summary>\r
+            Construct with the name of the factory - for use with languages\r
+            that don't support params arrays.\r
+            </summary>\r
+            <param name="sourceName">The name of the data source to be used</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.ValueSourceAttribute.#ctor(System.Type,System.String)">\r
+            <summary>\r
+            Construct with a Type and name - for use with languages\r
+            that don't support params arrays.\r
+            </summary>\r
+            <param name="sourceType">The Type that will provide data</param>\r
+            <param name="sourceName">The name of the method, property or field that will provide data</param>\r
+        </member>\r
+        <member name="P:NUnit.Framework.ValueSourceAttribute.SourceName">\r
+            <summary>\r
+            The name of a the method, property or fiend to be used as a source\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.ValueSourceAttribute.SourceType">\r
+            <summary>\r
+            A Type to be used as a source\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.AttributeExistsConstraint">\r
+            <summary>\r
+            AttributeExistsConstraint tests for the presence of a\r
+            specified attribute on  a Type.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.Constraint">\r
+            <summary>\r
+            The Constraint class is the base of all built-in constraints\r
+            within NUnit. It provides the operator overloads used to combine \r
+            constraints.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.IResolveConstraint">\r
+            <summary>\r
+            The IConstraintExpression interface is implemented by all\r
+            complete and resolvable constraints and expressions.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.IResolveConstraint.Resolve">\r
+            <summary>\r
+            Return the top-level constraint for this expression\r
+            </summary>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.Constraint.UNSET">\r
+            <summary>\r
+            Static UnsetObject used to detect derived constraints\r
+            failing to set the actual value.\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.Constraint.actual">\r
+            <summary>\r
+            The actual value being tested against a constraint\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.Constraint.displayName">\r
+            <summary>\r
+            The display name of this Constraint for use by ToString()\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.Constraint.argcnt">\r
+            <summary>\r
+            Argument fields used by ToString();\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.Constraint.builder">\r
+            <summary>\r
+            The builder holding this constraint\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Constraint.#ctor">\r
+            <summary>\r
+            Construct a constraint with no arguments\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Constraint.#ctor(System.Object)">\r
+            <summary>\r
+            Construct a constraint with one argument\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Constraint.#ctor(System.Object,System.Object)">\r
+            <summary>\r
+            Construct a constraint with two arguments\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Constraint.SetBuilder(NUnit.Framework.Constraints.ConstraintBuilder)">\r
+            <summary>\r
+            Sets the ConstraintBuilder holding this constraint\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Constraint.WriteMessageTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the failure message to the MessageWriter provided\r
+            as an argument. The default implementation simply passes\r
+            the constraint and the actual value to the writer, which\r
+            then displays the constraint description and the value.\r
+            \r
+            Constraints that need to provide additional details,\r
+            such as where the error occured can override this.\r
+            </summary>\r
+            <param name="writer">The MessageWriter on which to display the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Constraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Constraint.Matches(NUnit.Framework.Constraints.ActualValueDelegate)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by an\r
+            ActualValueDelegate that returns the value to be tested.\r
+            The default implementation simply evaluates the delegate\r
+            but derived classes may override it to provide for delayed \r
+            processing.\r
+            </summary>\r
+            <param name="del">An ActualValueDelegate</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Constraint.Matches``1(``0@)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given reference.\r
+            The default implementation simply dereferences the value but\r
+            derived classes may override it to provide for delayed processing.\r
+            </summary>\r
+            <param name="actual">A reference to the value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Constraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Constraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the actual value for a failing constraint test to a\r
+            MessageWriter. The default implementation simply writes\r
+            the raw value of actual, leaving it to the writer to\r
+            perform any formatting.\r
+            </summary>\r
+            <param name="writer">The writer on which the actual value is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Constraint.ToString">\r
+            <summary>\r
+            Default override of ToString returns the constraint DisplayName\r
+            followed by any arguments within angle brackets.\r
+            </summary>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Constraint.GetStringRepresentation">\r
+            <summary>\r
+            Returns the string representation of this constraint\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Constraint.op_BitwiseAnd(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            This operator creates a constraint that is satisfied only if both \r
+            argument constraints are satisfied.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Constraint.op_BitwiseOr(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            This operator creates a constraint that is satisfied if either \r
+            of the argument constraints is satisfied.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Constraint.op_LogicalNot(NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            This operator creates a constraint that is satisfied if the \r
+            argument constraint is not satisfied.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Constraint.After(System.Int32)">\r
+            <summary>\r
+            Returns a DelayedConstraint with the specified delay time.\r
+            </summary>\r
+            <param name="delayInMilliseconds">The delay in milliseconds.</param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Constraint.After(System.Int32,System.Int32)">\r
+            <summary>\r
+            Returns a DelayedConstraint with the specified delay time\r
+            and polling interval.\r
+            </summary>\r
+            <param name="delayInMilliseconds">The delay in milliseconds.</param>\r
+            <param name="pollingInterval">The interval at which to test the constraint.</param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.Constraint.DisplayName">\r
+            <summary>\r
+            The display name of this Constraint for use by ToString().\r
+            The default value is the name of the constraint with\r
+            trailing "Constraint" removed. Derived classes may set\r
+            this to another name in their constructors.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.Constraint.And">\r
+            <summary>\r
+            Returns a ConstraintExpression by appending And\r
+            to the current constraint.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.Constraint.With">\r
+            <summary>\r
+            Returns a ConstraintExpression by appending And\r
+            to the current constraint.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.Constraint.Or">\r
+            <summary>\r
+            Returns a ConstraintExpression by appending Or\r
+            to the current constraint.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.Constraint.UnsetObject">\r
+            <summary>\r
+            Class used to detect any derived constraints\r
+            that fail to set the actual value in their\r
+            Matches override.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AttributeExistsConstraint.#ctor(System.Type)">\r
+            <summary>\r
+            Constructs an AttributeExistsConstraint for a specific attribute Type\r
+            </summary>\r
+            <param name="type"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AttributeExistsConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Tests whether the object provides the expected attribute.\r
+            </summary>\r
+            <param name="actual">A Type, MethodInfo, or other ICustomAttributeProvider</param>\r
+            <returns>True if the expected attribute is present, otherwise false</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AttributeExistsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Writes the description of the constraint to the specified writer\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.AttributeConstraint">\r
+            <summary>\r
+            AttributeConstraint tests that a specified attribute is present\r
+            on a Type or other provider and that the value of the attribute\r
+            satisfies some other constraint.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.PrefixConstraint">\r
+            <summary>\r
+            Abstract base class used for prefixes\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.PrefixConstraint.baseConstraint">\r
+            <summary>\r
+            The base constraint\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PrefixConstraint.#ctor(NUnit.Framework.Constraints.IResolveConstraint)">\r
+            <summary>\r
+            Construct given a base constraint\r
+            </summary>\r
+            <param name="resolvable"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AttributeConstraint.#ctor(System.Type,NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Constructs an AttributeConstraint for a specified attriute\r
+            Type and base constraint.\r
+            </summary>\r
+            <param name="type"></param>\r
+            <param name="baseConstraint"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AttributeConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Determines whether the Type or other provider has the \r
+            expected attribute and if its value matches the\r
+            additional constraint specified.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AttributeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Writes a description of the attribute to the specified writer.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AttributeConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Writes the actual value supplied to the specified writer.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AttributeConstraint.GetStringRepresentation">\r
+            <summary>\r
+            Returns a string representation of the constraint.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.BasicConstraint">\r
+            <summary>\r
+            BasicConstraint is the abstract base for constraints that\r
+            perform a simple comparison to a constant value.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.BasicConstraint.#ctor(System.Object,System.String)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:BasicConstraint"/> class.\r
+            </summary>\r
+            <param name="expected">The expected.</param>\r
+            <param name="description">The description.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.BasicConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.BasicConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.NullConstraint">\r
+            <summary>\r
+            NullConstraint tests that the actual value is null\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NullConstraint.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:NullConstraint"/> class.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.TrueConstraint">\r
+            <summary>\r
+            TrueConstraint tests that the actual value is true\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.TrueConstraint.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:TrueConstraint"/> class.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.FalseConstraint">\r
+            <summary>\r
+            FalseConstraint tests that the actual value is false\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.FalseConstraint.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:FalseConstraint"/> class.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.NaNConstraint">\r
+            <summary>\r
+            NaNConstraint tests that the actual value is a double or float NaN\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NaNConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test that the actual value is an NaN\r
+            </summary>\r
+            <param name="actual"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NaNConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a specified writer\r
+            </summary>\r
+            <param name="writer"></param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.BinaryConstraint">\r
+            <summary>\r
+            BinaryConstraint is the abstract base of all constraints\r
+            that combine two other constraints in some fashion.\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.BinaryConstraint.left">\r
+            <summary>\r
+            The first constraint being combined\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.BinaryConstraint.right">\r
+            <summary>\r
+            The second constraint being combined\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.BinaryConstraint.#ctor(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Construct a BinaryConstraint from two other constraints\r
+            </summary>\r
+            <param name="left">The first constraint</param>\r
+            <param name="right">The second constraint</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.AndConstraint">\r
+            <summary>\r
+            AndConstraint succeeds only if both members succeed.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AndConstraint.#ctor(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Create an AndConstraint from two other constraints\r
+            </summary>\r
+            <param name="left">The first constraint</param>\r
+            <param name="right">The second constraint</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AndConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Apply both member constraints to an actual value, succeeding \r
+            succeeding only if both of them succeed.\r
+            </summary>\r
+            <param name="actual">The actual value</param>\r
+            <returns>True if the constraints both succeeded</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AndConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write a description for this contraint to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The MessageWriter to receive the description</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AndConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the actual value for a failing constraint test to a\r
+            MessageWriter. The default implementation simply writes\r
+            the raw value of actual, leaving it to the writer to\r
+            perform any formatting.\r
+            </summary>\r
+            <param name="writer">The writer on which the actual value is displayed</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.OrConstraint">\r
+            <summary>\r
+            OrConstraint succeeds if either member succeeds\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.OrConstraint.#ctor(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Create an OrConstraint from two other constraints\r
+            </summary>\r
+            <param name="left">The first constraint</param>\r
+            <param name="right">The second constraint</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.OrConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Apply the member constraints to an actual value, succeeding \r
+            succeeding as soon as one of them succeeds.\r
+            </summary>\r
+            <param name="actual">The actual value</param>\r
+            <returns>True if either constraint succeeded</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.OrConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write a description for this contraint to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The MessageWriter to receive the description</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.CollectionConstraint">\r
+            <summary>\r
+            CollectionConstraint is the abstract base class for\r
+            constraints that operate on collections.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionConstraint.#ctor">\r
+            <summary>\r
+            Construct an empty CollectionConstraint\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionConstraint.#ctor(System.Object)">\r
+            <summary>\r
+            Construct a CollectionConstraint\r
+            </summary>\r
+            <param name="arg"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionConstraint.IsEmpty(System.Collections.IEnumerable)">\r
+            <summary>\r
+            Determines whether the specified enumerable is empty.\r
+            </summary>\r
+            <param name="enumerable">The enumerable.</param>\r
+            <returns>\r
+               <c>true</c> if the specified enumerable is empty; otherwise, <c>false</c>.\r
+            </returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionConstraint.doMatch(System.Collections.IEnumerable)">\r
+            <summary>\r
+            Protected method to be implemented by derived classes\r
+            </summary>\r
+            <param name="collection"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.CollectionItemsEqualConstraint">\r
+            <summary>\r
+            CollectionItemsEqualConstraint is the abstract base class for all\r
+            collection constraints that apply some notion of item equality\r
+            as a part of their operation.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.#ctor">\r
+            <summary>\r
+            Construct an empty CollectionConstraint\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.#ctor(System.Object)">\r
+            <summary>\r
+            Construct a CollectionConstraint\r
+            </summary>\r
+            <param name="arg"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using(System.Collections.IComparer)">\r
+            <summary>\r
+            Flag the constraint to use the supplied IComparer object.\r
+            </summary>\r
+            <param name="comparer">The IComparer object to use.</param>\r
+            <returns>Self.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using``1(System.Collections.Generic.IComparer{``0})">\r
+            <summary>\r
+            Flag the constraint to use the supplied IComparer object.\r
+            </summary>\r
+            <param name="comparer">The IComparer object to use.</param>\r
+            <returns>Self.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using``1(System.Comparison{``0})">\r
+            <summary>\r
+            Flag the constraint to use the supplied Comparison object.\r
+            </summary>\r
+            <param name="comparer">The IComparer object to use.</param>\r
+            <returns>Self.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using(System.Collections.IEqualityComparer)">\r
+            <summary>\r
+            Flag the constraint to use the supplied IEqualityComparer object.\r
+            </summary>\r
+            <param name="comparer">The IComparer object to use.</param>\r
+            <returns>Self.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using``1(System.Collections.Generic.IEqualityComparer{``0})">\r
+            <summary>\r
+            Flag the constraint to use the supplied IEqualityComparer object.\r
+            </summary>\r
+            <param name="comparer">The IComparer object to use.</param>\r
+            <returns>Self.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.ItemsEqual(System.Object,System.Object)">\r
+            <summary>\r
+            Compares two collection members for equality\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Tally(System.Collections.IEnumerable)">\r
+            <summary>\r
+            Return a new CollectionTally for use in making tests\r
+            </summary>\r
+            <param name="c">The collection to be included in the tally</param>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.IgnoreCase">\r
+            <summary>\r
+            Flag the constraint to ignore case and return self.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.EmptyCollectionConstraint">\r
+            <summary>\r
+            EmptyCollectionConstraint tests whether a collection is empty. \r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EmptyCollectionConstraint.doMatch(System.Collections.IEnumerable)">\r
+            <summary>\r
+            Check that the collection is empty\r
+            </summary>\r
+            <param name="collection"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EmptyCollectionConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer"></param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.UniqueItemsConstraint">\r
+            <summary>\r
+            UniqueItemsConstraint tests whether all the items in a \r
+            collection are unique.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.UniqueItemsConstraint.doMatch(System.Collections.IEnumerable)">\r
+            <summary>\r
+            Check that all items are unique.\r
+            </summary>\r
+            <param name="actual"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.UniqueItemsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write a description of this constraint to a MessageWriter\r
+            </summary>\r
+            <param name="writer"></param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.CollectionContainsConstraint">\r
+            <summary>\r
+            CollectionContainsConstraint is used to test whether a collection\r
+            contains an expected object as a member.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionContainsConstraint.#ctor(System.Object)">\r
+            <summary>\r
+            Construct a CollectionContainsConstraint\r
+            </summary>\r
+            <param name="expected"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionContainsConstraint.doMatch(System.Collections.IEnumerable)">\r
+            <summary>\r
+            Test whether the expected item is contained in the collection\r
+            </summary>\r
+            <param name="actual"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionContainsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write a descripton of the constraint to a MessageWriter\r
+            </summary>\r
+            <param name="writer"></param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.CollectionEquivalentConstraint">\r
+            <summary>\r
+            CollectionEquivalentCOnstraint is used to determine whether two\r
+            collections are equivalent.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionEquivalentConstraint.#ctor(System.Collections.IEnumerable)">\r
+            <summary>\r
+            Construct a CollectionEquivalentConstraint\r
+            </summary>\r
+            <param name="expected"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionEquivalentConstraint.doMatch(System.Collections.IEnumerable)">\r
+            <summary>\r
+            Test whether two collections are equivalent\r
+            </summary>\r
+            <param name="actual"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionEquivalentConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write a description of this constraint to a MessageWriter\r
+            </summary>\r
+            <param name="writer"></param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.CollectionSubsetConstraint">\r
+            <summary>\r
+            CollectionSubsetConstraint is used to determine whether\r
+            one collection is a subset of another\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionSubsetConstraint.#ctor(System.Collections.IEnumerable)">\r
+            <summary>\r
+            Construct a CollectionSubsetConstraint\r
+            </summary>\r
+            <param name="expected">The collection that the actual value is expected to be a subset of</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionSubsetConstraint.doMatch(System.Collections.IEnumerable)">\r
+            <summary>\r
+            Test whether the actual collection is a subset of \r
+            the expected collection provided.\r
+            </summary>\r
+            <param name="actual"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionSubsetConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write a description of this constraint to a MessageWriter\r
+            </summary>\r
+            <param name="writer"></param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.CollectionOrderedConstraint">\r
+            <summary>\r
+            CollectionOrderedConstraint is used to test whether a collection is ordered.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.#ctor">\r
+            <summary>\r
+            Construct a CollectionOrderedConstraint\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.Using(System.Collections.IComparer)">\r
+            <summary>\r
+            Modifies the constraint to use an IComparer and returns self.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.Using``1(System.Collections.Generic.IComparer{``0})">\r
+            <summary>\r
+            Modifies the constraint to use an IComparer&lt;T&gt; and returns self.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.Using``1(System.Comparison{``0})">\r
+            <summary>\r
+            Modifies the constraint to use a Comparison&lt;T&gt; and returns self.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.By(System.String)">\r
+            <summary>\r
+            Modifies the constraint to test ordering by the value of\r
+            a specified property and returns self.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.doMatch(System.Collections.IEnumerable)">\r
+            <summary>\r
+            Test whether the collection is ordered\r
+            </summary>\r
+            <param name="actual"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write a description of the constraint to a MessageWriter\r
+            </summary>\r
+            <param name="writer"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.GetStringRepresentation">\r
+            <summary>\r
+            Returns the string representation of the constraint.\r
+            </summary>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.CollectionOrderedConstraint.Descending">\r
+            <summary>\r
+             If used performs a reverse comparison\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.CollectionTally">\r
+            <summary>\r
+            CollectionTally counts (tallies) the number of\r
+            occurences of each object in one or more enumerations.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionTally.#ctor(NUnit.Framework.Constraints.NUnitEqualityComparer,System.Collections.IEnumerable)">\r
+            <summary>\r
+            Construct a CollectionTally object from a comparer and a collection\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionTally.TryRemove(System.Object)">\r
+            <summary>\r
+            Try to remove an object from the tally\r
+            </summary>\r
+            <param name="o">The object to remove</param>\r
+            <returns>True if successful, false if the object was not found</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionTally.TryRemove(System.Collections.IEnumerable)">\r
+            <summary>\r
+            Try to remove a set of objects from the tally\r
+            </summary>\r
+            <param name="c">The objects to remove</param>\r
+            <returns>True if successful, false if any object was not found</returns>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.CollectionTally.Count">\r
+            <summary>\r
+            The number of objects remaining in the tally\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.ComparisonAdapter">\r
+            <summary>\r
+            ComparisonAdapter class centralizes all comparisons of\r
+            values in NUnit, adapting to the use of any provided\r
+            IComparer, IComparer&lt;T&gt; or Comparison&lt;T&gt;\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.For(System.Collections.IComparer)">\r
+            <summary>\r
+            Returns a ComparisonAdapter that wraps an IComparer\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.For``1(System.Collections.Generic.IComparer{``0})">\r
+            <summary>\r
+            Returns a ComparisonAdapter that wraps an IComparer&lt;T&gt;\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.For``1(System.Comparison{``0})">\r
+            <summary>\r
+            Returns a ComparisonAdapter that wraps a Comparison&lt;T&gt;\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.Compare(System.Object,System.Object)">\r
+            <summary>\r
+            Compares two objects\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ComparisonAdapter.Default">\r
+            <summary>\r
+            Gets the default ComparisonAdapter, which wraps an\r
+            NUnitComparer object.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter.#ctor(System.Collections.IComparer)">\r
+            <summary>\r
+            Construct a ComparisonAdapter for an IComparer\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter.Compare(System.Object,System.Object)">\r
+            <summary>\r
+            Compares two objects\r
+            </summary>\r
+            <param name="expected"></param>\r
+            <param name="actual"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.DefaultComparisonAdapter.#ctor">\r
+            <summary>\r
+            Construct a default ComparisonAdapter\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter`1">\r
+            <summary>\r
+            ComparisonAdapter&lt;T&gt; extends ComparisonAdapter and\r
+            allows use of an IComparer&lt;T&gt; or Comparison&lt;T&gt;\r
+            to actually perform the comparison.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter`1.#ctor(System.Collections.Generic.IComparer{`0})">\r
+            <summary>\r
+            Construct a ComparisonAdapter for an IComparer&lt;T&gt;\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter`1.Compare(System.Object,System.Object)">\r
+            <summary>\r
+            Compare a Type T to an object\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparisonAdapterForComparison`1.#ctor(System.Comparison{`0})">\r
+            <summary>\r
+            Construct a ComparisonAdapter for a Comparison&lt;T&gt;\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparisonAdapterForComparison`1.Compare(System.Object,System.Object)">\r
+            <summary>\r
+            Compare a Type T to an object\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.ComparisonConstraint">\r
+            <summary>\r
+            Abstract base class for constraints that compare values to\r
+            determine if one is greater than, equal to or less than\r
+            the other.\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.expected">\r
+            <summary>\r
+            The value against which a comparison is to be made\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.ltOK">\r
+            <summary>\r
+            If true, less than returns success\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.eqOK">\r
+            <summary>\r
+            if true, equal returns success\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.gtOK">\r
+            <summary>\r
+            if true, greater than returns success\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.predicate">\r
+            <summary>\r
+            The predicate used as a part of the description\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.comparer">\r
+            <summary>\r
+            ComparisonAdapter to be used in making the comparison\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.#ctor(System.Object,System.Boolean,System.Boolean,System.Boolean,System.String)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:ComparisonConstraint"/> class.\r
+            </summary>\r
+            <param name="value">The value against which to make a comparison.</param>\r
+            <param name="ltOK">if set to <c>true</c> less succeeds.</param>\r
+            <param name="eqOK">if set to <c>true</c> equal succeeds.</param>\r
+            <param name="gtOK">if set to <c>true</c> greater succeeds.</param>\r
+            <param name="predicate">String used in describing the constraint.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Using(System.Collections.IComparer)">\r
+            <summary>\r
+            Modifies the constraint to use an IComparer and returns self\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Using``1(System.Collections.Generic.IComparer{``0})">\r
+            <summary>\r
+            Modifies the constraint to use an IComparer&lt;T&gt; and returns self\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Using``1(System.Comparison{``0})">\r
+            <summary>\r
+            Modifies the constraint to use a Comparison&lt;T&gt; and returns self\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.GreaterThanConstraint">\r
+            <summary>\r
+            Tests whether a value is greater than the value supplied to its constructor\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.GreaterThanConstraint.#ctor(System.Object)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:GreaterThanConstraint"/> class.\r
+            </summary>\r
+            <param name="expected">The expected value.</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.GreaterThanOrEqualConstraint">\r
+            <summary>\r
+            Tests whether a value is greater than or equal to the value supplied to its constructor\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.GreaterThanOrEqualConstraint.#ctor(System.Object)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:GreaterThanOrEqualConstraint"/> class.\r
+            </summary>\r
+            <param name="expected">The expected value.</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.LessThanConstraint">\r
+            <summary>\r
+            Tests whether a value is less than the value supplied to its constructor\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.LessThanConstraint.#ctor(System.Object)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:LessThanConstraint"/> class.\r
+            </summary>\r
+            <param name="expected">The expected value.</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.LessThanOrEqualConstraint">\r
+            <summary>\r
+            Tests whether a value is less than or equal to the value supplied to its constructor\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.LessThanOrEqualConstraint.#ctor(System.Object)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:LessThanOrEqualConstraint"/> class.\r
+            </summary>\r
+            <param name="expected">The expected value.</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.ActualValueDelegate">\r
+            <summary>\r
+            Delegate used to delay evaluation of the actual value\r
+            to be used in evaluating a constraint\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.ConstraintBuilder">\r
+            <summary>\r
+            ConstraintBuilder maintains the stacks that are used in\r
+            processing a ConstraintExpression. An OperatorStack\r
+            is used to hold operators that are waiting for their\r
+            operands to be reognized. a ConstraintStack holds \r
+            input constraints as well as the results of each\r
+            operator applied.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:ConstraintBuilder"/> class.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.Append(NUnit.Framework.Constraints.ConstraintOperator)">\r
+            <summary>\r
+            Appends the specified operator to the expression by first\r
+            reducing the operator stack and then pushing the new\r
+            operator on the stack.\r
+            </summary>\r
+            <param name="op">The operator to push.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.Append(NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Appends the specified constraint to the expresson by pushing\r
+            it on the constraint stack.\r
+            </summary>\r
+            <param name="constraint">The constraint to push.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.SetTopOperatorRightContext(System.Object)">\r
+            <summary>\r
+            Sets the top operator right context.\r
+            </summary>\r
+            <param name="rightContext">The right context.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ReduceOperatorStack(System.Int32)">\r
+            <summary>\r
+            Reduces the operator stack until the topmost item\r
+            precedence is greater than or equal to the target precedence.\r
+            </summary>\r
+            <param name="targetPrecedence">The target precedence.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.Resolve">\r
+            <summary>\r
+            Resolves this instance, returning a Constraint. If the builder\r
+            is not currently in a resolvable state, an exception is thrown.\r
+            </summary>\r
+            <returns>The resolved constraint</returns>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.IsResolvable">\r
+            <summary>\r
+            Gets a value indicating whether this instance is resolvable.\r
+            </summary>\r
+            <value>\r
+               <c>true</c> if this instance is resolvable; otherwise, <c>false</c>.\r
+            </value>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack">\r
+            <summary>\r
+            OperatorStack is a type-safe stack for holding ConstraintOperators\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:OperatorStack"/> class.\r
+            </summary>\r
+            <param name="builder">The builder.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Push(NUnit.Framework.Constraints.ConstraintOperator)">\r
+            <summary>\r
+            Pushes the specified operator onto the stack.\r
+            </summary>\r
+            <param name="op">The op.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Pop">\r
+            <summary>\r
+            Pops the topmost operator from the stack.\r
+            </summary>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Empty">\r
+            <summary>\r
+            Gets a value indicating whether this <see cref="T:OpStack"/> is empty.\r
+            </summary>\r
+            <value><c>true</c> if empty; otherwise, <c>false</c>.</value>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Top">\r
+            <summary>\r
+            Gets the topmost operator without modifying the stack.\r
+            </summary>\r
+            <value>The top.</value>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack">\r
+            <summary>\r
+            ConstraintStack is a type-safe stack for holding Constraints\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:ConstraintStack"/> class.\r
+            </summary>\r
+            <param name="builder">The builder.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Push(NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Pushes the specified constraint. As a side effect,\r
+            the constraint's builder field is set to the \r
+            ConstraintBuilder owning this stack.\r
+            </summary>\r
+            <param name="constraint">The constraint.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Pop">\r
+            <summary>\r
+            Pops this topmost constrait from the stack.\r
+            As a side effect, the constraint's builder\r
+            field is set to null.\r
+            </summary>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Empty">\r
+            <summary>\r
+            Gets a value indicating whether this <see cref="T:ConstraintStack"/> is empty.\r
+            </summary>\r
+            <value><c>true</c> if empty; otherwise, <c>false</c>.</value>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Top">\r
+            <summary>\r
+            Gets the topmost constraint without modifying the stack.\r
+            </summary>\r
+            <value>The topmost constraint</value>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.ConstraintExpression">\r
+            <summary>\r
+            ConstraintExpression represents a compound constraint in the \r
+            process of being constructed from a series of syntactic elements.\r
+            \r
+            Individual elements are appended to the expression as they are\r
+            reognized. Once an actual Constraint is appended, the expression\r
+            returns a resolvable Constraint.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.ConstraintExpressionBase">\r
+            <summary>\r
+            ConstraintExpressionBase is the abstract base class for the \r
+            generated ConstraintExpression class, which represents a \r
+            compound constraint in the process of being constructed \r
+            from a series of syntactic elements.\r
+            \r
+            NOTE: ConstraintExpressionBase is aware of some of its\r
+            derived classes, which is an apparent violation of \r
+            encapsulation. Ideally, these classes would be a \r
+            single class, but they must be separated in order to\r
+            allow parts to be generated under .NET 1.x and to\r
+            provide proper user feedback in syntactically \r
+            aware IDEs.\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.ConstraintExpressionBase.builder">\r
+            <summary>\r
+            The ConstraintBuilder holding the elements recognized so far\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:ConstraintExpressionBase"/> class.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:ConstraintExpressionBase"/> \r
+            class passing in a ConstraintBuilder, which may be pre-populated.\r
+            </summary>\r
+            <param name="builder">The builder.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.ToString">\r
+            <summary>\r
+            Returns a string representation of the expression as it\r
+            currently stands. This should only be used for testing,\r
+            since it has the side-effect of resolving the expression.\r
+            </summary>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.Append(NUnit.Framework.Constraints.ConstraintOperator)">\r
+            <summary>\r
+            Appends an operator to the expression and returns the\r
+            resulting expression itself.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.Append(NUnit.Framework.Constraints.SelfResolvingOperator)">\r
+            <summary>\r
+            Appends a self-resolving operator to the expression and\r
+            returns a new ResolvableConstraintExpression.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.Append(NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Appends a constraint to the expression and returns that\r
+            constraint, which is associated with the current state\r
+            of the expression being built.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:ConstraintExpression"/> class.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:ConstraintExpression"/> \r
+            class passing in a ConstraintBuilder, which may be pre-populated.\r
+            </summary>\r
+            <param name="builder">The builder.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Property(System.String)">\r
+            <summary>\r
+            Returns a new PropertyConstraintExpression, which will either\r
+            test for the existence of the named property on the object\r
+            being tested or apply any following constraint to that property.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Attribute(System.Type)">\r
+            <summary>\r
+            Returns a new AttributeConstraint checking for the\r
+            presence of a particular attribute on an object.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Attribute``1">\r
+            <summary>\r
+            Returns a new AttributeConstraint checking for the\r
+            presence of a particular attribute on an object.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Matches(NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Returns the constraint provided as an argument - used to allow custom\r
+            custom constraints to easily participate in the syntax.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Matches``1(System.Predicate{``0})">\r
+            <summary>\r
+            Returns the constraint provided as an argument - used to allow custom\r
+            custom constraints to easily participate in the syntax.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.EqualTo(System.Object)">\r
+            <summary>\r
+            Returns a constraint that tests two items for equality\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SameAs(System.Object)">\r
+            <summary>\r
+            Returns a constraint that tests that two references are the same object\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.GreaterThan(System.Object)">\r
+            <summary>\r
+            Returns a constraint that tests whether the\r
+            actual value is greater than the suppled argument\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.GreaterThanOrEqualTo(System.Object)">\r
+            <summary>\r
+            Returns a constraint that tests whether the\r
+            actual value is greater than or equal to the suppled argument\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AtLeast(System.Object)">\r
+            <summary>\r
+            Returns a constraint that tests whether the\r
+            actual value is greater than or equal to the suppled argument\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.LessThan(System.Object)">\r
+            <summary>\r
+            Returns a constraint that tests whether the\r
+            actual value is less than the suppled argument\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.LessThanOrEqualTo(System.Object)">\r
+            <summary>\r
+            Returns a constraint that tests whether the\r
+            actual value is less than or equal to the suppled argument\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AtMost(System.Object)">\r
+            <summary>\r
+            Returns a constraint that tests whether the\r
+            actual value is less than or equal to the suppled argument\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.TypeOf(System.Type)">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual\r
+            value is of the exact type supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.TypeOf``1">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual\r
+            value is of the exact type supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOf(System.Type)">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is of the type supplied as an argument or a derived type.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOf``1">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is of the type supplied as an argument or a derived type.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOfType(System.Type)">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is of the type supplied as an argument or a derived type.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOfType``1">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is of the type supplied as an argument or a derived type.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableFrom(System.Type)">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is assignable from the type supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableFrom``1">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is assignable from the type supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableTo(System.Type)">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is assignable from the type supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableTo``1">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is assignable from the type supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.EquivalentTo(System.Collections.IEnumerable)">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is a collection containing the same elements as the \r
+            collection supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SubsetOf(System.Collections.IEnumerable)">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is a subset of the collection supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Member(System.Object)">\r
+            <summary>\r
+            Returns a new CollectionContainsConstraint checking for the\r
+            presence of a particular object in the collection.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Contains(System.Object)">\r
+            <summary>\r
+            Returns a new CollectionContainsConstraint checking for the\r
+            presence of a particular object in the collection.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Contains(System.String)">\r
+            <summary>\r
+            Returns a new ContainsConstraint. This constraint\r
+            will, in turn, make use of the appropriate second-level\r
+            constraint, depending on the type of the actual argument. \r
+            This overload is only used if the item sought is a string,\r
+            since any other type implies that we are looking for a \r
+            collection member.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringContaining(System.String)">\r
+            <summary>\r
+            Returns a constraint that succeeds if the actual\r
+            value contains the substring supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.ContainsSubstring(System.String)">\r
+            <summary>\r
+            Returns a constraint that succeeds if the actual\r
+            value contains the substring supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StartsWith(System.String)">\r
+            <summary>\r
+            Returns a constraint that succeeds if the actual\r
+            value starts with the substring supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringStarting(System.String)">\r
+            <summary>\r
+            Returns a constraint that succeeds if the actual\r
+            value starts with the substring supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.EndsWith(System.String)">\r
+            <summary>\r
+            Returns a constraint that succeeds if the actual\r
+            value ends with the substring supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringEnding(System.String)">\r
+            <summary>\r
+            Returns a constraint that succeeds if the actual\r
+            value ends with the substring supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Matches(System.String)">\r
+            <summary>\r
+            Returns a constraint that succeeds if the actual\r
+            value matches the Regex pattern supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringMatching(System.String)">\r
+            <summary>\r
+            Returns a constraint that succeeds if the actual\r
+            value matches the Regex pattern supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SamePath(System.String)">\r
+            <summary>\r
+            Returns a constraint that tests whether the path provided \r
+            is the same as an expected path after canonicalization.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SubPath(System.String)">\r
+            <summary>\r
+            Returns a constraint that tests whether the path provided \r
+            is the same path or under an expected path after canonicalization.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SamePathOrUnder(System.String)">\r
+            <summary>\r
+            Returns a constraint that tests whether the path provided \r
+            is the same path or under an expected path after canonicalization.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InRange(System.IComparable,System.IComparable)">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value falls \r
+            within a specified range.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Not">\r
+            <summary>\r
+            Returns a ConstraintExpression that negates any\r
+            following constraint.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.No">\r
+            <summary>\r
+            Returns a ConstraintExpression that negates any\r
+            following constraint.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.All">\r
+            <summary>\r
+            Returns a ConstraintExpression, which will apply\r
+            the following constraint to all members of a collection,\r
+            succeeding if all of them succeed.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Some">\r
+            <summary>\r
+            Returns a ConstraintExpression, which will apply\r
+            the following constraint to all members of a collection,\r
+            succeeding if at least one of them succeeds.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.None">\r
+            <summary>\r
+            Returns a ConstraintExpression, which will apply\r
+            the following constraint to all members of a collection,\r
+            succeeding if all of them fail.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Length">\r
+            <summary>\r
+            Returns a new ConstraintExpression, which will apply the following\r
+            constraint to the Length property of the object being tested.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Count">\r
+            <summary>\r
+            Returns a new ConstraintExpression, which will apply the following\r
+            constraint to the Count property of the object being tested.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Message">\r
+            <summary>\r
+            Returns a new ConstraintExpression, which will apply the following\r
+            constraint to the Message property of the object being tested.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.InnerException">\r
+            <summary>\r
+            Returns a new ConstraintExpression, which will apply the following\r
+            constraint to the InnerException property of the object being tested.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.With">\r
+            <summary>\r
+            With is currently a NOP - reserved for future use.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Null">\r
+            <summary>\r
+            Returns a constraint that tests for null\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.True">\r
+            <summary>\r
+            Returns a constraint that tests for True\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.False">\r
+            <summary>\r
+            Returns a constraint that tests for False\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.NaN">\r
+            <summary>\r
+            Returns a constraint that tests for NaN\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Empty">\r
+            <summary>\r
+            Returns a constraint that tests for empty\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Unique">\r
+            <summary>\r
+            Returns a constraint that tests whether a collection \r
+            contains all unique items.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.BinarySerializable">\r
+            <summary>\r
+            Returns a constraint that tests whether an object graph is serializable in binary format.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.XmlSerializable">\r
+            <summary>\r
+            Returns a constraint that tests whether an object graph is serializable in xml format.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Ordered">\r
+            <summary>\r
+            Returns a constraint that tests whether a collection is ordered\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.ConstraintFactory">\r
+            <summary>\r
+            Helper class with properties and methods that supply\r
+            a number of constraints used in Asserts.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Property(System.String)">\r
+            <summary>\r
+            Returns a new PropertyConstraintExpression, which will either\r
+            test for the existence of the named property on the object\r
+            being tested or apply any following constraint to that property.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Attribute(System.Type)">\r
+            <summary>\r
+            Returns a new AttributeConstraint checking for the\r
+            presence of a particular attribute on an object.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Attribute``1">\r
+            <summary>\r
+            Returns a new AttributeConstraint checking for the\r
+            presence of a particular attribute on an object.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.EqualTo(System.Object)">\r
+            <summary>\r
+            Returns a constraint that tests two items for equality\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SameAs(System.Object)">\r
+            <summary>\r
+            Returns a constraint that tests that two references are the same object\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.GreaterThan(System.Object)">\r
+            <summary>\r
+            Returns a constraint that tests whether the\r
+            actual value is greater than the suppled argument\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.GreaterThanOrEqualTo(System.Object)">\r
+            <summary>\r
+            Returns a constraint that tests whether the\r
+            actual value is greater than or equal to the suppled argument\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AtLeast(System.Object)">\r
+            <summary>\r
+            Returns a constraint that tests whether the\r
+            actual value is greater than or equal to the suppled argument\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.LessThan(System.Object)">\r
+            <summary>\r
+            Returns a constraint that tests whether the\r
+            actual value is less than the suppled argument\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.LessThanOrEqualTo(System.Object)">\r
+            <summary>\r
+            Returns a constraint that tests whether the\r
+            actual value is less than or equal to the suppled argument\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AtMost(System.Object)">\r
+            <summary>\r
+            Returns a constraint that tests whether the\r
+            actual value is less than or equal to the suppled argument\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.TypeOf(System.Type)">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual\r
+            value is of the exact type supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.TypeOf``1">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual\r
+            value is of the exact type supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOf(System.Type)">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is of the type supplied as an argument or a derived type.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOf``1">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is of the type supplied as an argument or a derived type.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOfType(System.Type)">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is of the type supplied as an argument or a derived type.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOfType``1">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is of the type supplied as an argument or a derived type.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableFrom(System.Type)">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is assignable from the type supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableFrom``1">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is assignable from the type supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableTo(System.Type)">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is assignable from the type supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableTo``1">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is assignable from the type supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.EquivalentTo(System.Collections.IEnumerable)">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is a collection containing the same elements as the \r
+            collection supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SubsetOf(System.Collections.IEnumerable)">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value\r
+            is a subset of the collection supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Member(System.Object)">\r
+            <summary>\r
+            Returns a new CollectionContainsConstraint checking for the\r
+            presence of a particular object in the collection.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Contains(System.Object)">\r
+            <summary>\r
+            Returns a new CollectionContainsConstraint checking for the\r
+            presence of a particular object in the collection.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Contains(System.String)">\r
+            <summary>\r
+            Returns a new ContainsConstraint. This constraint\r
+            will, in turn, make use of the appropriate second-level\r
+            constraint, depending on the type of the actual argument. \r
+            This overload is only used if the item sought is a string,\r
+            since any other type implies that we are looking for a \r
+            collection member.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringContaining(System.String)">\r
+            <summary>\r
+            Returns a constraint that succeeds if the actual\r
+            value contains the substring supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.ContainsSubstring(System.String)">\r
+            <summary>\r
+            Returns a constraint that succeeds if the actual\r
+            value contains the substring supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotContain(System.String)">\r
+            <summary>\r
+            Returns a constraint that fails if the actual\r
+            value contains the substring supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StartsWith(System.String)">\r
+            <summary>\r
+            Returns a constraint that succeeds if the actual\r
+            value starts with the substring supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringStarting(System.String)">\r
+            <summary>\r
+            Returns a constraint that succeeds if the actual\r
+            value starts with the substring supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotStartWith(System.String)">\r
+            <summary>\r
+            Returns a constraint that fails if the actual\r
+            value starts with the substring supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.EndsWith(System.String)">\r
+            <summary>\r
+            Returns a constraint that succeeds if the actual\r
+            value ends with the substring supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringEnding(System.String)">\r
+            <summary>\r
+            Returns a constraint that succeeds if the actual\r
+            value ends with the substring supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotEndWith(System.String)">\r
+            <summary>\r
+            Returns a constraint that fails if the actual\r
+            value ends with the substring supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Matches(System.String)">\r
+            <summary>\r
+            Returns a constraint that succeeds if the actual\r
+            value matches the Regex pattern supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringMatching(System.String)">\r
+            <summary>\r
+            Returns a constraint that succeeds if the actual\r
+            value matches the Regex pattern supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotMatch(System.String)">\r
+            <summary>\r
+            Returns a constraint that fails if the actual\r
+            value matches the pattern supplied as an argument.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SamePath(System.String)">\r
+            <summary>\r
+            Returns a constraint that tests whether the path provided \r
+            is the same as an expected path after canonicalization.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SubPath(System.String)">\r
+            <summary>\r
+            Returns a constraint that tests whether the path provided \r
+            is the same path or under an expected path after canonicalization.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SamePathOrUnder(System.String)">\r
+            <summary>\r
+            Returns a constraint that tests whether the path provided \r
+            is the same path or under an expected path after canonicalization.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InRange(System.IComparable,System.IComparable)">\r
+            <summary>\r
+            Returns a constraint that tests whether the actual value falls \r
+            within a specified range.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Not">\r
+            <summary>\r
+            Returns a ConstraintExpression that negates any\r
+            following constraint.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.No">\r
+            <summary>\r
+            Returns a ConstraintExpression that negates any\r
+            following constraint.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.All">\r
+            <summary>\r
+            Returns a ConstraintExpression, which will apply\r
+            the following constraint to all members of a collection,\r
+            succeeding if all of them succeed.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Some">\r
+            <summary>\r
+            Returns a ConstraintExpression, which will apply\r
+            the following constraint to all members of a collection,\r
+            succeeding if at least one of them succeeds.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.None">\r
+            <summary>\r
+            Returns a ConstraintExpression, which will apply\r
+            the following constraint to all members of a collection,\r
+            succeeding if all of them fail.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Length">\r
+            <summary>\r
+            Returns a new ConstraintExpression, which will apply the following\r
+            constraint to the Length property of the object being tested.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Count">\r
+            <summary>\r
+            Returns a new ConstraintExpression, which will apply the following\r
+            constraint to the Count property of the object being tested.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Message">\r
+            <summary>\r
+            Returns a new ConstraintExpression, which will apply the following\r
+            constraint to the Message property of the object being tested.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.InnerException">\r
+            <summary>\r
+            Returns a new ConstraintExpression, which will apply the following\r
+            constraint to the InnerException property of the object being tested.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Null">\r
+            <summary>\r
+            Returns a constraint that tests for null\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.True">\r
+            <summary>\r
+            Returns a constraint that tests for True\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.False">\r
+            <summary>\r
+            Returns a constraint that tests for False\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.NaN">\r
+            <summary>\r
+            Returns a constraint that tests for NaN\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Empty">\r
+            <summary>\r
+            Returns a constraint that tests for empty\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Unique">\r
+            <summary>\r
+            Returns a constraint that tests whether a collection \r
+            contains all unique items.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.BinarySerializable">\r
+            <summary>\r
+            Returns a constraint that tests whether an object graph is serializable in binary format.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.XmlSerializable">\r
+            <summary>\r
+            Returns a constraint that tests whether an object graph is serializable in xml format.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Ordered">\r
+            <summary>\r
+            Returns a constraint that tests whether a collection is ordered\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.ConstraintOperator">\r
+            <summary>\r
+            The ConstraintOperator class is used internally by a\r
+            ConstraintBuilder to represent an operator that \r
+            modifies or combines constraints. \r
+            \r
+            Constraint operators use left and right precedence\r
+            values to determine whether the top operator on the\r
+            stack should be reduced before pushing a new operator.\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.ConstraintOperator.left_precedence">\r
+            <summary>\r
+            The precedence value used when the operator\r
+            is about to be pushed to the stack.\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.ConstraintOperator.right_precedence">\r
+            <summary>\r
+            The precedence value used when the operator\r
+            is on the top of the stack.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ConstraintOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">\r
+            <summary>\r
+            Reduce produces a constraint from the operator and \r
+            any arguments. It takes the arguments from the constraint \r
+            stack and pushes the resulting constraint on it.\r
+            </summary>\r
+            <param name="stack"></param>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintOperator.LeftContext">\r
+            <summary>\r
+            The syntax element preceding this operator\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintOperator.RightContext">\r
+            <summary>\r
+            The syntax element folowing this operator\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintOperator.LeftPrecedence">\r
+            <summary>\r
+            The precedence value used when the operator\r
+            is about to be pushed to the stack.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ConstraintOperator.RightPrecedence">\r
+            <summary>\r
+            The precedence value used when the operator\r
+            is on the top of the stack.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.PrefixOperator">\r
+            <summary>\r
+            PrefixOperator takes a single constraint and modifies\r
+            it's action in some way.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PrefixOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">\r
+            <summary>\r
+            Reduce produces a constraint from the operator and \r
+            any arguments. It takes the arguments from the constraint \r
+            stack and pushes the resulting constraint on it.\r
+            </summary>\r
+            <param name="stack"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PrefixOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Returns the constraint created by applying this\r
+            prefix to another constraint.\r
+            </summary>\r
+            <param name="constraint"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.NotOperator">\r
+            <summary>\r
+            Negates the test of the constraint it wraps.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NotOperator.#ctor">\r
+            <summary>\r
+            Constructs a new NotOperator\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NotOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Returns a NotConstraint applied to its argument.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.CollectionOperator">\r
+            <summary>\r
+            Abstract base for operators that indicate how to\r
+            apply a constraint to items in a collection.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.CollectionOperator.#ctor">\r
+            <summary>\r
+            Constructs a CollectionOperator\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.AllOperator">\r
+            <summary>\r
+            Represents a constraint that succeeds if all the \r
+            members of a collection match a base constraint.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AllOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Returns a constraint that will apply the argument\r
+            to the members of a collection, succeeding if\r
+            they all succeed.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.SomeOperator">\r
+            <summary>\r
+            Represents a constraint that succeeds if any of the \r
+            members of a collection match a base constraint.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.SomeOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Returns a constraint that will apply the argument\r
+            to the members of a collection, succeeding if\r
+            any of them succeed.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.NoneOperator">\r
+            <summary>\r
+            Represents a constraint that succeeds if none of the \r
+            members of a collection match a base constraint.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NoneOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Returns a constraint that will apply the argument\r
+            to the members of a collection, succeeding if\r
+            none of them succeed.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.WithOperator">\r
+            <summary>\r
+            Represents a constraint that simply wraps the\r
+            constraint provided as an argument, without any\r
+            further functionality, but which modifes the\r
+            order of evaluation because of its precedence.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.WithOperator.#ctor">\r
+            <summary>\r
+            Constructor for the WithOperator\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.WithOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Returns a constraint that wraps its argument\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.SelfResolvingOperator">\r
+            <summary>\r
+            Abstract base class for operators that are able to reduce to a \r
+            constraint whether or not another syntactic element follows.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.PropOperator">\r
+            <summary>\r
+            Operator used to test for the presence of a named Property\r
+            on an object and optionally apply further tests to the\r
+            value of that property.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PropOperator.#ctor(System.String)">\r
+            <summary>\r
+            Constructs a PropOperator for a particular named property\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PropOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">\r
+            <summary>\r
+            Reduce produces a constraint from the operator and \r
+            any arguments. It takes the arguments from the constraint \r
+            stack and pushes the resulting constraint on it.\r
+            </summary>\r
+            <param name="stack"></param>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.PropOperator.Name">\r
+            <summary>\r
+            Gets the name of the property to which the operator applies\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.AttributeOperator">\r
+            <summary>\r
+            Operator that tests for the presence of a particular attribute\r
+            on a type and optionally applies further tests to the attribute.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AttributeOperator.#ctor(System.Type)">\r
+            <summary>\r
+            Construct an AttributeOperator for a particular Type\r
+            </summary>\r
+            <param name="type">The Type of attribute tested</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AttributeOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">\r
+            <summary>\r
+            Reduce produces a constraint from the operator and \r
+            any arguments. It takes the arguments from the constraint \r
+            stack and pushes the resulting constraint on it.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.ThrowsOperator">\r
+            <summary>\r
+            Operator that tests that an exception is thrown and\r
+            optionally applies further tests to the exception.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ThrowsOperator.#ctor">\r
+            <summary>\r
+            Construct a ThrowsOperator\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ThrowsOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">\r
+            <summary>\r
+            Reduce produces a constraint from the operator and \r
+            any arguments. It takes the arguments from the constraint \r
+            stack and pushes the resulting constraint on it.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.BinaryOperator">\r
+            <summary>\r
+            Abstract base class for all binary operators\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.BinaryOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">\r
+            <summary>\r
+            Reduce produces a constraint from the operator and \r
+            any arguments. It takes the arguments from the constraint \r
+            stack and pushes the resulting constraint on it.\r
+            </summary>\r
+            <param name="stack"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.BinaryOperator.ApplyOperator(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Abstract method that produces a constraint by applying\r
+            the operator to its left and right constraint arguments.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.BinaryOperator.LeftPrecedence">\r
+            <summary>\r
+            Gets the left precedence of the operator\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.BinaryOperator.RightPrecedence">\r
+            <summary>\r
+            Gets the right precedence of the operator\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.AndOperator">\r
+            <summary>\r
+            Operator that requires both it's arguments to succeed\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AndOperator.#ctor">\r
+            <summary>\r
+            Construct an AndOperator\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AndOperator.ApplyOperator(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Apply the operator to produce an AndConstraint\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.OrOperator">\r
+            <summary>\r
+            Operator that requires at least one of it's arguments to succeed\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.OrOperator.#ctor">\r
+            <summary>\r
+            Construct an OrOperator\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.OrOperator.ApplyOperator(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Apply the operator to produce an OrConstraint\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.ContainsConstraint">\r
+            <summary>\r
+            ContainsConstraint tests a whether a string contains a substring\r
+            or a collection contains an object. It postpones the decision of\r
+            which test to use until the type of the actual argument is known.\r
+            This allows testing whether a string is contained in a collection\r
+            or as a substring of another string using the same syntax.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ContainsConstraint.#ctor(System.Object)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:ContainsConstraint"/> class.\r
+            </summary>\r
+            <param name="expected">The expected.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ContainsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Using(System.Collections.IComparer)">\r
+            <summary>\r
+            Flag the constraint to use the supplied IComparer object.\r
+            </summary>\r
+            <param name="comparer">The IComparer object to use.</param>\r
+            <returns>Self.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Using``1(System.Collections.Generic.IComparer{``0})">\r
+            <summary>\r
+            Flag the constraint to use the supplied IComparer object.\r
+            </summary>\r
+            <param name="comparer">The IComparer object to use.</param>\r
+            <returns>Self.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Using``1(System.Comparison{``0})">\r
+            <summary>\r
+            Flag the constraint to use the supplied Comparison object.\r
+            </summary>\r
+            <param name="comparer">The IComparer object to use.</param>\r
+            <returns>Self.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Using(System.Collections.IEqualityComparer)">\r
+            <summary>\r
+            Flag the constraint to use the supplied IEqualityComparer object.\r
+            </summary>\r
+            <param name="comparer">The IComparer object to use.</param>\r
+            <returns>Self.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Using``1(System.Collections.Generic.IEqualityComparer{``0})">\r
+            <summary>\r
+            Flag the constraint to use the supplied IEqualityComparer object.\r
+            </summary>\r
+            <param name="comparer">The IComparer object to use.</param>\r
+            <returns>Self.</returns>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ContainsConstraint.IgnoreCase">\r
+            <summary>\r
+            Flag the constraint to ignore case and return self.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.DelayedConstraint">\r
+            <summary>\r
+             Applies a delay to the match so that a match can be evaluated in the future.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.DelayedConstraint.#ctor(NUnit.Framework.Constraints.Constraint,System.Int32)">\r
+            <summary>\r
+             Creates a new DelayedConstraint\r
+            </summary>\r
+            <param name="baseConstraint">The inner constraint two decorate</param>\r
+            <param name="delayInMilliseconds">The time interval after which the match is performed</param>\r
+            <exception cref="T:System.InvalidOperationException">If the value of <paramref name="delayInMilliseconds"/> is less than 0</exception>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.DelayedConstraint.#ctor(NUnit.Framework.Constraints.Constraint,System.Int32,System.Int32)">\r
+            <summary>\r
+             Creates a new DelayedConstraint\r
+            </summary>\r
+            <param name="baseConstraint">The inner constraint two decorate</param>\r
+            <param name="delayInMilliseconds">The time interval after which the match is performed</param>\r
+            <param name="pollingInterval">The time interval used for polling</param>\r
+            <exception cref="T:System.InvalidOperationException">If the value of <paramref name="delayInMilliseconds"/> is less than 0</exception>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.DelayedConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for if the base constraint fails, false if it succeeds</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.DelayedConstraint.Matches(NUnit.Framework.Constraints.ActualValueDelegate)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a delegate\r
+            </summary>\r
+            <param name="del">The delegate whose value is to be tested</param>\r
+            <returns>True for if the base constraint fails, false if it succeeds</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.DelayedConstraint.Matches``1(``0@)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given reference.\r
+            Overridden to wait for the specified delay period before\r
+            calling the base constraint with the dereferenced value.\r
+            </summary>\r
+            <param name="actual">A reference to the value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.DelayedConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.DelayedConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the actual value for a failing constraint test to a MessageWriter.\r
+            </summary>\r
+            <param name="writer">The writer on which the actual value is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.DelayedConstraint.GetStringRepresentation">\r
+            <summary>\r
+            Returns the string representation of the constraint.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.EmptyDirectoryContraint">\r
+            <summary>\r
+            EmptyDirectoryConstraint is used to test that a directory is empty\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EmptyDirectoryContraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EmptyDirectoryContraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EmptyDirectoryContraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the actual value for a failing constraint test to a\r
+            MessageWriter. The default implementation simply writes\r
+            the raw value of actual, leaving it to the writer to\r
+            perform any formatting.\r
+            </summary>\r
+            <param name="writer">The writer on which the actual value is displayed</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.EmptyConstraint">\r
+            <summary>\r
+            EmptyConstraint tests a whether a string or collection is empty,\r
+            postponing the decision about which test is applied until the\r
+            type of the actual argument is known.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EmptyConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EmptyConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.EqualConstraint">\r
+            <summary>\r
+            EqualConstraint is able to compare an actual value with the\r
+            expected value provided in its constructor. Two objects are \r
+            considered equal if both are null, or if both have the same \r
+            value. NUnit has special semantics for some object types.\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.EqualConstraint.clipStrings">\r
+            <summary>\r
+            If true, strings in error messages will be clipped\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.EqualConstraint.comparer">\r
+            <summary>\r
+            NUnitEqualityComparer used to test equality.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.#ctor(System.Object)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:NUnit.Framework.Constraints.EqualConstraint"/> class.\r
+            </summary>\r
+            <param name="expected">The expected value.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.Within(System.Object)">\r
+            <summary>\r
+            Flag the constraint to use a tolerance when determining equality.\r
+            </summary>\r
+            <param name="amount">Tolerance value to be used</param>\r
+            <returns>Self.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.Comparer(System.Collections.IComparer)">\r
+            <summary>\r
+            Flag the constraint to use the supplied IComparer object.\r
+            </summary>\r
+            <param name="comparer">The IComparer object to use.</param>\r
+            <returns>Self.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using(System.Collections.IComparer)">\r
+            <summary>\r
+            Flag the constraint to use the supplied IComparer object.\r
+            </summary>\r
+            <param name="comparer">The IComparer object to use.</param>\r
+            <returns>Self.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using``1(System.Collections.Generic.IComparer{``0})">\r
+            <summary>\r
+            Flag the constraint to use the supplied IComparer object.\r
+            </summary>\r
+            <param name="comparer">The IComparer object to use.</param>\r
+            <returns>Self.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using``1(System.Comparison{``0})">\r
+            <summary>\r
+            Flag the constraint to use the supplied Comparison object.\r
+            </summary>\r
+            <param name="comparer">The IComparer object to use.</param>\r
+            <returns>Self.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using(System.Collections.IEqualityComparer)">\r
+            <summary>\r
+            Flag the constraint to use the supplied IEqualityComparer object.\r
+            </summary>\r
+            <param name="comparer">The IComparer object to use.</param>\r
+            <returns>Self.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using``1(System.Collections.Generic.IEqualityComparer{``0})">\r
+            <summary>\r
+            Flag the constraint to use the supplied IEqualityComparer object.\r
+            </summary>\r
+            <param name="comparer">The IComparer object to use.</param>\r
+            <returns>Self.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.WriteMessageTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write a failure message. Overridden to provide custom \r
+            failure messages for EqualConstraint.\r
+            </summary>\r
+            <param name="writer">The MessageWriter to write to</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write description of this constraint\r
+            </summary>\r
+            <param name="writer">The MessageWriter to write to</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.DisplayCollectionDifferences(NUnit.Framework.Constraints.MessageWriter,System.Collections.ICollection,System.Collections.ICollection,System.Int32)">\r
+            <summary>\r
+            Display the failure information for two collections that did not match.\r
+            </summary>\r
+            <param name="writer">The MessageWriter on which to display</param>\r
+            <param name="expected">The expected collection.</param>\r
+            <param name="actual">The actual collection</param>\r
+            <param name="depth">The depth of this failure in a set of nested collections</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.DisplayCollectionTypesAndSizes(NUnit.Framework.Constraints.MessageWriter,System.Collections.ICollection,System.Collections.ICollection,System.Int32)">\r
+            <summary>\r
+            Displays a single line showing the types and sizes of the expected\r
+            and actual collections or arrays. If both are identical, the value is \r
+            only shown once.\r
+            </summary>\r
+            <param name="writer">The MessageWriter on which to display</param>\r
+            <param name="expected">The expected collection or array</param>\r
+            <param name="actual">The actual collection or array</param>\r
+            <param name="indent">The indentation level for the message line</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.DisplayFailurePoint(NUnit.Framework.Constraints.MessageWriter,System.Collections.ICollection,System.Collections.ICollection,System.Int32,System.Int32)">\r
+            <summary>\r
+            Displays a single line showing the point in the expected and actual\r
+            arrays at which the comparison failed. If the arrays have different\r
+            structures or dimensions, both values are shown.\r
+            </summary>\r
+            <param name="writer">The MessageWriter on which to display</param>\r
+            <param name="expected">The expected array</param>\r
+            <param name="actual">The actual array</param>\r
+            <param name="failurePoint">Index of the failure point in the underlying collections</param>\r
+            <param name="indent">The indentation level for the message line</param>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.IgnoreCase">\r
+            <summary>\r
+            Flag the constraint to ignore case and return self.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.NoClip">\r
+            <summary>\r
+            Flag the constraint to suppress string clipping \r
+            and return self.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.AsCollection">\r
+            <summary>\r
+            Flag the constraint to compare arrays as collections\r
+            and return self.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.Ulps">\r
+            <summary>\r
+            Switches the .Within() modifier to interpret its tolerance as\r
+            a distance in representable values (see remarks).\r
+            </summary>\r
+            <returns>Self.</returns>\r
+            <remarks>\r
+            Ulp stands for "unit in the last place" and describes the minimum\r
+            amount a given value can change. For any integers, an ulp is 1 whole\r
+            digit. For floating point values, the accuracy of which is better\r
+            for smaller numbers and worse for larger numbers, an ulp depends\r
+            on the size of the number. Using ulps for comparison of floating\r
+            point results instead of fixed tolerances is safer because it will\r
+            automatically compensate for the added inaccuracy of larger numbers.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.Percent">\r
+            <summary>\r
+            Switches the .Within() modifier to interpret its tolerance as\r
+            a percentage that the actual values is allowed to deviate from\r
+            the expected value.\r
+            </summary>\r
+            <returns>Self</returns>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.Days">\r
+            <summary>\r
+            Causes the tolerance to be interpreted as a TimeSpan in days.\r
+            </summary>\r
+            <returns>Self</returns>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.Hours">\r
+            <summary>\r
+            Causes the tolerance to be interpreted as a TimeSpan in hours.\r
+            </summary>\r
+            <returns>Self</returns>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.Minutes">\r
+            <summary>\r
+            Causes the tolerance to be interpreted as a TimeSpan in minutes.\r
+            </summary>\r
+            <returns>Self</returns>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.Seconds">\r
+            <summary>\r
+            Causes the tolerance to be interpreted as a TimeSpan in seconds.\r
+            </summary>\r
+            <returns>Self</returns>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.Milliseconds">\r
+            <summary>\r
+            Causes the tolerance to be interpreted as a TimeSpan in milliseconds.\r
+            </summary>\r
+            <returns>Self</returns>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.Ticks">\r
+            <summary>\r
+            Causes the tolerance to be interpreted as a TimeSpan in clock ticks.\r
+            </summary>\r
+            <returns>Self</returns>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.EqualityAdapter">\r
+            <summary>\r
+            EqualityAdapter class handles all equality comparisons\r
+            that use an IEqualityComparer, IEqualityComparer&lt;T&gt;\r
+            or a ComparisonAdapter.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualityAdapter.ObjectsEqual(System.Object,System.Object)">\r
+            <summary>\r
+            Compares two objects, returning true if they are equal\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For(System.Collections.IComparer)">\r
+            <summary>\r
+            Returns an EqualityAdapter that wraps an IComparer.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For(System.Collections.IEqualityComparer)">\r
+            <summary>\r
+            Returns an EqualityAdapter that wraps an IEqualityComparer.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For``1(System.Collections.Generic.IEqualityComparer{``0})">\r
+            <summary>\r
+            Returns an EqualityAdapter that wraps an IEqualityComparer&lt;T&gt;.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For``1(System.Collections.Generic.IComparer{``0})">\r
+            <summary>\r
+            Returns an EqualityAdapter that wraps an IComparer&lt;T&gt;.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For``1(System.Comparison{``0})">\r
+            <summary>\r
+            Returns an EqualityAdapter that wraps a Comparison&lt;T&gt;.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.FloatingPointNumerics">\r
+            <summary>Helper routines for working with floating point numbers</summary>\r
+            <remarks>\r
+              <para>\r
+                The floating point comparison code is based on this excellent article:\r
+                http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm\r
+              </para>\r
+              <para>\r
+                "ULP" means Unit in the Last Place and in the context of this library refers to\r
+                the distance between two adjacent floating point numbers. IEEE floating point\r
+                numbers can only represent a finite subset of natural numbers, with greater\r
+                accuracy for smaller numbers and lower accuracy for very large numbers.\r
+              </para>\r
+              <para>\r
+                If a comparison is allowed "2 ulps" of deviation, that means the values are\r
+                allowed to deviate by up to 2 adjacent floating point values, which might be\r
+                as low as 0.0000001 for small numbers or as high as 10.0 for large numbers.\r
+              </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.AreAlmostEqualUlps(System.Single,System.Single,System.Int32)">\r
+            <summary>Compares two floating point values for equality</summary>\r
+            <param name="left">First floating point value to be compared</param>\r
+            <param name="right">Second floating point value t be compared</param>\r
+            <param name="maxUlps">\r
+              Maximum number of representable floating point values that are allowed to\r
+              be between the left and the right floating point values\r
+            </param>\r
+            <returns>True if both numbers are equal or close to being equal</returns>\r
+            <remarks>\r
+              <para>\r
+                Floating point values can only represent a finite subset of natural numbers.\r
+                For example, the values 2.00000000 and 2.00000024 can be stored in a float,\r
+                but nothing inbetween them.\r
+              </para>\r
+              <para>\r
+                This comparison will count how many possible floating point values are between\r
+                the left and the right number. If the number of possible values between both\r
+                numbers is less than or equal to maxUlps, then the numbers are considered as\r
+                being equal.\r
+              </para>\r
+              <para>\r
+                Implementation partially follows the code outlined here:\r
+                http://www.anttirt.net/2007/08/19/proper-floating-point-comparisons/\r
+              </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.AreAlmostEqualUlps(System.Double,System.Double,System.Int64)">\r
+            <summary>Compares two double precision floating point values for equality</summary>\r
+            <param name="left">First double precision floating point value to be compared</param>\r
+            <param name="right">Second double precision floating point value t be compared</param>\r
+            <param name="maxUlps">\r
+              Maximum number of representable double precision floating point values that are\r
+              allowed to be between the left and the right double precision floating point values\r
+            </param>\r
+            <returns>True if both numbers are equal or close to being equal</returns>\r
+            <remarks>\r
+              <para>\r
+                Double precision floating point values can only represent a limited series of\r
+                natural numbers. For example, the values 2.0000000000000000 and 2.0000000000000004\r
+                can be stored in a double, but nothing inbetween them.\r
+              </para>\r
+              <para>\r
+                This comparison will count how many possible double precision floating point\r
+                values are between the left and the right number. If the number of possible\r
+                values between both numbers is less than or equal to maxUlps, then the numbers\r
+                are considered as being equal.\r
+              </para>\r
+              <para>\r
+                Implementation partially follows the code outlined here:\r
+                http://www.anttirt.net/2007/08/19/proper-floating-point-comparisons/\r
+              </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsInt(System.Single)">\r
+            <summary>\r
+              Reinterprets the memory contents of a floating point value as an integer value\r
+            </summary>\r
+            <param name="value">\r
+              Floating point value whose memory contents to reinterpret\r
+            </param>\r
+            <returns>\r
+              The memory contents of the floating point value interpreted as an integer\r
+            </returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsLong(System.Double)">\r
+            <summary>\r
+              Reinterprets the memory contents of a double precision floating point\r
+              value as an integer value\r
+            </summary>\r
+            <param name="value">\r
+              Double precision floating point value whose memory contents to reinterpret\r
+            </param>\r
+            <returns>\r
+              The memory contents of the double precision floating point value\r
+              interpreted as an integer\r
+            </returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsFloat(System.Int32)">\r
+            <summary>\r
+              Reinterprets the memory contents of an integer as a floating point value\r
+            </summary>\r
+            <param name="value">Integer value whose memory contents to reinterpret</param>\r
+            <returns>\r
+              The memory contents of the integer value interpreted as a floating point value\r
+            </returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsDouble(System.Int64)">\r
+            <summary>\r
+              Reinterprets the memory contents of an integer value as a double precision\r
+              floating point value\r
+            </summary>\r
+            <param name="value">Integer whose memory contents to reinterpret</param>\r
+            <returns>\r
+              The memory contents of the integer interpreted as a double precision\r
+              floating point value\r
+            </returns>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion">\r
+            <summary>Union of a floating point variable and an integer</summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion.Float">\r
+            <summary>The union's value as a floating point variable</summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion.Int">\r
+            <summary>The union's value as an integer</summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion.UInt">\r
+            <summary>The union's value as an unsigned integer</summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion">\r
+            <summary>Union of a double precision floating point variable and a long</summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion.Double">\r
+            <summary>The union's value as a double precision floating point variable</summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion.Long">\r
+            <summary>The union's value as a long</summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion.ULong">\r
+            <summary>The union's value as an unsigned long</summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.MessageWriter">\r
+            <summary>\r
+            MessageWriter is the abstract base for classes that write\r
+            constraint descriptions and messages in some form. The\r
+            class has separate methods for writing various components\r
+            of a message, allowing implementations to tailor the\r
+            presentation as needed.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.#ctor">\r
+            <summary>\r
+            Construct a MessageWriter given a culture\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteMessageLine(System.String,System.Object[])">\r
+            <summary>\r
+            Method to write single line  message with optional args, usually\r
+            written to precede the general failure message.\r
+            </summary>\r
+            <param name="message">The message to be written</param>\r
+            <param name="args">Any arguments used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteMessageLine(System.Int32,System.String,System.Object[])">\r
+            <summary>\r
+            Method to write single line  message with optional args, usually\r
+            written to precede the general failure message, at a givel \r
+            indentation level.\r
+            </summary>\r
+            <param name="level">The indentation level of the message</param>\r
+            <param name="message">The message to be written</param>\r
+            <param name="args">Any arguments used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayDifferences(NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Display Expected and Actual lines for a constraint. This\r
+            is called by MessageWriter's default implementation of \r
+            WriteMessageTo and provides the generic two-line display. \r
+            </summary>\r
+            <param name="constraint">The constraint that failed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayDifferences(System.Object,System.Object)">\r
+            <summary>\r
+            Display Expected and Actual lines for given values. This\r
+            method may be called by constraints that need more control over\r
+            the display of actual and expected values than is provided\r
+            by the default implementation.\r
+            </summary>\r
+            <param name="expected">The expected value</param>\r
+            <param name="actual">The actual value causing the failure</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayDifferences(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance)">\r
+            <summary>\r
+            Display Expected and Actual lines for given values, including\r
+            a tolerance value on the Expected line.\r
+            </summary>\r
+            <param name="expected">The expected value</param>\r
+            <param name="actual">The actual value causing the failure</param>\r
+            <param name="tolerance">The tolerance within which the test was made</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayStringDifferences(System.String,System.String,System.Int32,System.Boolean,System.Boolean)">\r
+            <summary>\r
+            Display the expected and actual string values on separate lines.\r
+            If the mismatch parameter is >=0, an additional line is displayed\r
+            line containing a caret that points to the mismatch point.\r
+            </summary>\r
+            <param name="expected">The expected string value</param>\r
+            <param name="actual">The actual string value</param>\r
+            <param name="mismatch">The point at which the strings don't match or -1</param>\r
+            <param name="ignoreCase">If true, case is ignored in locating the point where the strings differ</param>\r
+            <param name="clipping">If true, the strings should be clipped to fit the line</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteConnector(System.String)">\r
+            <summary>\r
+            Writes the text for a connector.\r
+            </summary>\r
+            <param name="connector">The connector.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.WritePredicate(System.String)">\r
+            <summary>\r
+            Writes the text for a predicate.\r
+            </summary>\r
+            <param name="predicate">The predicate.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteExpectedValue(System.Object)">\r
+            <summary>\r
+            Writes the text for an expected value.\r
+            </summary>\r
+            <param name="expected">The expected value.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteModifier(System.String)">\r
+            <summary>\r
+            Writes the text for a modifier\r
+            </summary>\r
+            <param name="modifier">The modifier.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteActualValue(System.Object)">\r
+            <summary>\r
+            Writes the text for an actual value.\r
+            </summary>\r
+            <param name="actual">The actual value.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteValue(System.Object)">\r
+            <summary>\r
+            Writes the text for a generalized value.\r
+            </summary>\r
+            <param name="val">The value.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteCollectionElements(System.Collections.ICollection,System.Int32,System.Int32)">\r
+            <summary>\r
+            Writes the text for a collection value,\r
+            starting at a particular point, to a max length\r
+            </summary>\r
+            <param name="collection">The collection containing elements to write.</param>\r
+            <param name="start">The starting point of the elements to write</param>\r
+            <param name="max">The maximum number of elements to write</param>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.MessageWriter.MaxLineLength">\r
+            <summary>\r
+            Abstract method to get the max line length\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.MsgUtils">\r
+            <summary>\r
+            Static methods used in creating messages\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.MsgUtils.ELLIPSIS">\r
+            <summary>\r
+            Static string used when strings are clipped\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MsgUtils.GetTypeRepresentation(System.Object)">\r
+            <summary>\r
+            Returns the representation of a type as used in NUnitLite.\r
+            This is the same as Type.ToString() except for arrays,\r
+            which are displayed with their declared sizes.\r
+            </summary>\r
+            <param name="obj"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MsgUtils.EscapeControlChars(System.String)">\r
+            <summary>\r
+            Converts any control characters in a string \r
+            to their escaped representation.\r
+            </summary>\r
+            <param name="s">The string to be converted</param>\r
+            <returns>The converted string</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MsgUtils.GetArrayIndicesAsString(System.Int32[])">\r
+            <summary>\r
+            Return the a string representation for a set of indices into an array\r
+            </summary>\r
+            <param name="indices">Array of indices for which a string is needed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MsgUtils.GetArrayIndicesFromCollectionIndex(System.Collections.ICollection,System.Int32)">\r
+            <summary>\r
+            Get an array of indices representing the point in a collection or\r
+            array corresponding to a single int index into the collection.\r
+            </summary>\r
+            <param name="collection">The collection to which the indices apply</param>\r
+            <param name="index">Index in the collection</param>\r
+            <returns>Array of indices</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MsgUtils.ClipString(System.String,System.Int32,System.Int32)">\r
+            <summary>\r
+            Clip a string to a given length, starting at a particular offset, returning the clipped\r
+            string with ellipses representing the removed parts\r
+            </summary>\r
+            <param name="s">The string to be clipped</param>\r
+            <param name="maxStringLength">The maximum permitted length of the result string</param>\r
+            <param name="clipStart">The point at which to start clipping</param>\r
+            <returns>The clipped string</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MsgUtils.ClipExpectedAndActual(System.String@,System.String@,System.Int32,System.Int32)">\r
+            <summary>\r
+            Clip the expected and actual strings in a coordinated fashion, \r
+            so that they may be displayed together.\r
+            </summary>\r
+            <param name="expected"></param>\r
+            <param name="actual"></param>\r
+            <param name="maxDisplayLength"></param>\r
+            <param name="mismatch"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.MsgUtils.FindMismatchPosition(System.String,System.String,System.Int32,System.Boolean)">\r
+            <summary>\r
+            Shows the position two strings start to differ.  Comparison \r
+            starts at the start index.\r
+            </summary>\r
+            <param name="expected">The expected string</param>\r
+            <param name="actual">The actual string</param>\r
+            <param name="istart">The index in the strings at which comparison should start</param>\r
+            <param name="ignoreCase">Boolean indicating whether case should be ignored</param>\r
+            <returns>-1 if no mismatch found, or the index where mismatch found</returns>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.Numerics">\r
+            <summary>\r
+            The Numerics class contains common operations on numeric values.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Numerics.IsNumericType(System.Object)">\r
+            <summary>\r
+            Checks the type of the object, returning true if\r
+            the object is a numeric type.\r
+            </summary>\r
+            <param name="obj">The object to check</param>\r
+            <returns>true if the object is a numeric type</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Numerics.IsFloatingPointNumeric(System.Object)">\r
+            <summary>\r
+            Checks the type of the object, returning true if\r
+            the object is a floating point numeric type.\r
+            </summary>\r
+            <param name="obj">The object to check</param>\r
+            <returns>true if the object is a floating point numeric type</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Numerics.IsFixedPointNumeric(System.Object)">\r
+            <summary>\r
+            Checks the type of the object, returning true if\r
+            the object is a fixed point numeric type.\r
+            </summary>\r
+            <param name="obj">The object to check</param>\r
+            <returns>true if the object is a fixed point numeric type</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Numerics.AreEqual(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance@)">\r
+            <summary>\r
+            Test two numeric values for equality, performing the usual numeric \r
+            conversions and using a provided or default tolerance. If the tolerance \r
+            provided is Empty, this method may set it to a default tolerance.\r
+            </summary>\r
+            <param name="expected">The expected value</param>\r
+            <param name="actual">The actual value</param>\r
+            <param name="tolerance">A reference to the tolerance in effect</param>\r
+            <returns>True if the values are equal</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Numerics.Compare(System.Object,System.Object)">\r
+            <summary>\r
+            Compare two numeric values, performing the usual numeric conversions.\r
+            </summary>\r
+            <param name="expected">The expected value</param>\r
+            <param name="actual">The actual value</param>\r
+            <returns>The relationship of the values to each other</returns>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.NUnitComparer">\r
+            <summary>\r
+            NUnitComparer encapsulates NUnit's default behavior\r
+            in comparing two objects.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NUnitComparer.Compare(System.Object,System.Object)">\r
+            <summary>\r
+            Compares two objects\r
+            </summary>\r
+            <param name="x"></param>\r
+            <param name="y"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.NUnitComparer.Default">\r
+            <summary>\r
+            Returns the default NUnitComparer.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.NUnitEqualityComparer">\r
+            <summary>\r
+            NUnitEqualityComparer encapsulates NUnit's handling of\r
+            equality tests between objects.\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.caseInsensitive">\r
+            <summary>\r
+            If true, all string comparisons will ignore case\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.compareAsCollection">\r
+            <summary>\r
+            If true, arrays will be treated as collections, allowing\r
+            those of different dimensions to be compared\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.tolerance">\r
+            <summary>\r
+            If non-zero, equality comparisons within the specified \r
+            tolerance will succeed.\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.externalComparer">\r
+            <summary>\r
+            Comparison object used in comparisons for some constraints.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NUnitEqualityComparer.ObjectsEqual(System.Object,System.Object)">\r
+            <summary>\r
+            Compares two objects for equality.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NUnitEqualityComparer.ArraysEqual(System.Array,System.Array)">\r
+            <summary>\r
+            Helper method to compare two arrays\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NUnitEqualityComparer.DirectoriesEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">\r
+            <summary>\r
+            Method to compare two DirectoryInfo objects\r
+            </summary>\r
+            <param name="x">first directory to compare</param>\r
+            <param name="y">second directory to compare</param>\r
+            <returns>true if equivalent, false if not</returns>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.Default">\r
+            <summary>\r
+            Returns the default NUnitEqualityComparer\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.IgnoreCase">\r
+            <summary>\r
+            Gets and sets a flag indicating whether case should\r
+            be ignored in determining equality.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.CompareAsCollection">\r
+            <summary>\r
+            Gets and sets a flag indicating that arrays should be\r
+            compared as collections, without regard to their shape.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.ExternalComparer">\r
+            <summary>\r
+            Gets and sets an external comparer to be used to\r
+            test for equality. It is applied to members of\r
+            collections, in place of NUnit's own logic.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.Tolerance">\r
+            <summary>\r
+            Gets and sets a tolerance used to compare objects of \r
+            certin types.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.FailurePoints">\r
+            <summary>\r
+            Gets the list of failure points for the last Match performed.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.PathConstraint">\r
+            <summary>\r
+            PathConstraint serves as the abstract base of constraints\r
+            that operate on paths and provides several helper methods.\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.PathConstraint.expectedPath">\r
+            <summary>\r
+            The expected path used in the constraint\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.PathConstraint.actualPath">\r
+            <summary>\r
+            The actual path being tested\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.PathConstraint.caseInsensitive">\r
+            <summary>\r
+            Flag indicating whether a caseInsensitive comparison should be made\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PathConstraint.#ctor(System.String)">\r
+            <summary>\r
+            Construct a PathConstraint for a give expected path\r
+            </summary>\r
+            <param name="expected">The expected path</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PathConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PathConstraint.IsMatch(System.String,System.String)">\r
+            <summary>\r
+            Returns true if the expected path and actual path match\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PathConstraint.GetStringRepresentation">\r
+            <summary>\r
+            Returns the string representation of this constraint\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PathConstraint.Canonicalize(System.String)">\r
+            <summary>\r
+            Canonicalize the provided path\r
+            </summary>\r
+            <param name="path"></param>\r
+            <returns>The path in standardized form</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PathConstraint.IsSamePath(System.String,System.String,System.Boolean)">\r
+            <summary>\r
+            Test whether two paths are the same\r
+            </summary>\r
+            <param name="path1">The first path</param>\r
+            <param name="path2">The second path</param>\r
+            <param name="ignoreCase">Indicates whether case should be ignored</param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PathConstraint.IsSubPath(System.String,System.String,System.Boolean)">\r
+            <summary>\r
+            Test whether one path is under another path\r
+            </summary>\r
+            <param name="path1">The first path - supposed to be the parent path</param>\r
+            <param name="path2">The second path - supposed to be the child path</param>\r
+            <param name="ignoreCase">Indicates whether case should be ignored</param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PathConstraint.IsSamePathOrUnder(System.String,System.String)">\r
+            <summary>\r
+            Test whether one path is the same as or under another path\r
+            </summary>\r
+            <param name="path1">The first path - supposed to be the parent path</param>\r
+            <param name="path2">The second path - supposed to be the child path</param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.PathConstraint.IgnoreCase">\r
+            <summary>\r
+            Modifies the current instance to be case-insensitve\r
+            and returns it.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.PathConstraint.RespectCase">\r
+            <summary>\r
+            Modifies the current instance to be case-sensitve\r
+            and returns it.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.SamePathConstraint">\r
+            <summary>\r
+            Summary description for SamePathConstraint.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.SamePathConstraint.#ctor(System.String)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:SamePathConstraint"/> class.\r
+            </summary>\r
+            <param name="expected">The expected path</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.SamePathConstraint.IsMatch(System.String,System.String)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="expectedPath">The expected path</param>\r
+            <param name="actualPath">The actual path</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.SamePathConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.SubPathConstraint">\r
+            <summary>\r
+            SubPathConstraint tests that the actual path is under the expected path\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.SubPathConstraint.#ctor(System.String)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:SubPathConstraint"/> class.\r
+            </summary>\r
+            <param name="expected">The expected path</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.SubPathConstraint.IsMatch(System.String,System.String)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="expectedPath">The expected path</param>\r
+            <param name="actualPath">The actual path</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.SubPathConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.SamePathOrUnderConstraint">\r
+            <summary>\r
+            SamePathOrUnderConstraint tests that one path is under another\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.SamePathOrUnderConstraint.#ctor(System.String)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:SamePathOrUnderConstraint"/> class.\r
+            </summary>\r
+            <param name="expected">The expected path</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.SamePathOrUnderConstraint.IsMatch(System.String,System.String)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="expectedPath">The expected path</param>\r
+            <param name="actualPath">The actual path</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.SamePathOrUnderConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.PredicateConstraint`1">\r
+            <summary>\r
+            Predicate constraint wraps a Predicate in a constraint,\r
+            returning success if the predicate is true.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PredicateConstraint`1.#ctor(System.Predicate{`0})">\r
+            <summary>\r
+            Construct a PredicateConstraint from a predicate\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PredicateConstraint`1.Matches(System.Object)">\r
+            <summary>\r
+            Determines whether the predicate succeeds when applied\r
+            to the actual value.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PredicateConstraint`1.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Writes the description to a MessageWriter\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.NotConstraint">\r
+            <summary>\r
+            NotConstraint negates the effect of some other constraint\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NotConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:NotConstraint"/> class.\r
+            </summary>\r
+            <param name="baseConstraint">The base constraint to be negated.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NotConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for if the base constraint fails, false if it succeeds</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NotConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NotConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the actual value for a failing constraint test to a MessageWriter.\r
+            </summary>\r
+            <param name="writer">The writer on which the actual value is displayed</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.AllItemsConstraint">\r
+            <summary>\r
+            AllItemsConstraint applies another constraint to each\r
+            item in a collection, succeeding if they all succeed.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AllItemsConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Construct an AllItemsConstraint on top of an existing constraint\r
+            </summary>\r
+            <param name="itemConstraint"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AllItemsConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Apply the item constraint to each item in the collection,\r
+            failing if any item fails.\r
+            </summary>\r
+            <param name="actual"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AllItemsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write a description of this constraint to a MessageWriter\r
+            </summary>\r
+            <param name="writer"></param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.SomeItemsConstraint">\r
+            <summary>\r
+            SomeItemsConstraint applies another constraint to each\r
+            item in a collection, succeeding if any of them succeeds.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.SomeItemsConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Construct a SomeItemsConstraint on top of an existing constraint\r
+            </summary>\r
+            <param name="itemConstraint"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.SomeItemsConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Apply the item constraint to each item in the collection,\r
+            succeeding if any item succeeds.\r
+            </summary>\r
+            <param name="actual"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.SomeItemsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write a description of this constraint to a MessageWriter\r
+            </summary>\r
+            <param name="writer"></param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.NoItemConstraint">\r
+            <summary>\r
+            NoItemConstraint applies another constraint to each\r
+            item in a collection, failing if any of them succeeds.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NoItemConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Construct a SomeItemsConstraint on top of an existing constraint\r
+            </summary>\r
+            <param name="itemConstraint"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NoItemConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Apply the item constraint to each item in the collection,\r
+            failing if any item fails.\r
+            </summary>\r
+            <param name="actual"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NoItemConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write a description of this constraint to a MessageWriter\r
+            </summary>\r
+            <param name="writer"></param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.PropertyExistsConstraint">\r
+            <summary>\r
+            PropertyExistsConstraint tests that a named property\r
+            exists on the object provided through Match.\r
+            \r
+            Originally, PropertyConstraint provided this feature\r
+            in addition to making optional tests on the vaue\r
+            of the property. The two constraints are now separate.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.#ctor(System.String)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:PropertyExistConstraint"/> class.\r
+            </summary>\r
+            <param name="name">The name of the property.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the property exists for a given object\r
+            </summary>\r
+            <param name="actual">The object to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the actual value for a failing constraint test to a\r
+            MessageWriter.\r
+            </summary>\r
+            <param name="writer">The writer on which the actual value is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.GetStringRepresentation">\r
+            <summary>\r
+            Returns the string representation of the constraint.\r
+            </summary>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.PropertyConstraint">\r
+            <summary>\r
+            PropertyConstraint extracts a named property and uses\r
+            its value as the actual value for a chained constraint.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PropertyConstraint.#ctor(System.String,NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:PropertyConstraint"/> class.\r
+            </summary>\r
+            <param name="name">The name.</param>\r
+            <param name="baseConstraint">The constraint to apply to the property.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PropertyConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PropertyConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PropertyConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the actual value for a failing constraint test to a\r
+            MessageWriter. The default implementation simply writes\r
+            the raw value of actual, leaving it to the writer to\r
+            perform any formatting.\r
+            </summary>\r
+            <param name="writer">The writer on which the actual value is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.PropertyConstraint.GetStringRepresentation">\r
+            <summary>\r
+            Returns the string representation of the constraint.\r
+            </summary>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.RangeConstraint">\r
+            <summary>\r
+            RangeConstraint tests whethe two values are within a \r
+            specified range.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.RangeConstraint.#ctor(System.IComparable,System.IComparable)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:RangeConstraint"/> class.\r
+            </summary>\r
+            <param name="from">From.</param>\r
+            <param name="to">To.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.RangeConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.RangeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.RangeConstraint.Using(System.Collections.IComparer)">\r
+            <summary>\r
+            Modifies the constraint to use an IComparer and returns self.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.RangeConstraint.Using``1(System.Collections.Generic.IComparer{``0})">\r
+            <summary>\r
+            Modifies the constraint to use an IComparer&lt;T&gt; and returns self.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.RangeConstraint.Using``1(System.Comparison{``0})">\r
+            <summary>\r
+            Modifies the constraint to use a Comparison&lt;T&gt; and returns self.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.ResolvableConstraintExpression">\r
+            <summary>\r
+            ResolvableConstraintExpression is used to represent a compound\r
+            constraint being constructed at a point where the last operator\r
+            may either terminate the expression or may have additional \r
+            qualifying constraints added to it. \r
+            \r
+            It is used, for example, for a Property element or for\r
+            an Exception element, either of which may be optionally\r
+            followed by constraints that apply to the property or \r
+            exception.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.#ctor">\r
+            <summary>\r
+            Create a new instance of ResolvableConstraintExpression\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">\r
+            <summary>\r
+            Create a new instance of ResolvableConstraintExpression,\r
+            passing in a pre-populated ConstraintBuilder.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.NUnit#Framework#Constraints#IResolveConstraint#Resolve">\r
+            <summary>\r
+            Resolve the current expression to a Constraint\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ResolvableConstraintExpression.And">\r
+            <summary>\r
+            Appends an And Operator to the expression\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ResolvableConstraintExpression.Or">\r
+            <summary>\r
+            Appends an Or operator to the expression.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.ReusableConstraint">\r
+            <summary>\r
+            ReusableConstraint wraps a resolved constraint so that it\r
+            may be saved and reused as needed.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ReusableConstraint.#ctor(NUnit.Framework.Constraints.IResolveConstraint)">\r
+            <summary>\r
+            Construct a ReusableConstraint\r
+            </summary>\r
+            <param name="c">The constraint or expression to be reused</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ReusableConstraint.op_Implicit(NUnit.Framework.Constraints.Constraint)~NUnit.Framework.Constraints.ReusableConstraint">\r
+            <summary>\r
+            Conversion operator from a normal constraint to a ReusableConstraint.\r
+            </summary>\r
+            <param name="c">The original constraint to be wrapped as a ReusableConstraint</param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ReusableConstraint.ToString">\r
+            <summary>\r
+            Returns the string representation of the constraint.\r
+            </summary>\r
+            <returns>A string representing the constraint</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ReusableConstraint.Resolve">\r
+            <summary>\r
+            Resolves the ReusableConstraint by returning the constraint\r
+            that it originally wrapped.\r
+            </summary>\r
+            <returns>A resolved constraint</returns>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.SameAsConstraint">\r
+            <summary>\r
+            SameAsConstraint tests whether an object is identical to\r
+            the object passed to its constructor\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.SameAsConstraint.#ctor(System.Object)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:SameAsConstraint"/> class.\r
+            </summary>\r
+            <param name="expected">The expected object.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.SameAsConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.SameAsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.BinarySerializableConstraint">\r
+            <summary>\r
+            BinarySerializableConstraint tests whether \r
+            an object is serializable in binary format.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the actual value for a failing constraint test to a\r
+            MessageWriter. The default implementation simply writes\r
+            the raw value of actual, leaving it to the writer to\r
+            perform any formatting.\r
+            </summary>\r
+            <param name="writer">The writer on which the actual value is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.GetStringRepresentation">\r
+            <summary>\r
+            Returns the string representation\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.XmlSerializableConstraint">\r
+            <summary>\r
+            BinarySerializableConstraint tests whether \r
+            an object is serializable in binary format.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the actual value for a failing constraint test to a\r
+            MessageWriter. The default implementation simply writes\r
+            the raw value of actual, leaving it to the writer to\r
+            perform any formatting.\r
+            </summary>\r
+            <param name="writer">The writer on which the actual value is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.GetStringRepresentation">\r
+            <summary>\r
+            Returns the string representation of this constraint\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.StringConstraint">\r
+            <summary>\r
+            StringConstraint is the abstract base for constraints\r
+            that operate on strings. It supports the IgnoreCase\r
+            modifier for string operations.\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.StringConstraint.expected">\r
+            <summary>\r
+            The expected value\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.StringConstraint.caseInsensitive">\r
+            <summary>\r
+            Indicates whether tests should be case-insensitive\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.StringConstraint.#ctor(System.String)">\r
+            <summary>\r
+            Constructs a StringConstraint given an expected value\r
+            </summary>\r
+            <param name="expected">The expected value</param>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.StringConstraint.IgnoreCase">\r
+            <summary>\r
+            Modify the constraint to ignore case in matching.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.EmptyStringConstraint">\r
+            <summary>\r
+            EmptyStringConstraint tests whether a string is empty.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EmptyStringConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EmptyStringConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.NullOrEmptyStringConstraint">\r
+            <summary>\r
+            NullEmptyStringConstraint tests whether a string is either null or empty.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NullOrEmptyStringConstraint.#ctor">\r
+            <summary>\r
+            Constructs a new NullOrEmptyStringConstraint\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NullOrEmptyStringConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.NullOrEmptyStringConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.SubstringConstraint">\r
+            <summary>\r
+            SubstringConstraint can test whether a string contains\r
+            the expected substring.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.SubstringConstraint.#ctor(System.String)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:SubstringConstraint"/> class.\r
+            </summary>\r
+            <param name="expected">The expected.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.SubstringConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.SubstringConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.StartsWithConstraint">\r
+            <summary>\r
+            StartsWithConstraint can test whether a string starts\r
+            with an expected substring.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.StartsWithConstraint.#ctor(System.String)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:StartsWithConstraint"/> class.\r
+            </summary>\r
+            <param name="expected">The expected string</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.StartsWithConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is matched by the actual value.\r
+            This is a template method, which calls the IsMatch method\r
+            of the derived class.\r
+            </summary>\r
+            <param name="actual"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.StartsWithConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.EndsWithConstraint">\r
+            <summary>\r
+            EndsWithConstraint can test whether a string ends\r
+            with an expected substring.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EndsWithConstraint.#ctor(System.String)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:EndsWithConstraint"/> class.\r
+            </summary>\r
+            <param name="expected">The expected string</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EndsWithConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is matched by the actual value.\r
+            This is a template method, which calls the IsMatch method\r
+            of the derived class.\r
+            </summary>\r
+            <param name="actual"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.EndsWithConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.RegexConstraint">\r
+            <summary>\r
+            RegexConstraint can test whether a string matches\r
+            the pattern provided.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.RegexConstraint.#ctor(System.String)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:RegexConstraint"/> class.\r
+            </summary>\r
+            <param name="pattern">The pattern.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.RegexConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True for success, false for failure</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.RegexConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.ThrowsConstraint">\r
+            <summary>\r
+            ThrowsConstraint is used to test the exception thrown by \r
+            a delegate by applying a constraint to it.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:ThrowsConstraint"/> class,\r
+            using a constraint to be applied to the exception.\r
+            </summary>\r
+            <param name="baseConstraint">A constraint to apply to the caught exception.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Executes the code of the delegate and captures any exception.\r
+            If a non-null base constraint was provided, it applies that\r
+            constraint to the exception.\r
+            </summary>\r
+            <param name="actual">A delegate representing the code to be tested</param>\r
+            <returns>True if an exception is thrown and the constraint succeeds, otherwise false</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.Matches(NUnit.Framework.Constraints.ActualValueDelegate)">\r
+            <summary>\r
+            Converts an ActualValueDelegate to a TestDelegate\r
+            before calling the primary overload.\r
+            </summary>\r
+            <param name="del"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the actual value for a failing constraint test to a\r
+            MessageWriter. The default implementation simply writes\r
+            the raw value of actual, leaving it to the writer to\r
+            perform any formatting.\r
+            </summary>\r
+            <param name="writer">The writer on which the actual value is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.GetStringRepresentation">\r
+            <summary>\r
+            Returns the string representation of this constraint\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.ThrowsConstraint.ActualException">\r
+            <summary>\r
+            Get the actual exception thrown - used by Assert.Throws.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.ThrowsNothingConstraint">\r
+            <summary>\r
+            ThrowsNothingConstraint tests that a delegate does not\r
+            throw an exception.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether the constraint is satisfied by a given value\r
+            </summary>\r
+            <param name="actual">The value to be tested</param>\r
+            <returns>True if no exception is thrown, otherwise false</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.Matches(NUnit.Framework.Constraints.ActualValueDelegate)">\r
+            <summary>\r
+            Converts an ActualValueDelegate to a TestDelegate\r
+            before calling the primary overload.\r
+            </summary>\r
+            <param name="del"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the constraint description to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The writer on which the description is displayed</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the actual value for a failing constraint test to a\r
+            MessageWriter. The default implementation simply writes\r
+            the raw value of actual, leaving it to the writer to\r
+            perform any formatting.\r
+            </summary>\r
+            <param name="writer">The writer on which the actual value is displayed</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.ToleranceMode">\r
+            <summary>\r
+            Modes in which the tolerance value for a comparison can\r
+            be interpreted.\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.ToleranceMode.None">\r
+            <summary>\r
+            The tolerance was created with a value, without specifying \r
+            how the value would be used. This is used to prevent setting\r
+            the mode more than once and is generally changed to Linear\r
+            upon execution of the test.\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.ToleranceMode.Linear">\r
+            <summary>\r
+            The tolerance is used as a numeric range within which\r
+            two compared values are considered to be equal.\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.ToleranceMode.Percent">\r
+            <summary>\r
+            Interprets the tolerance as the percentage by which\r
+            the two compared values my deviate from each other.\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.ToleranceMode.Ulps">\r
+            <summary>\r
+            Compares two values based in their distance in\r
+            representable numbers.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.Tolerance">\r
+            <summary>\r
+            The Tolerance class generalizes the notion of a tolerance\r
+            within which an equality test succeeds. Normally, it is\r
+            used with numeric types, but it can be used with any\r
+            type that supports taking a difference between two \r
+            objects and comparing that difference to a value.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Tolerance.#ctor(System.Object)">\r
+            <summary>\r
+            Constructs a linear tolerance of a specdified amount\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Tolerance.#ctor(System.Object,NUnit.Framework.Constraints.ToleranceMode)">\r
+            <summary>\r
+            Constructs a tolerance given an amount and ToleranceMode\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.Tolerance.CheckLinearAndNumeric">\r
+            <summary>\r
+            Tests that the current Tolerance is linear with a \r
+            numeric value, throwing an exception if it is not.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Empty">\r
+            <summary>\r
+            Returns an empty Tolerance object, equivalent to \r
+            specifying an exact match.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Mode">\r
+            <summary>\r
+            Gets the ToleranceMode for the current Tolerance\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Value">\r
+            <summary>\r
+            Gets the value of the current Tolerance instance.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Percent">\r
+            <summary>\r
+            Returns a new tolerance, using the current amount as a percentage.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Ulps">\r
+            <summary>\r
+            Returns a new tolerance, using the current amount in Ulps.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Days">\r
+            <summary>\r
+            Returns a new tolerance with a TimeSpan as the amount, using \r
+            the current amount as a number of days.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Hours">\r
+            <summary>\r
+            Returns a new tolerance with a TimeSpan as the amount, using \r
+            the current amount as a number of hours.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Minutes">\r
+            <summary>\r
+            Returns a new tolerance with a TimeSpan as the amount, using \r
+            the current amount as a number of minutes.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Seconds">\r
+            <summary>\r
+            Returns a new tolerance with a TimeSpan as the amount, using \r
+            the current amount as a number of seconds.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Milliseconds">\r
+            <summary>\r
+            Returns a new tolerance with a TimeSpan as the amount, using \r
+            the current amount as a number of milliseconds.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Ticks">\r
+            <summary>\r
+            Returns a new tolerance with a TimeSpan as the amount, using \r
+            the current amount as a number of clock ticks.\r
+            </summary>\r
+        </member>\r
+        <member name="P:NUnit.Framework.Constraints.Tolerance.IsEmpty">\r
+            <summary>\r
+            Returns true if the current tolerance is empty.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.TypeConstraint">\r
+            <summary>\r
+            TypeConstraint is the abstract base for constraints\r
+            that take a Type as their expected value.\r
+            </summary>\r
+        </member>\r
+        <member name="F:NUnit.Framework.Constraints.TypeConstraint.expectedType">\r
+            <summary>\r
+            The expected Type used by the constraint\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.TypeConstraint.#ctor(System.Type)">\r
+            <summary>\r
+            Construct a TypeConstraint for a given Type\r
+            </summary>\r
+            <param name="type"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.TypeConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the actual value for a failing constraint test to a\r
+            MessageWriter. TypeConstraints override this method to write\r
+            the name of the type.\r
+            </summary>\r
+            <param name="writer">The writer on which the actual value is displayed</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.ExactTypeConstraint">\r
+            <summary>\r
+            ExactTypeConstraint is used to test that an object\r
+            is of the exact type provided in the constructor\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ExactTypeConstraint.#ctor(System.Type)">\r
+            <summary>\r
+            Construct an ExactTypeConstraint for a given Type\r
+            </summary>\r
+            <param name="type">The expected Type.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ExactTypeConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test that an object is of the exact type specified\r
+            </summary>\r
+            <param name="actual">The actual value.</param>\r
+            <returns>True if the tested object is of the exact type provided, otherwise false.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.ExactTypeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write the description of this constraint to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The MessageWriter to use</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.InstanceOfTypeConstraint">\r
+            <summary>\r
+            InstanceOfTypeConstraint is used to test that an object\r
+            is of the same type provided or derived from it.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.InstanceOfTypeConstraint.#ctor(System.Type)">\r
+            <summary>\r
+            Construct an InstanceOfTypeConstraint for the type provided\r
+            </summary>\r
+            <param name="type">The expected Type</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.InstanceOfTypeConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether an object is of the specified type or a derived type\r
+            </summary>\r
+            <param name="actual">The object to be tested</param>\r
+            <returns>True if the object is of the provided type or derives from it, otherwise false.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.InstanceOfTypeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write a description of this constraint to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The MessageWriter to use</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.AssignableFromConstraint">\r
+            <summary>\r
+            AssignableFromConstraint is used to test that an object\r
+            can be assigned from a given Type.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AssignableFromConstraint.#ctor(System.Type)">\r
+            <summary>\r
+            Construct an AssignableFromConstraint for the type provided\r
+            </summary>\r
+            <param name="type"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AssignableFromConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether an object can be assigned from the specified type\r
+            </summary>\r
+            <param name="actual">The object to be tested</param>\r
+            <returns>True if the object can be assigned a value of the expected Type, otherwise false.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AssignableFromConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write a description of this constraint to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The MessageWriter to use</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Constraints.AssignableToConstraint">\r
+            <summary>\r
+            AssignableToConstraint is used to test that an object\r
+            can be assigned to a given Type.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AssignableToConstraint.#ctor(System.Type)">\r
+            <summary>\r
+            Construct an AssignableToConstraint for the type provided\r
+            </summary>\r
+            <param name="type"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AssignableToConstraint.Matches(System.Object)">\r
+            <summary>\r
+            Test whether an object can be assigned to the specified type\r
+            </summary>\r
+            <param name="actual">The object to be tested</param>\r
+            <returns>True if the object can be assigned a value of the expected Type, otherwise false.</returns>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Constraints.AssignableToConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">\r
+            <summary>\r
+            Write a description of this constraint to a MessageWriter\r
+            </summary>\r
+            <param name="writer">The MessageWriter to use</param>\r
+        </member>\r
+        <member name="T:NUnit.Framework.AssertionException">\r
+            <summary>\r
+            Thrown when an assertion failed.\r
+            </summary>\r
+            \r
+        </member>\r
+        <member name="M:NUnit.Framework.AssertionException.#ctor(System.String)">\r
+            <param name="message">The error message that explains \r
+            the reason for the exception</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.AssertionException.#ctor(System.String,System.Exception)">\r
+            <param name="message">The error message that explains \r
+            the reason for the exception</param>\r
+            <param name="inner">The exception that caused the \r
+            current exception</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.AssertionException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">\r
+            <summary>\r
+            Serialization Constructor\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.IgnoreException">\r
+            <summary>\r
+            Thrown when an assertion failed.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.IgnoreException.#ctor(System.String)">\r
+            <param name="message"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.IgnoreException.#ctor(System.String,System.Exception)">\r
+            <param name="message">The error message that explains \r
+            the reason for the exception</param>\r
+            <param name="inner">The exception that caused the \r
+            current exception</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.IgnoreException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">\r
+            <summary>\r
+            Serialization Constructor\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.InconclusiveException">\r
+            <summary>\r
+            Thrown when a test executes inconclusively.\r
+            </summary>\r
+            \r
+        </member>\r
+        <member name="M:NUnit.Framework.InconclusiveException.#ctor(System.String)">\r
+            <param name="message">The error message that explains \r
+            the reason for the exception</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.InconclusiveException.#ctor(System.String,System.Exception)">\r
+            <param name="message">The error message that explains \r
+            the reason for the exception</param>\r
+            <param name="inner">The exception that caused the \r
+            current exception</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.InconclusiveException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">\r
+            <summary>\r
+            Serialization Constructor\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.SuccessException">\r
+            <summary>\r
+            Thrown when an assertion failed.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.SuccessException.#ctor(System.String)">\r
+            <param name="message"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.SuccessException.#ctor(System.String,System.Exception)">\r
+            <param name="message">The error message that explains \r
+            the reason for the exception</param>\r
+            <param name="inner">The exception that caused the \r
+            current exception</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.SuccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">\r
+            <summary>\r
+            Serialization Constructor\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.TestDelegate">\r
+            <summary>\r
+            Delegate used by tests that execute code and\r
+            capture any thrown exception.\r
+            </summary>\r
+        </member>\r
+        <member name="T:NUnit.Framework.Assert">\r
+            <summary>\r
+            The Assert class contains a collection of static methods that\r
+            implement the most common assertions used in NUnit.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.#ctor">\r
+            <summary>\r
+            We don't actually want any instances of this object, but some people\r
+            like to inherit from it to add other static methods. Hence, the\r
+            protected constructor disallows any instances of this object. \r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Equals(System.Object,System.Object)">\r
+            <summary>\r
+            The Equals method throws an AssertionException. This is done \r
+            to make sure there is no mistake by calling this function.\r
+            </summary>\r
+            <param name="a"></param>\r
+            <param name="b"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.ReferenceEquals(System.Object,System.Object)">\r
+            <summary>\r
+            override the default ReferenceEquals to throw an AssertionException. This \r
+            implementation makes sure there is no mistake in calling this function \r
+            as part of Assert. \r
+            </summary>\r
+            <param name="a"></param>\r
+            <param name="b"></param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.AssertDoublesAreEqual(System.Double,System.Double,System.Double,System.String,System.Object[])">\r
+            <summary>\r
+            Helper for Assert.AreEqual(double expected, double actual, ...)\r
+            allowing code generation to work consistently.\r
+            </summary>\r
+            <param name="expected">The expected value</param>\r
+            <param name="actual">The actual value</param>\r
+            <param name="delta">The maximum acceptable difference between the\r
+            the expected and the actual</param>\r
+            <param name="message">The message to display in case of failure</param>\r
+            <param name="args">Array of objects to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Pass(System.String,System.Object[])">\r
+            <summary>\r
+            Throws a <see cref="T:NUnit.Framework.SuccessException"/> with the message and arguments \r
+            that are passed in. This allows a test to be cut short, with a result\r
+            of success returned to NUnit.\r
+            </summary>\r
+            <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>\r
+            <param name="args">Arguments to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Pass(System.String)">\r
+            <summary>\r
+            Throws a <see cref="T:NUnit.Framework.SuccessException"/> with the message and arguments \r
+            that are passed in. This allows a test to be cut short, with a result\r
+            of success returned to NUnit.\r
+            </summary>\r
+            <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Pass">\r
+            <summary>\r
+            Throws a <see cref="T:NUnit.Framework.SuccessException"/> with the message and arguments \r
+            that are passed in. This allows a test to be cut short, with a result\r
+            of success returned to NUnit.\r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Fail(System.String,System.Object[])">\r
+            <summary>\r
+            Throws an <see cref="T:NUnit.Framework.AssertionException"/> with the message and arguments \r
+            that are passed in. This is used by the other Assert functions. \r
+            </summary>\r
+            <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>\r
+            <param name="args">Arguments to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Fail(System.String)">\r
+            <summary>\r
+            Throws an <see cref="T:NUnit.Framework.AssertionException"/> with the message that is \r
+            passed in. This is used by the other Assert functions. \r
+            </summary>\r
+            <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Fail">\r
+            <summary>\r
+            Throws an <see cref="T:NUnit.Framework.AssertionException"/>. \r
+            This is used by the other Assert functions. \r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Ignore(System.String,System.Object[])">\r
+            <summary>\r
+            Throws an <see cref="T:NUnit.Framework.IgnoreException"/> with the message and arguments \r
+            that are passed in.  This causes the test to be reported as ignored.\r
+            </summary>\r
+            <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>\r
+            <param name="args">Arguments to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Ignore(System.String)">\r
+            <summary>\r
+            Throws an <see cref="T:NUnit.Framework.IgnoreException"/> with the message that is \r
+            passed in. This causes the test to be reported as ignored. \r
+            </summary>\r
+            <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Ignore">\r
+            <summary>\r
+            Throws an <see cref="T:NUnit.Framework.IgnoreException"/>. \r
+            This causes the test to be reported as ignored. \r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Inconclusive(System.String,System.Object[])">\r
+            <summary>\r
+            Throws an <see cref="T:NUnit.Framework.InconclusiveException"/> with the message and arguments \r
+            that are passed in.  This causes the test to be reported as inconclusive.\r
+            </summary>\r
+            <param name="message">The message to initialize the <see cref="T:NUnit.Framework.InconclusiveException"/> with.</param>\r
+            <param name="args">Arguments to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Inconclusive(System.String)">\r
+            <summary>\r
+            Throws an <see cref="T:NUnit.Framework.InconclusiveException"/> with the message that is \r
+            passed in. This causes the test to be reported as inconclusive. \r
+            </summary>\r
+            <param name="message">The message to initialize the <see cref="T:NUnit.Framework.InconclusiveException"/> with.</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Inconclusive">\r
+            <summary>\r
+            Throws an <see cref="T:NUnit.Framework.InconclusiveException"/>. \r
+            This causes the test to be reported as Inconclusive. \r
+            </summary>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint)">\r
+            <summary>\r
+            Apply a constraint to an actual value, succeeding if the constraint\r
+            is satisfied and throwing an assertion exception on failure.\r
+            </summary>\r
+            <param name="expression">A Constraint to be applied</param>\r
+            <param name="actual">The actual value to test</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String)">\r
+            <summary>\r
+            Apply a constraint to an actual value, succeeding if the constraint\r
+            is satisfied and throwing an assertion exception on failure.\r
+            </summary>\r
+            <param name="expression">A Constraint to be applied</param>\r
+            <param name="actual">The actual value to test</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">\r
+            <summary>\r
+            Apply a constraint to an actual value, succeeding if the constraint\r
+            is satisfied and throwing an assertion exception on failure.\r
+            </summary>\r
+            <param name="expression">A Constraint expression to be applied</param>\r
+            <param name="actual">The actual value to test</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+            <param name="args">Arguments to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint)">\r
+            <summary>\r
+            Apply a constraint to an actual value, succeeding if the constraint\r
+            is satisfied and throwing an assertion exception on failure.\r
+            </summary>\r
+            <param name="expr">A Constraint expression to be applied</param>\r
+            <param name="del">An ActualValueDelegate returning the value to be tested</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String)">\r
+            <summary>\r
+            Apply a constraint to an actual value, succeeding if the constraint\r
+            is satisfied and throwing an assertion exception on failure.\r
+            </summary>\r
+            <param name="expr">A Constraint expression to be applied</param>\r
+            <param name="del">An ActualValueDelegate returning the value to be tested</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">\r
+            <summary>\r
+            Apply a constraint to an actual value, succeeding if the constraint\r
+            is satisfied and throwing an assertion exception on failure.\r
+            </summary>\r
+            <param name="del">An ActualValueDelegate returning the value to be tested</param>\r
+            <param name="expr">A Constraint expression to be applied</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+            <param name="args">Arguments to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint)">\r
+            <summary>\r
+            Apply a constraint to a referenced value, succeeding if the constraint\r
+            is satisfied and throwing an assertion exception on failure.\r
+            </summary>\r
+            <param name="expression">A Constraint to be applied</param>\r
+            <param name="actual">The actual value to test</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String)">\r
+            <summary>\r
+            Apply a constraint to a referenced value, succeeding if the constraint\r
+            is satisfied and throwing an assertion exception on failure.\r
+            </summary>\r
+            <param name="expression">A Constraint to be applied</param>\r
+            <param name="actual">The actual value to test</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">\r
+            <summary>\r
+            Apply a constraint to a referenced value, succeeding if the constraint\r
+            is satisfied and throwing an assertion exception on failure.\r
+            </summary>\r
+            <param name="expression">A Constraint to be applied</param>\r
+            <param name="actual">The actual value to test</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+            <param name="args">Arguments to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.That(System.Boolean,System.String,System.Object[])">\r
+            <summary>\r
+            Asserts that a condition is true. If the condition is false the method throws\r
+            an <see cref="T:NUnit.Framework.AssertionException"/>.\r
+            </summary> \r
+            <param name="condition">The evaluated condition</param>\r
+            <param name="message">The message to display if the condition is false</param>\r
+            <param name="args">Arguments to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.That(System.Boolean,System.String)">\r
+            <summary>\r
+            Asserts that a condition is true. If the condition is false the method throws\r
+            an <see cref="T:NUnit.Framework.AssertionException"/>.\r
+            </summary>\r
+            <param name="condition">The evaluated condition</param>\r
+            <param name="message">The message to display if the condition is false</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.That(System.Boolean)">\r
+            <summary>\r
+            Asserts that a condition is true. If the condition is false the method throws\r
+            an <see cref="T:NUnit.Framework.AssertionException"/>.\r
+            </summary>\r
+            <param name="condition">The evaluated condition</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.That(NUnit.Framework.TestDelegate,NUnit.Framework.Constraints.IResolveConstraint)">\r
+            <summary>\r
+            Asserts that the code represented by a delegate throws an exception\r
+            that satisfies the constraint provided.\r
+            </summary>\r
+            <param name="code">A TestDelegate to be executed</param>\r
+            <param name="constraint">A ThrowsConstraint used in the test</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Throws(NUnit.Framework.Constraints.IResolveConstraint,NUnit.Framework.TestDelegate,System.String,System.Object[])">\r
+            <summary>\r
+            Verifies that a delegate throws a particular exception when called.\r
+            </summary>\r
+            <param name="expression">A constraint to be satisfied by the exception</param>\r
+            <param name="code">A TestSnippet delegate</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+            <param name="args">Arguments to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Throws(NUnit.Framework.Constraints.IResolveConstraint,NUnit.Framework.TestDelegate,System.String)">\r
+            <summary>\r
+            Verifies that a delegate throws a particular exception when called.\r
+            </summary>\r
+            <param name="expression">A constraint to be satisfied by the exception</param>\r
+            <param name="code">A TestSnippet delegate</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Throws(NUnit.Framework.Constraints.IResolveConstraint,NUnit.Framework.TestDelegate)">\r
+            <summary>\r
+            Verifies that a delegate throws a particular exception when called.\r
+            </summary>\r
+            <param name="expression">A constraint to be satisfied by the exception</param>\r
+            <param name="code">A TestSnippet delegate</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Throws(System.Type,NUnit.Framework.TestDelegate,System.String,System.Object[])">\r
+            <summary>\r
+            Verifies that a delegate throws a particular exception when called.\r
+            </summary>\r
+            <param name="expectedExceptionType">The exception Type expected</param>\r
+            <param name="code">A TestSnippet delegate</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+            <param name="args">Arguments to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Throws(System.Type,NUnit.Framework.TestDelegate,System.String)">\r
+            <summary>\r
+            Verifies that a delegate throws a particular exception when called.\r
+            </summary>\r
+            <param name="expectedExceptionType">The exception Type expected</param>\r
+            <param name="code">A TestSnippet delegate</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Throws(System.Type,NUnit.Framework.TestDelegate)">\r
+            <summary>\r
+            Verifies that a delegate throws a particular exception when called.\r
+            </summary>\r
+            <param name="expectedExceptionType">The exception Type expected</param>\r
+            <param name="code">A TestSnippet delegate</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Throws``1(NUnit.Framework.TestDelegate,System.String,System.Object[])">\r
+            <summary>\r
+            Verifies that a delegate throws a particular exception when called.\r
+            </summary>\r
+            <typeparam name="T">Type of the expected exception</typeparam>\r
+            <param name="code">A TestSnippet delegate</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+            <param name="args">Arguments to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Throws``1(NUnit.Framework.TestDelegate,System.String)">\r
+            <summary>\r
+            Verifies that a delegate throws a particular exception when called.\r
+            </summary>\r
+            <typeparam name="T">Type of the expected exception</typeparam>\r
+            <param name="code">A TestSnippet delegate</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Throws``1(NUnit.Framework.TestDelegate)">\r
+            <summary>\r
+            Verifies that a delegate throws a particular exception when called.\r
+            </summary>\r
+            <typeparam name="T">Type of the expected exception</typeparam>\r
+            <param name="code">A TestSnippet delegate</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Catch(NUnit.Framework.TestDelegate,System.String,System.Object[])">\r
+            <summary>\r
+            Verifies that a delegate throws an exception when called\r
+            and returns it.\r
+            </summary>\r
+            <param name="code">A TestDelegate</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+            <param name="args">Arguments to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Catch(NUnit.Framework.TestDelegate,System.String)">\r
+            <summary>\r
+            Verifies that a delegate throws an exception when called\r
+            and returns it.\r
+            </summary>\r
+            <param name="code">A TestDelegate</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Catch(NUnit.Framework.TestDelegate)">\r
+            <summary>\r
+            Verifies that a delegate throws an exception when called\r
+            and returns it.\r
+            </summary>\r
+            <param name="code">A TestDelegate</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Catch(System.Type,NUnit.Framework.TestDelegate,System.String,System.Object[])">\r
+            <summary>\r
+            Verifies that a delegate throws an exception of a certain Type\r
+            or one derived from it when called and returns it.\r
+            </summary>\r
+            <param name="expectedExceptionType">The expected Exception Type</param>\r
+            <param name="code">A TestDelegate</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+            <param name="args">Arguments to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Catch(System.Type,NUnit.Framework.TestDelegate,System.String)">\r
+            <summary>\r
+            Verifies that a delegate throws an exception of a certain Type\r
+            or one derived from it when called and returns it.\r
+            </summary>\r
+            <param name="expectedExceptionType">The expected Exception Type</param>\r
+            <param name="code">A TestDelegate</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Catch(System.Type,NUnit.Framework.TestDelegate)">\r
+            <summary>\r
+            Verifies that a delegate throws an exception of a certain Type\r
+            or one derived from it when called and returns it.\r
+            </summary>\r
+            <param name="expectedExceptionType">The expected Exception Type</param>\r
+            <param name="code">A TestDelegate</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Catch``1(NUnit.Framework.TestDelegate,System.String,System.Object[])">\r
+            <summary>\r
+            Verifies that a delegate throws an exception of a certain Type\r
+            or one derived from it when called and returns it.\r
+            </summary>\r
+            <typeparam name="T">The expected Exception Type</typeparam>\r
+            <param name="code">A TestDelegate</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+            <param name="args">Arguments to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Catch``1(NUnit.Framework.TestDelegate,System.String)">\r
+            <summary>\r
+            Verifies that a delegate throws an exception of a certain Type\r
+            or one derived from it when called and returns it.\r
+            </summary>\r
+            <typeparam name="T">The expected Exception Type</typeparam>\r
+            <param name="code">A TestDelegate</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.Catch``1(NUnit.Framework.TestDelegate)">\r
+            <summary>\r
+            Verifies that a delegate throws an exception of a certain Type\r
+            or one derived from it when called and returns it.\r
+            </summary>\r
+            <typeparam name="T">The expected Exception Type</typeparam>\r
+            <param name="code">A TestDelegate</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.DoesNotThrow(NUnit.Framework.TestDelegate,System.String,System.Object[])">\r
+            <summary>\r
+            Verifies that a delegate does not throw an exception\r
+            </summary>\r
+            <param name="code">A TestSnippet delegate</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+            <param name="args">Arguments to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.DoesNotThrow(NUnit.Framework.TestDelegate,System.String)">\r
+            <summary>\r
+            Verifies that a delegate does not throw an exception.\r
+            </summary>\r
+            <param name="code">A TestSnippet delegate</param>\r
+            <param name="message">The message that will be displayed on failure</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.DoesNotThrow(NUnit.Framework.TestDelegate)">\r
+            <summary>\r
+            Verifies that a delegate does not throw an exception.\r
+            </summary>\r
+            <param name="code">A TestSnippet delegate</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.True(System.Boolean,System.String,System.Object[])">\r
+            <summary>\r
+            Asserts that a condition is true. If the condition is false the method throws\r
+            an <see cref="T:NUnit.Framework.AssertionException"/>.\r
+            </summary>\r
+            <param name="condition">The evaluated condition</param>\r
+            <param name="message">The message to display in case of failure</param>\r
+            <param name="args">Array of objects to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.True(System.Boolean,System.String)">\r
+            <summary>\r
+            Asserts that a condition is true. If the condition is false the method throws\r
+            an <see cref="T:NUnit.Framework.AssertionException"/>.\r
+            </summary>\r
+            <param name="condition">The evaluated condition</param>\r
+            <param name="message">The message to display in case of failure</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.True(System.Boolean)">\r
+            <summary>\r
+            Asserts that a condition is true. If the condition is false the method throws\r
+            an <see cref="T:NUnit.Framework.AssertionException"/>.\r
+            </summary>\r
+            <param name="condition">The evaluated condition</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.IsTrue(System.Boolean,System.String,System.Object[])">\r
+            <summary>\r
+            Asserts that a condition is true. If the condition is false the method throws\r
+            an <see cref="T:NUnit.Framework.AssertionException"/>.\r
+            </summary>\r
+            <param name="condition">The evaluated condition</param>\r
+            <param name="message">The message to display in case of failure</param>\r
+            <param name="args">Array of objects to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.IsTrue(System.Boolean,System.String)">\r
+            <summary>\r
+            Asserts that a condition is true. If the condition is false the method throws\r
+            an <see cref="T:NUnit.Framework.AssertionException"/>.\r
+            </summary>\r
+            <param name="condition">The evaluated condition</param>\r
+            <param name="message">The message to display in case of failure</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.IsTrue(System.Boolean)">\r
+            <summary>\r
+            Asserts that a condition is true. If the condition is false the method throws\r
+            an <see cref="T:NUnit.Framework.AssertionException"/>.\r
+            </summary>\r
+            <param name="condition">The evaluated condition</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.False(System.Boolean,System.String,System.Object[])">\r
+            <summary>\r
+            Asserts that a condition is false. If the condition is true the method throws\r
+            an <see cref="T:NUnit.Framework.AssertionException"/>.\r
+            </summary> \r
+            <param name="condition">The evaluated condition</param>\r
+            <param name="message">The message to display in case of failure</param>\r
+            <param name="args">Array of objects to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.False(System.Boolean,System.String)">\r
+            <summary>\r
+            Asserts that a condition is false. If the condition is true the method throws\r
+            an <see cref="T:NUnit.Framework.AssertionException"/>.\r
+            </summary> \r
+            <param name="condition">The evaluated condition</param>\r
+            <param name="message">The message to display in case of failure</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.False(System.Boolean)">\r
+            <summary>\r
+            Asserts that a condition is false. If the condition is true the method throws\r
+            an <see cref="T:NUnit.Framework.AssertionException"/>.\r
+            </summary> \r
+            <param name="condition">The evaluated condition</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.IsFalse(System.Boolean,System.String,System.Object[])">\r
+            <summary>\r
+            Asserts that a condition is false. If the condition is true the method throws\r
+            an <see cref="T:NUnit.Framework.AssertionException"/>.\r
+            </summary> \r
+            <param name="condition">The evaluated condition</param>\r
+            <param name="message">The message to display in case of failure</param>\r
+            <param name="args">Array of objects to be used in formatting the message</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.IsFalse(System.Boolean,System.String)">\r
+            <summary>\r
+            Asserts that a condition is false. If the condition is true the method throws\r
+            an <see cref="T:NUnit.Framework.AssertionException"/>.\r
+            </summary> \r
+            <param name="condition">The evaluated condition</param>\r
+            <param name="message">The message to display in case of failure</param>\r
+        </member>\r
+        <member name="M:NUnit.Framework.Assert.IsFalse(System.Boolean)">\r
+            <summary>\r
+            Asserts that a condition is false. If the condition is true the method throws\r
+            an <see cref="T:NUnit.Framework.AssertionException"/>.