Added NUnit as a NuGet package

diff --git a/trunk/Libraries/Json40r2/Source/Src/Newtonsoft.Json/Newtonsoft.Json.csproj b/trunk/Libraries/Json40r2/Source/Src/Newtonsoft.Json/Newtonsoft.Json.csproj
index a69324b..bff73a7 100644 (file)
--- a/trunk/Libraries/Json40r2/Source/Src/Newtonsoft.Json/Newtonsoft.Json.csproj
+++ b/trunk/Libraries/Json40r2/Source/Src/Newtonsoft.Json/Newtonsoft.Json.csproj
@@ -43,6 +43,7 @@
     <UseApplicationTrust>false</UseApplicationTrust>
     <BootstrapperEnabled>true</BootstrapperEnabled>
     <TargetFrameworkProfile>Client</TargetFrameworkProfile>
+    <CodeContractsAssemblyMode>0</CodeContractsAssemblyMode>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -57,6 +58,31 @@
     <CodeAnalysisRules>
     </CodeAnalysisRules>
     <CodeAnalysisRuleSet>Newtonsoft.Json.ruleset</CodeAnalysisRuleSet>
+    <CodeContractsEnableRuntimeChecking>False</CodeContractsEnableRuntimeChecking>
+    <CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface>
+    <CodeContractsRuntimeThrowOnFailure>True</CodeContractsRuntimeThrowOnFailure>
+    <CodeContractsRuntimeCallSiteRequires>False</CodeContractsRuntimeCallSiteRequires>
+    <CodeContractsRuntimeSkipQuantifiers>False</CodeContractsRuntimeSkipQuantifiers>
+    <CodeContractsRunCodeAnalysis>False</CodeContractsRunCodeAnalysis>
+    <CodeContractsNonNullObligations>False</CodeContractsNonNullObligations>
+    <CodeContractsBoundsObligations>False</CodeContractsBoundsObligations>
+    <CodeContractsArithmeticObligations>False</CodeContractsArithmeticObligations>
+    <CodeContractsEnumObligations>False</CodeContractsEnumObligations>
+    <CodeContractsRedundantAssumptions>False</CodeContractsRedundantAssumptions>
+    <CodeContractsRunInBackground>True</CodeContractsRunInBackground>
+    <CodeContractsShowSquigglies>False</CodeContractsShowSquigglies>
+    <CodeContractsUseBaseLine>False</CodeContractsUseBaseLine>
+    <CodeContractsEmitXMLDocs>False</CodeContractsEmitXMLDocs>
+    <CodeContractsCustomRewriterAssembly />
+    <CodeContractsCustomRewriterClass />
+    <CodeContractsLibPaths />
+    <CodeContractsExtraRewriteOptions />
+    <CodeContractsExtraAnalysisOptions />
+    <CodeContractsBaseLineFile />
+    <CodeContractsCacheAnalysisResults>False</CodeContractsCacheAnalysisResults>
+    <CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel>
+    <CodeContractsReferenceAssembly>Build</CodeContractsReferenceAssembly>
+    <CodeContractsAnalysisWarningLevel>0</CodeContractsAnalysisWarningLevel>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>

diff --git a/trunk/Pithos.Client.Test/Pithos.Client.Test.csproj b/trunk/Pithos.Client.Test/Pithos.Client.Test.csproj
index 0b64b84..8ab8e13 100644 (file)
--- a/trunk/Pithos.Client.Test/Pithos.Client.Test.csproj
+++ b/trunk/Pithos.Client.Test/Pithos.Client.Test.csproj
@@ -31,7 +31,15 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="nunit.framework, Version=2.5.10.11092, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL" />
+    <Reference Include="nunit.framework">
+      <HintPath>..\packages\NUnit.2.5.10.11092\lib\nunit.framework.dll</HintPath>
+    </Reference>
+    <Reference Include="nunit.mocks">
+      <HintPath>..\packages\NUnit.2.5.10.11092\lib\nunit.mocks.dll</HintPath>
+    </Reference>
+    <Reference Include="pnunit.framework">
+      <HintPath>..\packages\NUnit.2.5.10.11092\lib\pnunit.framework.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Xml.Linq" />
@@ -53,6 +61,9 @@
       <Name>Pithos.Interfaces</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.

diff --git a/trunk/Pithos.Client.Test/packages.config b/trunk/Pithos.Client.Test/packages.config
new file mode 100644 (file)
index 0000000..0c82178
--- /dev/null
+++ b/trunk/Pithos.Client.Test/packages.config
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="NUnit" version="2.5.10.11092" />
+</packages>
\ No newline at end of file

diff --git a/trunk/Pithos.Client/Pithos.Client.csproj b/trunk/Pithos.Client/Pithos.Client.csproj
index 20af9f8..7b55aa2 100644 (file)
--- a/trunk/Pithos.Client/Pithos.Client.csproj
+++ b/trunk/Pithos.Client/Pithos.Client.csproj
@@ -138,7 +138,7 @@
     <None Include="Resources\TrayInSynch.ico" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\..\..\..\ParallelProgrammingSamples\ParallelExtensionsExtras\ParallelExtensionsExtras.csproj">
+    <ProjectReference Include="..\Libraries\ParallelExtensionsExtras\ParallelExtensionsExtras.csproj">
       <Project>{C45218F8-09E7-4F57-85BC-5D8D2AC736A3}</Project>
       <Name>ParallelExtensionsExtras</Name>
     </ProjectReference>
@@ -157,9 +157,6 @@
   </ItemGroup>
   <ItemGroup>
     <Content Include="App_Code\LICENSE.txt" />
-    <Content Include="Filemeta.sdf">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </Content>
   </ItemGroup>
   <ItemGroup>
     <BootstrapperPackage Include=".NETFramework,Version=v4.0,Profile=Client">

diff --git a/trunk/Pithos.Core.Test/Pithos.Core.Test.csproj b/trunk/Pithos.Core.Test/Pithos.Core.Test.csproj
index 7c63eac..7c42d44 100644 (file)
--- a/trunk/Pithos.Core.Test/Pithos.Core.Test.csproj
+++ b/trunk/Pithos.Core.Test/Pithos.Core.Test.csproj
@@ -57,7 +57,15 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="nunit.framework, Version=2.5.10.11092, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL" />
+    <Reference Include="nunit.framework, Version=2.5.10.11092, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <HintPath>..\packages\NUnit.2.5.10.11092\lib\nunit.framework.dll</HintPath>
+    </Reference>
+    <Reference Include="nunit.mocks">
+      <HintPath>..\packages\NUnit.2.5.10.11092\lib\nunit.mocks.dll</HintPath>
+    </Reference>
+    <Reference Include="pnunit.framework">
+      <HintPath>..\packages\NUnit.2.5.10.11092\lib\pnunit.framework.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Xml.Linq" />
@@ -84,6 +92,9 @@
       <Name>Pithos.Interfaces</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.

diff --git a/trunk/Pithos.Core.Test/packages.config b/trunk/Pithos.Core.Test/packages.config
new file mode 100644 (file)
index 0000000..0c82178
--- /dev/null
+++ b/trunk/Pithos.Core.Test/packages.config
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="NUnit" version="2.5.10.11092" />
+</packages>
\ No newline at end of file

diff --git a/trunk/Pithos.Core/Pithos.Core.csproj b/trunk/Pithos.Core/Pithos.Core.csproj
index 9b436b9..62e52ed 100644 (file)
--- a/trunk/Pithos.Core/Pithos.Core.csproj
+++ b/trunk/Pithos.Core/Pithos.Core.csproj
@@ -78,7 +78,7 @@
     <Compile Include="WorkflowState.cs" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\..\..\..\ParallelProgrammingSamples\ParallelExtensionsExtras\ParallelExtensionsExtras.csproj">
+    <ProjectReference Include="..\Libraries\ParallelExtensionsExtras\ParallelExtensionsExtras.csproj">
       <Project>{C45218F8-09E7-4F57-85BC-5D8D2AC736A3}</Project>
       <Name>ParallelExtensionsExtras</Name>
     </ProjectReference>

diff --git a/trunk/Pithos.Network.Test/Pithos.Network.Test.csproj b/trunk/Pithos.Network.Test/Pithos.Network.Test.csproj
index 620960b..93bb985 100644 (file)
--- a/trunk/Pithos.Network.Test/Pithos.Network.Test.csproj
+++ b/trunk/Pithos.Network.Test/Pithos.Network.Test.csproj
@@ -31,8 +31,15 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="Microsoft.Pex.Framework, Version=0.94.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL" />
-    <Reference Include="nunit.framework, Version=2.5.10.11092, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL" />
+    <Reference Include="nunit.framework, Version=2.5.10.11092, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <HintPath>..\packages\NUnit.2.5.10.11092\lib\nunit.framework.dll</HintPath>
+    </Reference>
+    <Reference Include="nunit.mocks">
+      <HintPath>..\packages\NUnit.2.5.10.11092\lib\nunit.mocks.dll</HintPath>
+    </Reference>
+    <Reference Include="pnunit.framework">
+      <HintPath>..\packages\NUnit.2.5.10.11092\lib\pnunit.framework.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Xml.Linq" />
@@ -56,6 +63,9 @@
       <Name>Pithos.Network</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.

diff --git a/trunk/Pithos.Network.Test/Properties/AssemblyInfo.cs b/trunk/Pithos.Network.Test/Properties/AssemblyInfo.cs
index 88a1171..1ac5f19 100644 (file)
--- a/trunk/Pithos.Network.Test/Properties/AssemblyInfo.cs
+++ b/trunk/Pithos.Network.Test/Properties/AssemblyInfo.cs
@@ -1,7 +1,7 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using Microsoft.Pex.Framework.Instrumentation;
+
 using Pithos.Network;
 
 // General Information about an assembly is controlled through the following 
@@ -39,4 +39,4 @@ using Pithos.Network;
 
 
 // monitor types in Pithos.Network.dll
-[assembly: PexInstrumentAssembly(typeof(CloudFilesClient))]
+

diff --git a/trunk/Pithos.Network.Test/packages.config b/trunk/Pithos.Network.Test/packages.config
new file mode 100644 (file)
index 0000000..0c82178
--- /dev/null
+++ b/trunk/Pithos.Network.Test/packages.config
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="NUnit" version="2.5.10.11092" />
+</packages>
\ No newline at end of file

diff --git a/trunk/Pithos.ShellExtensions.Test/Pithos.ShellExtensions.Test.csproj b/trunk/Pithos.ShellExtensions.Test/Pithos.ShellExtensions.Test.csproj
index 9626a0f..403b5e9 100644 (file)
--- a/trunk/Pithos.ShellExtensions.Test/Pithos.ShellExtensions.Test.csproj
+++ b/trunk/Pithos.ShellExtensions.Test/Pithos.ShellExtensions.Test.csproj
@@ -31,7 +31,15 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="nunit.framework, Version=2.5.10.11092, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL" />
+    <Reference Include="nunit.framework, Version=2.5.10.11092, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <HintPath>..\packages\NUnit.2.5.10.11092\lib\nunit.framework.dll</HintPath>
+    </Reference>
+    <Reference Include="nunit.mocks">
+      <HintPath>..\packages\NUnit.2.5.10.11092\lib\nunit.mocks.dll</HintPath>
+    </Reference>
+    <Reference Include="pnunit.framework">
+      <HintPath>..\packages\NUnit.2.5.10.11092\lib\pnunit.framework.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.ComponentModel.Composition" />
     <Reference Include="System.Core" />
@@ -61,6 +69,9 @@
       <Name>Pithos.ShellExtensions</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.

diff --git a/trunk/Pithos.ShellExtensions.Test/packages.config b/trunk/Pithos.ShellExtensions.Test/packages.config
new file mode 100644 (file)
index 0000000..0c82178
--- /dev/null
+++ b/trunk/Pithos.ShellExtensions.Test/packages.config
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="NUnit" version="2.5.10.11092" />
+</packages>
\ No newline at end of file

diff --git a/trunk/packages/NUnit.2.5.10.11092/Logo.ico b/trunk/packages/NUnit.2.5.10.11092/Logo.ico
new file mode 100644 (file)
index 0000000..13c4ff9
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/Logo.ico differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/NUnit.2.5.10.11092.nupkg b/trunk/packages/NUnit.2.5.10.11092/NUnit.2.5.10.11092.nupkg
new file mode 100644 (file)
index 0000000..7e9a777
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/NUnit.2.5.10.11092.nupkg differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/NUnitFitTests.html b/trunk/packages/NUnit.2.5.10.11092/NUnitFitTests.html
new file mode 100644 (file)
index 0000000..ca5cd4f
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/NUnitFitTests.html
@@ -0,0 +1,277 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<html>
+       <body>
+               <h1>NUnit Acceptance Tests</h1>
+               <p>
+               Developers love self-referential programs! Hence, NUnit has always run all it's 
+               own tests, even those that are not really unit tests.
+               <p>Now, beginning with NUnit 2.4, NUnit has top-level tests using Ward Cunningham's 
+                       FIT framework. At this time, the tests are pretty rudimentary, but it's a start 
+                       and it's a framework for doing more.
+                       <h2>Running the Tests</h2>
+               <p>Open a console or shell window and navigate to the NUnit bin directory, which 
+                       contains this file. To run the test under Microsoft .Net, enter the command
+                       <pre>    runFile NUnitFitTests.html TestResults.html .</pre>
+                       To run it under Mono, enter
+                       <pre>    mono runFile.exe NUnitFitTests.html TestResults.html .</pre>
+                       Note the space and dot at the end of each command. The results of your test 
+                       will be in TestResults.html in the same directory.
+                       <h2>Platform and CLR Version</h2>
+                       <table BORDER cellSpacing="0" cellPadding="5">
+                               <tr>
+                                       <td colspan="2">NUnit.Fixtures.PlatformInfo</td>
+                               </tr>
+                       </table>
+                       <h2>Verify Unit Tests</h2>
+               <p>
+               Load and run the NUnit unit tests, verifying that the results are as expected. 
+               When these tests are run on different platforms, different numbers of tests may 
+               be skipped, so the values for Skipped and Run tests are informational only.
+               <p>
+               The number of tests in each assembly should be constant across all platforms - 
+               any discrepancy usually means that one of the test source files was not 
+               compiled on the platform. There should be no failures and no tests ignored.
+               <p><b>Note:</b>
+               At the moment, the nunit.extensions.tests assembly is failing because the 
+               fixture doesn't initialize addins in the test domain.
+               <p>
+                       <table BORDER cellSpacing="0" cellPadding="5">
+                               <tr>
+                                       <td colspan="6">NUnit.Fixtures.AssemblyRunner</td>
+                               </tr>
+                               <tr>
+                                       <td>Assembly</td>
+                                       <td>Tests()</td>
+                                       <td>Run()</td>
+                                       <td>Skipped()</td>
+                                       <td>Ignored()</td>
+                                       <td>Failures()</td>
+                               </tr>
+                               <tr>
+                                       <td>nunit.framework.tests.dll</td>
+                                       <td>397</td>
+                                       <td>&nbsp;</td>
+                                       <td>&nbsp;</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                               </tr>
+                               <tr>
+                                       <td>nunit.core.tests.dll</td>
+                                       <td>355</td>
+                                       <td>&nbsp;</td>
+                                       <td>&nbsp;</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                               </tr>
+                               <tr>
+                                       <td>nunit.util.tests.dll</td>
+                                       <td>238</td>
+                                       <td>&nbsp;</td>
+                                       <td>&nbsp;</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                               </tr>
+                               <tr>
+                                       <td>nunit.mocks.tests.dll</td>
+                                       <td>43</td>
+                                       <td>&nbsp;</td>
+                                       <td>&nbsp;</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                               </tr>
+                               <tr>
+                                       <td>nunit.extensions.tests.dll</td>
+                                       <td>5</td>
+                                       <td>&nbsp;</td>
+                                       <td>&nbsp;</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                               </tr>
+                               <tr>
+                                       <td>nunit-console.tests.dll</td>
+                                       <td>40</td>
+                                       <td>&nbsp;</td>
+                                       <td>&nbsp;</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                               </tr>
+                               <tr>
+                                       <td>nunit.uikit.tests.dll</td>
+                                       <td>34</td>
+                                       <td>&nbsp;</td>
+                                       <td>&nbsp;</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                               </tr>
+                               <tr>
+                                       <td>nunit-gui.tests.dll</td>
+                                       <td>15</td>
+                                       <td>&nbsp;</td>
+                                       <td>&nbsp;</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                               </tr>
+                               <tr>
+                                       <td>nunit.fixtures.tests.dll</td>
+                                       <td>6</td>
+                                       <td>&nbsp;</td>
+                                       <td>&nbsp;</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                               </tr>
+                       </table>
+                       <h2>Code Snippet Tests</h2>
+               <p>
+               These tests create a test assembly from a snippet of code and then load and run 
+               the tests that it contains, verifying that the structure of the loaded tests is 
+               as expected and that the number of tests run, skipped, ignored or failed is 
+               correct.
+               <p>
+                       <table BORDER cellSpacing="0" cellPadding="5">
+                               <tr>
+                                       <td colspan="6">NUnit.Fixtures.SnippetRunner</td>
+                               </tr>
+                               <tr>
+                                       <td>Code</td>
+                                       <td>Tree()</td>
+                                       <td>Run()</td>
+                                       <td>Skipped()</td>
+                                       <td>Ignored()</td>
+                                       <td>Failures()</td>
+                               </tr>
+                               <tr>
+                                       <td><pre>public class TestClass
+{
+}</pre>
+                                       </td>
+                                       <td>EMPTY</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                               </tr>
+                               <tr>
+                                       <td><pre>using NUnit.Framework;
+
+[TestFixture]
+public class TestClass
+{
+}</pre>
+                                       </td>
+                                       <td>TestClass</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                               </tr>
+                               <tr>
+                                       <td><pre>using NUnit.Framework;
+
+[TestFixture]
+public class TestClass
+{
+    [Test]
+    public void T1() { }
+    [Test]
+    public void T2() { }
+    [Test]
+    public void T3() { }
+}</pre>
+                                       </td>
+                                       <td><pre>TestClass
+&gt;T1
+&gt;T2
+&gt;T3</pre>
+                                       </td>
+                                       <td>3</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                               </tr>
+                               <tr>
+                                       <td><pre>using NUnit.Framework;
+
+[TestFixture]
+public class TestClass1
+{
+    [Test]
+    public void T1() { }
+}
+
+[TestFixture]
+public class TestClass2
+{
+    [Test]
+    public void T2() { }
+    [Test]
+    public void T3() { }
+}</pre>
+                                       </td>
+                                       <td><pre>TestClass1
+&gt;T1
+TestClass2
+&gt;T2
+&gt;T3</pre>
+                                       </td>
+                                       <td>3</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                               </tr>
+                               <tr>
+                                       <td><pre>using NUnit.Framework;
+
+[TestFixture]
+public class TestClass
+{
+    [Test]
+    public void T1() { }
+    [Test, Ignore]
+    public void T2() { }
+    [Test]
+    public void T3() { }
+}</pre>
+                                       </td>
+                                       <td><pre>TestClass
+&gt;T1
+&gt;T2
+&gt;T3</pre>
+                                       </td>
+                                       <td>2</td>
+                                       <td>0</td>
+                                       <td>1</td>
+                                       <td>0</td>
+                               </tr>
+                               <tr>
+                                       <td><pre>using NUnit.Framework;
+
+[TestFixture]
+public class TestClass
+{
+    [Test]
+    public void T1() { }
+    [Test, Explicit]
+    public void T2() { }
+    [Test]
+    public void T3() { }
+}</pre>
+                                       </td>
+                                       <td><pre>TestClass
+&gt;T1
+&gt;T2
+&gt;T3</pre>
+                                       </td>
+                                       <td>2</td>
+                                       <td>1</td>
+                                       <td>0</td>
+                                       <td>0</td>
+                               </tr>
+                       </table>
+                       <h2>Summary Information</h2>
+                       <table BORDER cellSpacing="0" cellPadding="5">
+                               <tr>
+                                       <td colspan="2">fit.Summary</td>
+                               </tr>
+                       </table>
+       </body>
+</html>

diff --git a/trunk/packages/NUnit.2.5.10.11092/fit-license.txt b/trunk/packages/NUnit.2.5.10.11092/fit-license.txt
new file mode 100644 (file)
index 0000000..af37532
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/fit-license.txt
@@ -0,0 +1,342 @@
+\r
+\r
+                   GNU GENERAL PUBLIC LICENSE\r
+                      Version 2, June 1991\r
+\r
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.\r
+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\r
+ Everyone is permitted to copy and distribute verbatim copies\r
+ of this license document, but changing it is not allowed.\r
+\r
+                           Preamble\r
+\r
+  The licenses for most software are designed to take away your\r
+freedom to share and change it.  By contrast, the GNU General Public\r
+License is intended to guarantee your freedom to share and change free\r
+software--to make sure the software is free for all its users.  This\r
+General Public License applies to most of the Free Software\r
+Foundation's software and to any other program whose authors commit to\r
+using it.  (Some other Free Software Foundation software is covered by\r
+the GNU Library General Public License instead.)  You can apply it to\r
+your programs, too.\r
+\r
+  When we speak of free software, we are referring to freedom, not\r
+price.  Our General Public Licenses are designed to make sure that you\r
+have the freedom to distribute copies of free software (and charge for\r
+this service if you wish), that you receive source code or can get it\r
+if you want it, that you can change the software or use pieces of it\r
+in new free programs; and that you know you can do these things.\r
+\r
+  To protect your rights, we need to make restrictions that forbid\r
+anyone to deny you these rights or to ask you to surrender the rights.\r
+These restrictions translate to certain responsibilities for you if you\r
+distribute copies of the software, or if you modify it.\r
+\r
+  For example, if you distribute copies of such a program, whether\r
+gratis or for a fee, you must give the recipients all the rights that\r
+you have.  You must make sure that they, too, receive or can get the\r
+source code.  And you must show them these terms so they know their\r
+rights.\r
+\r
+  We protect your rights with two steps: (1) copyright the software, and\r
+(2) offer you this license which gives you legal permission to copy,\r
+distribute and/or modify the software.\r
+\r
+  Also, for each author's protection and ours, we want to make certain\r
+that everyone understands that there is no warranty for this free\r
+software.  If the software is modified by someone else and passed on, we\r
+want its recipients to know that what they have is not the original, so\r
+that any problems introduced by others will not reflect on the original\r
+authors' reputations.\r
+\r
+  Finally, any free program is threatened constantly by software\r
+patents.  We wish to avoid the danger that redistributors of a free\r
+program will individually obtain patent licenses, in effect making the\r
+program proprietary.  To prevent this, we have made it clear that any\r
+patent must be licensed for everyone's free use or not licensed at all.\r
+\r
+  The precise terms and conditions for copying, distribution and\r
+modification follow.\r
+\r
+                   GNU GENERAL PUBLIC LICENSE\r
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\r
+\r
+  0. This License applies to any program or other work which contains\r
+a notice placed by the copyright holder saying it may be distributed\r
+under the terms of this General Public License.  The "Program", below,\r
+refers to any such program or work, and a "work based on the Program"\r
+means either the Program or any derivative work under copyright law:\r
+that is to say, a work containing the Program or a portion of it,\r
+either verbatim or with modifications and/or translated into another\r
+language.  (Hereinafter, translation is included without limitation in\r
+the term "modification".)  Each licensee is addressed as "you".\r
+\r
+Activities other than copying, distribution and modification are not\r
+covered by this License; they are outside its scope.  The act of\r
+running the Program is not restricted, and the output from the Program\r
+is covered only if its contents constitute a work based on the\r
+Program (independent of having been made by running the Program).\r
+Whether that is true depends on what the Program does.\r
+\r
+  1. You may copy and distribute verbatim copies of the Program's\r
+source code as you receive it, in any medium, provided that you\r
+conspicuously and appropriately publish on each copy an appropriate\r
+copyright notice and disclaimer of warranty; keep intact all the\r
+notices that refer to this License and to the absence of any warranty;\r
+and give any other recipients of the Program a copy of this License\r
+along with the Program.\r
+\r
+You may charge a fee for the physical act of transferring a copy, and\r
+you may at your option offer warranty protection in exchange for a fee.\r
+\r
+  2. You may modify your copy or copies of the Program or any portion\r
+of it, thus forming a work based on the Program, and copy and\r
+distribute such modifications or work under the terms of Section 1\r
+above, provided that you also meet all of these conditions:\r
+\r
+    a) You must cause the modified files to carry prominent notices\r
+    stating that you changed the files and the date of any change.\r
+\r
+    b) You must cause any work that you distribute or publish, that in\r
+    whole or in part contains or is derived from the Program or any\r
+    part thereof, to be licensed as a whole at no charge to all third\r
+    parties under the terms of this License.\r
+\r
+    c) If the modified program normally reads commands interactively\r
+    when run, you must cause it, when started running for such\r
+    interactive use in the most ordinary way, to print or display an\r
+    announcement including an appropriate copyright notice and a\r
+    notice that there is no warranty (or else, saying that you provide\r
+    a warranty) and that users may redistribute the program under\r
+    these conditions, and telling the user how to view a copy of this\r
+    License.  (Exception: if the Program itself is interactive but\r
+    does not normally print such an announcement, your work based on\r
+    the Program is not required to print an announcement.)\r
+\r
+These requirements apply to the modified work as a whole.  If\r
+identifiable sections of that work are not derived from the Program,\r
+and can be reasonably considered independent and separate works in\r
+themselves, then this License, and its terms, do not apply to those\r
+sections when you distribute them as separate works.  But when you\r
+distribute the same sections as part of a whole which is a work based\r
+on the Program, the distribution of the whole must be on the terms of\r
+this License, whose permissions for other licensees extend to the\r
+entire whole, and thus to each and every part regardless of who wrote it.\r
+\r
+Thus, it is not the intent of this section to claim rights or contest\r
+your rights to work written entirely by you; rather, the intent is to\r
+exercise the right to control the distribution of derivative or\r
+collective works based on the Program.\r
+\r
+In addition, mere aggregation of another work not based on the Program\r
+with the Program (or with a work based on the Program) on a volume of\r
+a storage or distribution medium does not bring the other work under\r
+the scope of this License.\r
+\r
+  3. You may copy and distribute the Program (or a work based on it,\r
+under Section 2) in object code or executable form under the terms of\r
+Sections 1 and 2 above provided that you also do one of the following:\r
+\r
+    a) Accompany it with the complete corresponding machine-readable\r
+    source code, which must be distributed under the terms of Sections\r
+    1 and 2 above on a medium customarily used for software interchange; or,\r
+\r
+    b) Accompany it with a written offer, valid for at least three\r
+    years, to give any third party, for a charge no more than your\r
+    cost of physically performing source distribution, a complete\r
+    machine-readable copy of the corresponding source code, to be\r
+    distributed under the terms of Sections 1 and 2 above on a medium\r
+    customarily used for software interchange; or,\r
+\r
+    c) Accompany it with the information you received as to the offer\r
+    to distribute corresponding source code.  (This alternative is\r
+    allowed only for noncommercial distribution and only if you\r
+    received the program in object code or executable form with such\r
+    an offer, in accord with Subsection b above.)\r
+\r
+The source code for a work means the preferred form of the work for\r
+making modifications to it.  For an executable work, complete source\r
+code means all the source code for all modules it contains, plus any\r
+associated interface definition files, plus the scripts used to\r
+control compilation and installation of the executable.  However, as a\r
+special exception, the source code distributed need not include\r
+anything that is normally distributed (in either source or binary\r
+form) with the major components (compiler, kernel, and so on) of the\r
+operating system on which the executable runs, unless that component\r
+itself accompanies the executable.\r
+\r
+If distribution of executable or object code is made by offering\r
+access to copy from a designated place, then offering equivalent\r
+access to copy the source code from the same place counts as\r
+distribution of the source code, even though third parties are not\r
+compelled to copy the source along with the object code.\r
+\r
+  4. You may not copy, modify, sublicense, or distribute the Program\r
+except as expressly provided under this License.  Any attempt\r
+otherwise to copy, modify, sublicense or distribute the Program is\r
+void, and will automatically terminate your rights under this License.\r
+However, parties who have received copies, or rights, from you under\r
+this License will not have their licenses terminated so long as such\r
+parties remain in full compliance.\r
+\r
+  5. You are not required to accept this License, since you have not\r
+signed it.  However, nothing else grants you permission to modify or\r
+distribute the Program or its derivative works.  These actions are\r
+prohibited by law if you do not accept this License.  Therefore, by\r
+modifying or distributing the Program (or any work based on the\r
+Program), you indicate your acceptance of this License to do so, and\r
+all its terms and conditions for copying, distributing or modifying\r
+the Program or works based on it.\r
+\r
+  6. Each time you redistribute the Program (or any work based on the\r
+Program), the recipient automatically receives a license from the\r
+original licensor to copy, distribute or modify the Program subject to\r
+these terms and conditions.  You may not impose any further\r
+restrictions on the recipients' exercise of the rights granted herein.\r
+You are not responsible for enforcing compliance by third parties to\r
+this License.\r
+\r
+  7. If, as a consequence of a court judgment or allegation of patent\r
+infringement or for any other reason (not limited to patent issues),\r
+conditions are imposed on you (whether by court order, agreement or\r
+otherwise) that contradict the conditions of this License, they do not\r
+excuse you from the conditions of this License.  If you cannot\r
+distribute so as to satisfy simultaneously your obligations under this\r
+License and any other pertinent obligations, then as a consequence you\r
+may not distribute the Program at all.  For example, if a patent\r
+license would not permit royalty-free redistribution of the Program by\r
+all those who receive copies directly or indirectly through you, then\r
+the only way you could satisfy both it and this License would be to\r
+refrain entirely from distribution of the Program.\r
+\r
+If any portion of this section is held invalid or unenforceable under\r
+any particular circumstance, the balance of the section is intended to\r
+apply and the section as a whole is intended to apply in other\r
+circumstances.\r
+\r
+It is not the purpose of this section to induce you to infringe any\r
+patents or other property right claims or to contest validity of any\r
+such claims; this section has the sole purpose of protecting the\r
+integrity of the free software distribution system, which is\r
+implemented by public license practices.  Many people have made\r
+generous contributions to the wide range of software distributed\r
+through that system in reliance on consistent application of that\r
+system; it is up to the author/donor to decide if he or she is willing\r
+to distribute software through any other system and a licensee cannot\r
+impose that choice.\r
+\r
+This section is intended to make thoroughly clear what is believed to\r
+be a consequence of the rest of this License.\r
+\r
+  8. If the distribution and/or use of the Program is restricted in\r
+certain countries either by patents or by copyrighted interfaces, the\r
+original copyright holder who places the Program under this License\r
+may add an explicit geographical distribution limitation excluding\r
+those countries, so that distribution is permitted only in or among\r
+countries not thus excluded.  In such case, this License incorporates\r
+the limitation as if written in the body of this License.\r
+\r
+  9. The Free Software Foundation may publish revised and/or new versions\r
+of the General Public License from time to time.  Such new versions will\r
+be similar in spirit to the present version, but may differ in detail to\r
+address new problems or concerns.\r
+\r
+Each version is given a distinguishing version number.  If the Program\r
+specifies a version number of this License which applies to it and "any\r
+later version", you have the option of following the terms and conditions\r
+either of that version or of any later version published by the Free\r
+Software Foundation.  If the Program does not specify a version number of\r
+this License, you may choose any version ever published by the Free Software\r
+Foundation.\r
+\r
+  10. If you wish to incorporate parts of the Program into other free\r
+programs whose distribution conditions are different, write to the author\r
+to ask for permission.  For software which is copyrighted by the Free\r
+Software Foundation, write to the Free Software Foundation; we sometimes\r
+make exceptions for this.  Our decision will be guided by the two goals\r
+of preserving the free status of all derivatives of our free software and\r
+of promoting the sharing and reuse of software generally.\r
+\r
+                           NO WARRANTY\r
+\r
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY\r
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN\r
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES\r
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED\r
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\r
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS\r
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE\r
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,\r
+REPAIR OR CORRECTION.\r
+\r
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\r
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR\r
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,\r
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING\r
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED\r
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY\r
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\r
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\r
+POSSIBILITY OF SUCH DAMAGES.\r
+\r
+                    END OF TERMS AND CONDITIONS\r
+\r
+           How to Apply These Terms to Your New Programs\r
+\r
+  If you develop a new program, and you want it to be of the greatest\r
+possible use to the public, the best way to achieve this is to make it\r
+free software which everyone can redistribute and change under these terms.\r
+\r
+  To do so, attach the following notices to the program.  It is safest\r
+to attach them to the start of each source file to most effectively\r
+convey the exclusion of warranty; and each file should have at least\r
+the "copyright" line and a pointer to where the full notice is found.\r
+\r
+    <one line to give the program's name and a brief idea of what it does.>\r
+    Copyright (C) <year>  <name of author>\r
+\r
+    This program is free software; you can redistribute it and/or modify\r
+    it under the terms of the GNU General Public License as published by\r
+    the Free Software Foundation; either version 2 of the License, or\r
+    (at your option) any later version.\r
+\r
+    This program is distributed in the hope that it will be useful,\r
+    but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
+    GNU General Public License for more details.\r
+\r
+    You should have received a copy of the GNU General Public License\r
+    along with this program; if not, write to the Free Software\r
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\r
+\r
+\r
+Also add information on how to contact you by electronic and paper mail.\r
+\r
+If the program is interactive, make it output a short notice like this\r
+when it starts in an interactive mode:\r
+\r
+    Gnomovision version 69, Copyright (C) year name of author\r
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.\r
+    This is free software, and you are welcome to redistribute it\r
+    under certain conditions; type `show c' for details.\r
+\r
+The hypothetical commands `show w' and `show c' should show the appropriate\r
+parts of the General Public License.  Of course, the commands you use may\r
+be called something other than `show w' and `show c'; they could even be\r
+mouse-clicks or menu items--whatever suits your program.\r
+\r
+You should also get your employer (if you work as a programmer) or your\r
+school, if any, to sign a "copyright disclaimer" for the program, if\r
+necessary.  Here is a sample; alter the names:\r
+\r
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program\r
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.\r
+\r
+  <signature of Ty Coon>, 1 April 1989\r
+  Ty Coon, President of Vice\r
+\r
+This General Public License does not permit incorporating your program into\r
+proprietary programs.  If your program is a subroutine library, you may\r
+consider it more useful to permit linking proprietary applications with the\r
+library.  If this is what you want to do, use the GNU Library General\r
+Public License instead of this License.\r
\ No newline at end of file

diff --git a/trunk/packages/NUnit.2.5.10.11092/lib/nunit.framework.dll b/trunk/packages/NUnit.2.5.10.11092/lib/nunit.framework.dll
new file mode 100644 (file)
index 0000000..6856e51
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/lib/nunit.framework.dll differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/lib/nunit.framework.xml b/trunk/packages/NUnit.2.5.10.11092/lib/nunit.framework.xml
new file mode 100644 (file)
index 0000000..a56c62f
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/lib/nunit.framework.xml
@@ -0,0 +1,10407 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>nunit.framework</name>
+    </assembly>
+    <members>
+        <member name="T:NUnit.Framework.CategoryAttribute">
+            <summary>
+            Attribute used to apply a category to a test
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.CategoryAttribute.categoryName">
+            <summary>
+            The name of the category
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.CategoryAttribute.#ctor(System.String)">
+            <summary>
+            Construct attribute for a given category based on
+            a name. The name may not contain the characters ',',
+            '+', '-' or '!'. However, this is not checked in the
+            constructor since it would cause an error to arise at
+            as the test was loaded without giving a clear indication
+            of where the problem is located. The error is handled
+            in NUnitFramework.cs by marking the test as not
+            runnable.
+            </summary>
+            <param name="name">The name of the category</param>
+        </member>
+        <member name="M:NUnit.Framework.CategoryAttribute.#ctor">
+            <summary>
+            Protected constructor uses the Type name as the name
+            of the category.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.CategoryAttribute.Name">
+            <summary>
+            The name of the category
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.DatapointAttribute">
+            <summary>
+            Used to mark a field for use as a datapoint when executing a theory
+            within the same fixture that requires an argument of the field's Type.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.DatapointsAttribute">
+            <summary>
+            Used to mark an array as containing a set of datapoints to be used
+            executing a theory within the same fixture that requires an argument 
+            of the Type of the array elements.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.DescriptionAttribute">
+            <summary>
+            Attribute used to provide descriptive text about a 
+            test case or fixture.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.DescriptionAttribute.#ctor(System.String)">
+            <summary>
+            Construct the attribute
+            </summary>
+            <param name="description">Text describing the test</param>
+        </member>
+        <member name="P:NUnit.Framework.DescriptionAttribute.Description">
+            <summary>
+            Gets the test description
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.MessageMatch">
+            <summary>
+            Enumeration indicating how the expected message parameter is to be used
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.MessageMatch.Exact">
+            Expect an exact match
+        </member>
+        <member name="F:NUnit.Framework.MessageMatch.Contains">
+            Expect a message containing the parameter string
+        </member>
+        <member name="F:NUnit.Framework.MessageMatch.Regex">
+            Match the regular expression provided as a parameter
+        </member>
+        <member name="F:NUnit.Framework.MessageMatch.StartsWith">
+            Expect a message that starts with the parameter string
+        </member>
+        <member name="T:NUnit.Framework.ExpectedExceptionAttribute">
+            <summary>
+            ExpectedExceptionAttribute
+            </summary>
+            
+        </member>
+        <member name="M:NUnit.Framework.ExpectedExceptionAttribute.#ctor">
+            <summary>
+            Constructor for a non-specific exception
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.ExpectedExceptionAttribute.#ctor(System.Type)">
+            <summary>
+            Constructor for a given type of exception
+            </summary>
+            <param name="exceptionType">The type of the expected exception</param>
+        </member>
+        <member name="M:NUnit.Framework.ExpectedExceptionAttribute.#ctor(System.String)">
+            <summary>
+            Constructor for a given exception name
+            </summary>
+            <param name="exceptionName">The full name of the expected exception</param>
+        </member>
+        <member name="P:NUnit.Framework.ExpectedExceptionAttribute.ExpectedException">
+            <summary>
+            Gets or sets the expected exception type
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.ExpectedExceptionAttribute.ExpectedExceptionName">
+            <summary>
+            Gets or sets the full Type name of the expected exception
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.ExpectedExceptionAttribute.ExpectedMessage">
+            <summary>
+            Gets or sets the expected message text
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.ExpectedExceptionAttribute.UserMessage">
+            <summary>
+            Gets or sets the user message displayed in case of failure
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.ExpectedExceptionAttribute.MatchType">
+            <summary>
+             Gets or sets the type of match to be performed on the expected message
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.ExpectedExceptionAttribute.Handler">
+            <summary>
+             Gets the name of a method to be used as an exception handler
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.ExplicitAttribute">
+            <summary>
+            ExplicitAttribute marks a test or test fixture so that it will
+            only be run if explicitly executed from the gui or command line
+            or if it is included by use of a filter. The test will not be
+            run simply because an enclosing suite is run.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.ExplicitAttribute.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.ExplicitAttribute.#ctor(System.String)">
+            <summary>
+            Constructor with a reason
+            </summary>
+            <param name="reason">The reason test is marked explicit</param>
+        </member>
+        <member name="P:NUnit.Framework.ExplicitAttribute.Reason">
+            <summary>
+            The reason test is marked explicit
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.IgnoreAttribute">
+            <summary>
+            Attribute used to mark a test that is to be ignored.
+            Ignored tests result in a warning message when the
+            tests are run.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.IgnoreAttribute.#ctor">
+            <summary>
+            Constructs the attribute without giving a reason 
+            for ignoring the test.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.IgnoreAttribute.#ctor(System.String)">
+            <summary>
+            Constructs the attribute giving a reason for ignoring the test
+            </summary>
+            <param name="reason">The reason for ignoring the test</param>
+        </member>
+        <member name="P:NUnit.Framework.IgnoreAttribute.Reason">
+            <summary>
+            The reason for ignoring a test
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.IncludeExcludeAttribute">
+            <summary>
+            Abstract base for Attributes that are used to include tests
+            in the test run based on environmental settings.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.IncludeExcludeAttribute.#ctor">
+            <summary>
+            Constructor with no included items specified, for use
+            with named property syntax.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.IncludeExcludeAttribute.#ctor(System.String)">
+            <summary>
+            Constructor taking one or more included items
+            </summary>
+            <param name="include">Comma-delimited list of included items</param>
+        </member>
+        <member name="P:NUnit.Framework.IncludeExcludeAttribute.Include">
+            <summary>
+            Name of the item that is needed in order for
+            a test to run. Multiple itemss may be given,
+            separated by a comma.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.IncludeExcludeAttribute.Exclude">
+            <summary>
+            Name of the item to be excluded. Multiple items
+            may be given, separated by a comma.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.IncludeExcludeAttribute.Reason">
+            <summary>
+            The reason for including or excluding the test
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.PlatformAttribute">
+            <summary>
+            PlatformAttribute is used to mark a test fixture or an
+            individual method as applying to a particular platform only.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.PlatformAttribute.#ctor">
+            <summary>
+            Constructor with no platforms specified, for use
+            with named property syntax.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.PlatformAttribute.#ctor(System.String)">
+            <summary>
+            Constructor taking one or more platforms
+            </summary>
+            <param name="platforms">Comma-deliminted list of platforms</param>
+        </member>
+        <member name="T:NUnit.Framework.CultureAttribute">
+            <summary>
+            CultureAttribute is used to mark a test fixture or an
+            individual method as applying to a particular Culture only.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.CultureAttribute.#ctor">
+            <summary>
+            Constructor with no cultures specified, for use
+            with named property syntax.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.CultureAttribute.#ctor(System.String)">
+            <summary>
+            Constructor taking one or more cultures
+            </summary>
+            <param name="cultures">Comma-deliminted list of cultures</param>
+        </member>
+        <member name="T:NUnit.Framework.CombinatorialAttribute">
+            <summary>
+            Marks a test to use a combinatorial join of any argument data 
+            provided. NUnit will create a test case for every combination of 
+            the arguments provided. This can result in a large number of test
+            cases and so should be used judiciously. This is the default join
+            type, so the attribute need not be used except as documentation.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.PropertyAttribute">
+            <summary>
+            PropertyAttribute is used to attach information to a test as a name/value pair..
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.String,System.String)">
+            <summary>
+            Construct a PropertyAttribute with a name and string value
+            </summary>
+            <param name="propertyName">The name of the property</param>
+            <param name="propertyValue">The property value</param>
+        </member>
+        <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.String,System.Int32)">
+            <summary>
+            Construct a PropertyAttribute with a name and int value
+            </summary>
+            <param name="propertyName">The name of the property</param>
+            <param name="propertyValue">The property value</param>
+        </member>
+        <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.String,System.Double)">
+            <summary>
+            Construct a PropertyAttribute with a name and double value
+            </summary>
+            <param name="propertyName">The name of the property</param>
+            <param name="propertyValue">The property value</param>
+        </member>
+        <member name="M:NUnit.Framework.PropertyAttribute.#ctor">
+            <summary>
+            Constructor for derived classes that set the
+            property dictionary directly.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.Object)">
+            <summary>
+            Constructor for use by derived classes that use the
+            name of the type as the property name. Derived classes
+            must ensure that the Type of the property value is
+            a standard type supported by the BCL. Any custom
+            types will cause a serialization Exception when
+            in the client.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.PropertyAttribute.Properties">
+            <summary>
+            Gets the property dictionary for this attribute
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.CombinatorialAttribute.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.PairwiseAttribute">
+            <summary>
+            Marks a test to use pairwise join of any argument data provided. 
+            NUnit will attempt too excercise every pair of argument values at 
+            least once, using as small a number of test cases as it can. With
+            only two arguments, this is the same as a combinatorial join.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.PairwiseAttribute.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.SequentialAttribute">
+            <summary>
+            Marks a test to use a sequential join of any argument data
+            provided. NUnit will use arguements for each parameter in
+            sequence, generating test cases up to the largest number
+            of argument values provided and using null for any arguments
+            for which it runs out of values. Normally, this should be
+            used with the same number of arguments for each parameter.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.SequentialAttribute.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.MaxTimeAttribute">
+            <summary>
+            Summary description for MaxTimeAttribute.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.MaxTimeAttribute.#ctor(System.Int32)">
+            <summary>
+            Construct a MaxTimeAttribute, given a time in milliseconds.
+            </summary>
+            <param name="milliseconds">The maximum elapsed time in milliseconds</param>
+        </member>
+        <member name="T:NUnit.Framework.RandomAttribute">
+            <summary>
+            RandomAttribute is used to supply a set of random values
+            to a single parameter of a parameterized test.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.ValuesAttribute">
+            <summary>
+            ValuesAttribute is used to provide literal arguments for
+            an individual parameter of a test.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.ParameterDataAttribute">
+            <summary>
+            Abstract base class for attributes that apply to parameters 
+            and supply data for the parameter.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.ParameterDataAttribute.GetData(System.Reflection.ParameterInfo)">
+            <summary>
+            Gets the data to be provided to the specified parameter
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.ValuesAttribute.data">
+            <summary>
+            The collection of data to be returned. Must
+            be set by any derived attribute classes.
+            We use an object[] so that the individual
+            elements may have their type changed in GetData
+            if necessary.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object)">
+            <summary>
+            Construct with one argument
+            </summary>
+            <param name="arg1"></param>
+        </member>
+        <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object,System.Object)">
+            <summary>
+            Construct with two arguments
+            </summary>
+            <param name="arg1"></param>
+            <param name="arg2"></param>
+        </member>
+        <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object,System.Object,System.Object)">
+            <summary>
+            Construct with three arguments
+            </summary>
+            <param name="arg1"></param>
+            <param name="arg2"></param>
+            <param name="arg3"></param>
+        </member>
+        <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object[])">
+            <summary>
+            Construct with an array of arguments
+            </summary>
+            <param name="args"></param>
+        </member>
+        <member name="M:NUnit.Framework.ValuesAttribute.GetData(System.Reflection.ParameterInfo)">
+            <summary>
+            Get the collection of values to be used as arguments
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.RandomAttribute.#ctor(System.Int32)">
+            <summary>
+            Construct a set of doubles from 0.0 to 1.0,
+            specifying only the count.
+            </summary>
+            <param name="count"></param>
+        </member>
+        <member name="M:NUnit.Framework.RandomAttribute.#ctor(System.Double,System.Double,System.Int32)">
+            <summary>
+            Construct a set of doubles from min to max
+            </summary>
+            <param name="min"></param>
+            <param name="max"></param>
+            <param name="count"></param>
+        </member>
+        <member name="M:NUnit.Framework.RandomAttribute.#ctor(System.Int32,System.Int32,System.Int32)">
+            <summary>
+            Construct a set of ints from min to max
+            </summary>
+            <param name="min"></param>
+            <param name="max"></param>
+            <param name="count"></param>
+        </member>
+        <member name="M:NUnit.Framework.RandomAttribute.GetData(System.Reflection.ParameterInfo)">
+            <summary>
+            Get the collection of values to be used as arguments
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.RangeAttribute">
+            <summary>
+            RangeAttribute is used to supply a range of values to an
+            individual parameter of a parameterized test.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Int32,System.Int32)">
+            <summary>
+            Construct a range of ints using default step of 1
+            </summary>
+            <param name="from"></param>
+            <param name="to"></param>
+        </member>
+        <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Int32,System.Int32,System.Int32)">
+            <summary>
+            Construct a range of ints specifying the step size 
+            </summary>
+            <param name="from"></param>
+            <param name="to"></param>
+            <param name="step"></param>
+        </member>
+        <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Int64,System.Int64,System.Int64)">
+            <summary>
+            Construct a range of longs
+            </summary>
+            <param name="from"></param>
+            <param name="to"></param>
+            <param name="step"></param>
+        </member>
+        <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Double,System.Double,System.Double)">
+            <summary>
+            Construct a range of doubles
+            </summary>
+            <param name="from"></param>
+            <param name="to"></param>
+            <param name="step"></param>
+        </member>
+        <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Single,System.Single,System.Single)">
+            <summary>
+            Construct a range of floats
+            </summary>
+            <param name="from"></param>
+            <param name="to"></param>
+            <param name="step"></param>
+        </member>
+        <member name="T:NUnit.Framework.RepeatAttribute">
+            <summary>
+            RepeatAttribute may be applied to test case in order
+            to run it multiple times.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.RepeatAttribute.#ctor(System.Int32)">
+            <summary>
+            Construct a RepeatAttribute
+            </summary>
+            <param name="count">The number of times to run the test</param>
+        </member>
+        <member name="T:NUnit.Framework.RequiredAddinAttribute">
+            <summary>
+            RequiredAddinAttribute may be used to indicate the names of any addins
+            that must be present in order to run some or all of the tests in an
+            assembly. If the addin is not loaded, the entire assembly is marked
+            as NotRunnable.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.RequiredAddinAttribute.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:RequiredAddinAttribute"/> class.
+            </summary>
+            <param name="requiredAddin">The required addin.</param>
+        </member>
+        <member name="P:NUnit.Framework.RequiredAddinAttribute.RequiredAddin">
+            <summary>
+            Gets the name of required addin.
+            </summary>
+            <value>The required addin name.</value>
+        </member>
+        <member name="T:NUnit.Framework.SetCultureAttribute">
+            <summary>
+            Summary description for SetCultureAttribute.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.SetCultureAttribute.#ctor(System.String)">
+            <summary>
+            Construct given the name of a culture
+            </summary>
+            <param name="culture"></param>
+        </member>
+        <member name="T:NUnit.Framework.SetUICultureAttribute">
+            <summary>
+            Summary description for SetUICultureAttribute.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.SetUICultureAttribute.#ctor(System.String)">
+            <summary>
+            Construct given the name of a culture
+            </summary>
+            <param name="culture"></param>
+        </member>
+        <member name="T:NUnit.Framework.SetUpAttribute">
+            <summary>
+            Attribute used to mark a class that contains one-time SetUp 
+            and/or TearDown methods that apply to all the tests in a
+            namespace or an assembly.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.SetUpFixtureAttribute">
+            <summary>
+            SetUpFixtureAttribute is used to identify a SetUpFixture
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.SuiteAttribute">
+            <summary>
+            Attribute used to mark a static (shared in VB) property
+            that returns a list of tests.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.TearDownAttribute">
+            <summary>
+            Attribute used to identify a method that is called 
+            immediately after each test is run. The method is 
+            guaranteed to be called, even if an exception is thrown.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.TestAttribute">
+            <summary>
+            Adding this attribute to a method within a <seealso cref="T:NUnit.Framework.TestFixtureAttribute"/> 
+            class makes the method callable from the NUnit test runner. There is a property 
+            called Description which is optional which you can provide a more detailed test
+            description. This class cannot be inherited.
+            </summary>
+            
+            <example>
+            [TestFixture]
+            public class Fixture
+            {
+              [Test]
+              public void MethodToTest()
+              {}
+              
+              [Test(Description = "more detailed description")]
+              publc void TestDescriptionMethod()
+              {}
+            }
+            </example>
+            
+        </member>
+        <member name="P:NUnit.Framework.TestAttribute.Description">
+            <summary>
+            Descriptive text for this test
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.TestCaseAttribute">
+            <summary>
+            TestCaseAttribute is used to mark parameterized test cases
+            and provide them with their arguments.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.ITestCaseData">
+            <summary>
+            The ITestCaseData interface is implemented by a class
+            that is able to return complete testcases for use by
+            a parameterized test method.
+            
+            NOTE: This interface is used in both the framework
+            and the core, even though that results in two different
+            types. However, sharing the source code guarantees that
+            the various implementations will be compatible and that
+            the core is able to reflect successfully over the
+            framework implementations of ITestCaseData.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.ITestCaseData.Arguments">
+            <summary>
+            Gets the argument list to be provided to the test
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.ITestCaseData.Result">
+            <summary>
+            Gets the expected result
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.ITestCaseData.ExpectedException">
+            <summary>
+             Gets the expected exception Type
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.ITestCaseData.ExpectedExceptionName">
+            <summary>
+            Gets the FullName of the expected exception
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.ITestCaseData.TestName">
+            <summary>
+            Gets the name to be used for the test
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.ITestCaseData.Description">
+            <summary>
+            Gets the description of the test
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.ITestCaseData.Ignored">
+            <summary>
+            Gets a value indicating whether this <see cref="T:NUnit.Framework.ITestCaseData"/> is ignored.
+            </summary>
+            <value><c>true</c> if ignored; otherwise, <c>false</c>.</value>
+        </member>
+        <member name="P:NUnit.Framework.ITestCaseData.IgnoreReason">
+            <summary>
+            Gets the ignore reason.
+            </summary>
+            <value>The ignore reason.</value>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object[])">
+            <summary>
+            Construct a TestCaseAttribute with a list of arguments.
+            This constructor is not CLS-Compliant
+            </summary>
+            <param name="arguments"></param>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object)">
+            <summary>
+            Construct a TestCaseAttribute with a single argument
+            </summary>
+            <param name="arg"></param>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object,System.Object)">
+            <summary>
+            Construct a TestCaseAttribute with a two arguments
+            </summary>
+            <param name="arg1"></param>
+            <param name="arg2"></param>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object,System.Object,System.Object)">
+            <summary>
+            Construct a TestCaseAttribute with a three arguments
+            </summary>
+            <param name="arg1"></param>
+            <param name="arg2"></param>
+            <param name="arg3"></param>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseAttribute.Arguments">
+            <summary>
+            Gets the list of arguments to a test case
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseAttribute.Result">
+            <summary>
+            Gets or sets the expected result.
+            </summary>
+            <value>The result.</value>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseAttribute.Categories">
+            <summary>
+            Gets a list of categories associated with this test;
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseAttribute.Category">
+            <summary>
+            Gets or sets the category associated with this test.
+            May be a single category or a comma-separated list.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseAttribute.ExpectedException">
+            <summary>
+            Gets or sets the expected exception.
+            </summary>
+            <value>The expected exception.</value>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseAttribute.ExpectedExceptionName">
+            <summary>
+            Gets or sets the name the expected exception.
+            </summary>
+            <value>The expected name of the exception.</value>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseAttribute.ExpectedMessage">
+            <summary>
+            Gets or sets the expected message of the expected exception
+            </summary>
+            <value>The expected message of the exception.</value>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseAttribute.MatchType">
+            <summary>
+             Gets or sets the type of match to be performed on the expected message
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseAttribute.Description">
+            <summary>
+            Gets or sets the description.
+            </summary>
+            <value>The description.</value>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseAttribute.TestName">
+            <summary>
+            Gets or sets the name of the test.
+            </summary>
+            <value>The name of the test.</value>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseAttribute.Ignore">
+            <summary>
+            Gets or sets the ignored status of the test
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseAttribute.Ignored">
+            <summary>
+            Gets or sets the ignored status of the test
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseAttribute.IgnoreReason">
+            <summary>
+            Gets the ignore reason.
+            </summary>
+            <value>The ignore reason.</value>
+        </member>
+        <member name="T:NUnit.Framework.TestCaseSourceAttribute">
+            <summary>
+            FactoryAttribute indicates the source to be used to
+            provide test cases for a test method.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseSourceAttribute.#ctor(System.String)">
+            <summary>
+            Construct with the name of the factory - for use with languages
+            that don't support params arrays.
+            </summary>
+            <param name="sourceName">An array of the names of the factories that will provide data</param>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseSourceAttribute.#ctor(System.Type,System.String)">
+            <summary>
+            Construct with a Type and name - for use with languages
+            that don't support params arrays.
+            </summary>
+            <param name="sourceType">The Type that will provide data</param>
+            <param name="sourceName">The name of the method, property or field that will provide data</param>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseSourceAttribute.SourceName">
+            <summary>
+            The name of a the method, property or fiend to be used as a source
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseSourceAttribute.SourceType">
+            <summary>
+            A Type to be used as a source
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.TestFixtureAttribute">
+            <example>
+            [TestFixture]
+            public class ExampleClass 
+            {}
+            </example>
+        </member>
+        <member name="M:NUnit.Framework.TestFixtureAttribute.#ctor">
+            <summary>
+            Default constructor
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.TestFixtureAttribute.#ctor(System.Object[])">
+            <summary>
+            Construct with a object[] representing a set of arguments. 
+            In .NET 2.0, the arguments may later be separated into
+            type arguments and constructor arguments.
+            </summary>
+            <param name="arguments"></param>
+        </member>
+        <member name="P:NUnit.Framework.TestFixtureAttribute.Description">
+            <summary>
+            Descriptive text for this fixture
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestFixtureAttribute.Category">
+            <summary>
+            Gets and sets the category for this fixture.
+            May be a comma-separated list of categories.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestFixtureAttribute.Categories">
+            <summary>
+            Gets a list of categories for this fixture
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestFixtureAttribute.Arguments">
+            <summary>
+            The arguments originally provided to the attribute
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestFixtureAttribute.Ignore">
+            <summary>
+            Gets or sets a value indicating whether this <see cref="T:NUnit.Framework.TestFixtureAttribute"/> should be ignored.
+            </summary>
+            <value><c>true</c> if ignore; otherwise, <c>false</c>.</value>
+        </member>
+        <member name="P:NUnit.Framework.TestFixtureAttribute.IgnoreReason">
+            <summary>
+            Gets or sets the ignore reason. May set Ignored as a side effect.
+            </summary>
+            <value>The ignore reason.</value>
+        </member>
+        <member name="P:NUnit.Framework.TestFixtureAttribute.TypeArgs">
+            <summary>
+            Get or set the type arguments. If not set
+            explicitly, any leading arguments that are
+            Types are taken as type arguments.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.TestFixtureSetUpAttribute">
+            <summary>
+            Attribute used to identify a method that is 
+            called before any tests in a fixture are run.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.TestFixtureTearDownAttribute">
+            <summary>
+            Attribute used to identify a method that is called after
+            all the tests in a fixture have run. The method is 
+            guaranteed to be called, even if an exception is thrown.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.TheoryAttribute">
+            <summary>
+            Adding this attribute to a method within a <seealso cref="T:NUnit.Framework.TestFixtureAttribute"/> 
+            class makes the method callable from the NUnit test runner. There is a property 
+            called Description which is optional which you can provide a more detailed test
+            description. This class cannot be inherited.
+            </summary>
+            
+            <example>
+            [TestFixture]
+            public class Fixture
+            {
+              [Test]
+              public void MethodToTest()
+              {}
+              
+              [Test(Description = "more detailed description")]
+              publc void TestDescriptionMethod()
+              {}
+            }
+            </example>
+            
+        </member>
+        <member name="T:NUnit.Framework.TimeoutAttribute">
+            <summary>
+            WUsed on a method, marks the test with a timeout value in milliseconds. 
+            The test will be run in a separate thread and is cancelled if the timeout 
+            is exceeded. Used on a method or assembly, sets the default timeout 
+            for all contained test methods.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.TimeoutAttribute.#ctor(System.Int32)">
+            <summary>
+            Construct a TimeoutAttribute given a time in milliseconds
+            </summary>
+            <param name="timeout">The timeout value in milliseconds</param>
+        </member>
+        <member name="T:NUnit.Framework.RequiresSTAAttribute">
+            <summary>
+            Marks a test that must run in the STA, causing it
+            to run in a separate thread if necessary.
+            
+            On methods, you may also use STAThreadAttribute
+            to serve the same purpose.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.RequiresSTAAttribute.#ctor">
+            <summary>
+            Construct a RequiresSTAAttribute
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.RequiresMTAAttribute">
+            <summary>
+            Marks a test that must run in the MTA, causing it
+            to run in a separate thread if necessary.
+            
+            On methods, you may also use MTAThreadAttribute
+            to serve the same purpose.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.RequiresMTAAttribute.#ctor">
+            <summary>
+            Construct a RequiresMTAAttribute
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.RequiresThreadAttribute">
+            <summary>
+            Marks a test that must run on a separate thread.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.RequiresThreadAttribute.#ctor">
+            <summary>
+            Construct a RequiresThreadAttribute
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.RequiresThreadAttribute.#ctor(System.Threading.ApartmentState)">
+            <summary>
+            Construct a RequiresThreadAttribute, specifying the apartment
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.ValueSourceAttribute">
+            <summary>
+            ValueSourceAttribute indicates the source to be used to
+            provide data for one parameter of a test method.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.ValueSourceAttribute.#ctor(System.String)">
+            <summary>
+            Construct with the name of the factory - for use with languages
+            that don't support params arrays.
+            </summary>
+            <param name="sourceName">The name of the data source to be used</param>
+        </member>
+        <member name="M:NUnit.Framework.ValueSourceAttribute.#ctor(System.Type,System.String)">
+            <summary>
+            Construct with a Type and name - for use with languages
+            that don't support params arrays.
+            </summary>
+            <param name="sourceType">The Type that will provide data</param>
+            <param name="sourceName">The name of the method, property or field that will provide data</param>
+        </member>
+        <member name="P:NUnit.Framework.ValueSourceAttribute.SourceName">
+            <summary>
+            The name of a the method, property or fiend to be used as a source
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.ValueSourceAttribute.SourceType">
+            <summary>
+            A Type to be used as a source
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.AttributeExistsConstraint">
+            <summary>
+            AttributeExistsConstraint tests for the presence of a
+            specified attribute on  a Type.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.Constraint">
+            <summary>
+            The Constraint class is the base of all built-in constraints
+            within NUnit. It provides the operator overloads used to combine 
+            constraints.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.IResolveConstraint">
+            <summary>
+            The IConstraintExpression interface is implemented by all
+            complete and resolvable constraints and expressions.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.IResolveConstraint.Resolve">
+            <summary>
+            Return the top-level constraint for this expression
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.Constraint.UNSET">
+            <summary>
+            Static UnsetObject used to detect derived constraints
+            failing to set the actual value.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.Constraint.actual">
+            <summary>
+            The actual value being tested against a constraint
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.Constraint.displayName">
+            <summary>
+            The display name of this Constraint for use by ToString()
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.Constraint.argcnt">
+            <summary>
+            Argument fields used by ToString();
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.Constraint.builder">
+            <summary>
+            The builder holding this constraint
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Constraint.#ctor">
+            <summary>
+            Construct a constraint with no arguments
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Constraint.#ctor(System.Object)">
+            <summary>
+            Construct a constraint with one argument
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Constraint.#ctor(System.Object,System.Object)">
+            <summary>
+            Construct a constraint with two arguments
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Constraint.SetBuilder(NUnit.Framework.Constraints.ConstraintBuilder)">
+            <summary>
+            Sets the ConstraintBuilder holding this constraint
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Constraint.WriteMessageTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the failure message to the MessageWriter provided
+            as an argument. The default implementation simply passes
+            the constraint and the actual value to the writer, which
+            then displays the constraint description and the value.
+            
+            Constraints that need to provide additional details,
+            such as where the error occured can override this.
+            </summary>
+            <param name="writer">The MessageWriter on which to display the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Constraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Constraint.Matches(NUnit.Framework.Constraints.ActualValueDelegate)">
+            <summary>
+            Test whether the constraint is satisfied by an
+            ActualValueDelegate that returns the value to be tested.
+            The default implementation simply evaluates the delegate
+            but derived classes may override it to provide for delayed 
+            processing.
+            </summary>
+            <param name="del">An ActualValueDelegate</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Constraint.Matches``1(``0@)">
+            <summary>
+            Test whether the constraint is satisfied by a given reference.
+            The default implementation simply dereferences the value but
+            derived classes may override it to provide for delayed processing.
+            </summary>
+            <param name="actual">A reference to the value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Constraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Constraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the actual value for a failing constraint test to a
+            MessageWriter. The default implementation simply writes
+            the raw value of actual, leaving it to the writer to
+            perform any formatting.
+            </summary>
+            <param name="writer">The writer on which the actual value is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Constraint.ToString">
+            <summary>
+            Default override of ToString returns the constraint DisplayName
+            followed by any arguments within angle brackets.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Constraint.GetStringRepresentation">
+            <summary>
+            Returns the string representation of this constraint
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Constraint.op_BitwiseAnd(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            This operator creates a constraint that is satisfied only if both 
+            argument constraints are satisfied.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Constraint.op_BitwiseOr(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            This operator creates a constraint that is satisfied if either 
+            of the argument constraints is satisfied.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Constraint.op_LogicalNot(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            This operator creates a constraint that is satisfied if the 
+            argument constraint is not satisfied.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Constraint.After(System.Int32)">
+            <summary>
+            Returns a DelayedConstraint with the specified delay time.
+            </summary>
+            <param name="delayInMilliseconds">The delay in milliseconds.</param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Constraint.After(System.Int32,System.Int32)">
+            <summary>
+            Returns a DelayedConstraint with the specified delay time
+            and polling interval.
+            </summary>
+            <param name="delayInMilliseconds">The delay in milliseconds.</param>
+            <param name="pollingInterval">The interval at which to test the constraint.</param>
+            <returns></returns>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.Constraint.DisplayName">
+            <summary>
+            The display name of this Constraint for use by ToString().
+            The default value is the name of the constraint with
+            trailing "Constraint" removed. Derived classes may set
+            this to another name in their constructors.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.Constraint.And">
+            <summary>
+            Returns a ConstraintExpression by appending And
+            to the current constraint.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.Constraint.With">
+            <summary>
+            Returns a ConstraintExpression by appending And
+            to the current constraint.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.Constraint.Or">
+            <summary>
+            Returns a ConstraintExpression by appending Or
+            to the current constraint.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.Constraint.UnsetObject">
+            <summary>
+            Class used to detect any derived constraints
+            that fail to set the actual value in their
+            Matches override.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AttributeExistsConstraint.#ctor(System.Type)">
+            <summary>
+            Constructs an AttributeExistsConstraint for a specific attribute Type
+            </summary>
+            <param name="type"></param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AttributeExistsConstraint.Matches(System.Object)">
+            <summary>
+            Tests whether the object provides the expected attribute.
+            </summary>
+            <param name="actual">A Type, MethodInfo, or other ICustomAttributeProvider</param>
+            <returns>True if the expected attribute is present, otherwise false</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AttributeExistsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Writes the description of the constraint to the specified writer
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.AttributeConstraint">
+            <summary>
+            AttributeConstraint tests that a specified attribute is present
+            on a Type or other provider and that the value of the attribute
+            satisfies some other constraint.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.PrefixConstraint">
+            <summary>
+            Abstract base class used for prefixes
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.PrefixConstraint.baseConstraint">
+            <summary>
+            The base constraint
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PrefixConstraint.#ctor(NUnit.Framework.Constraints.IResolveConstraint)">
+            <summary>
+            Construct given a base constraint
+            </summary>
+            <param name="resolvable"></param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AttributeConstraint.#ctor(System.Type,NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Constructs an AttributeConstraint for a specified attriute
+            Type and base constraint.
+            </summary>
+            <param name="type"></param>
+            <param name="baseConstraint"></param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AttributeConstraint.Matches(System.Object)">
+            <summary>
+            Determines whether the Type or other provider has the 
+            expected attribute and if its value matches the
+            additional constraint specified.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AttributeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Writes a description of the attribute to the specified writer.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AttributeConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Writes the actual value supplied to the specified writer.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AttributeConstraint.GetStringRepresentation">
+            <summary>
+            Returns a string representation of the constraint.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.BasicConstraint">
+            <summary>
+            BasicConstraint is the abstract base for constraints that
+            perform a simple comparison to a constant value.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.BasicConstraint.#ctor(System.Object,System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:BasicConstraint"/> class.
+            </summary>
+            <param name="expected">The expected.</param>
+            <param name="description">The description.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.BasicConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.BasicConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.NullConstraint">
+            <summary>
+            NullConstraint tests that the actual value is null
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NullConstraint.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:NullConstraint"/> class.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.TrueConstraint">
+            <summary>
+            TrueConstraint tests that the actual value is true
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.TrueConstraint.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:TrueConstraint"/> class.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.FalseConstraint">
+            <summary>
+            FalseConstraint tests that the actual value is false
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.FalseConstraint.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:FalseConstraint"/> class.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.NaNConstraint">
+            <summary>
+            NaNConstraint tests that the actual value is a double or float NaN
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NaNConstraint.Matches(System.Object)">
+            <summary>
+            Test that the actual value is an NaN
+            </summary>
+            <param name="actual"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NaNConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a specified writer
+            </summary>
+            <param name="writer"></param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.BinaryConstraint">
+            <summary>
+            BinaryConstraint is the abstract base of all constraints
+            that combine two other constraints in some fashion.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.BinaryConstraint.left">
+            <summary>
+            The first constraint being combined
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.BinaryConstraint.right">
+            <summary>
+            The second constraint being combined
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.BinaryConstraint.#ctor(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Construct a BinaryConstraint from two other constraints
+            </summary>
+            <param name="left">The first constraint</param>
+            <param name="right">The second constraint</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.AndConstraint">
+            <summary>
+            AndConstraint succeeds only if both members succeed.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AndConstraint.#ctor(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Create an AndConstraint from two other constraints
+            </summary>
+            <param name="left">The first constraint</param>
+            <param name="right">The second constraint</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AndConstraint.Matches(System.Object)">
+            <summary>
+            Apply both member constraints to an actual value, succeeding 
+            succeeding only if both of them succeed.
+            </summary>
+            <param name="actual">The actual value</param>
+            <returns>True if the constraints both succeeded</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AndConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write a description for this contraint to a MessageWriter
+            </summary>
+            <param name="writer">The MessageWriter to receive the description</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AndConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the actual value for a failing constraint test to a
+            MessageWriter. The default implementation simply writes
+            the raw value of actual, leaving it to the writer to
+            perform any formatting.
+            </summary>
+            <param name="writer">The writer on which the actual value is displayed</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.OrConstraint">
+            <summary>
+            OrConstraint succeeds if either member succeeds
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.OrConstraint.#ctor(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Create an OrConstraint from two other constraints
+            </summary>
+            <param name="left">The first constraint</param>
+            <param name="right">The second constraint</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.OrConstraint.Matches(System.Object)">
+            <summary>
+            Apply the member constraints to an actual value, succeeding 
+            succeeding as soon as one of them succeeds.
+            </summary>
+            <param name="actual">The actual value</param>
+            <returns>True if either constraint succeeded</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.OrConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write a description for this contraint to a MessageWriter
+            </summary>
+            <param name="writer">The MessageWriter to receive the description</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.CollectionConstraint">
+            <summary>
+            CollectionConstraint is the abstract base class for
+            constraints that operate on collections.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionConstraint.#ctor">
+            <summary>
+            Construct an empty CollectionConstraint
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionConstraint.#ctor(System.Object)">
+            <summary>
+            Construct a CollectionConstraint
+            </summary>
+            <param name="arg"></param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionConstraint.IsEmpty(System.Collections.IEnumerable)">
+            <summary>
+            Determines whether the specified enumerable is empty.
+            </summary>
+            <param name="enumerable">The enumerable.</param>
+            <returns>
+               <c>true</c> if the specified enumerable is empty; otherwise, <c>false</c>.
+            </returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionConstraint.doMatch(System.Collections.IEnumerable)">
+            <summary>
+            Protected method to be implemented by derived classes
+            </summary>
+            <param name="collection"></param>
+            <returns></returns>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.CollectionItemsEqualConstraint">
+            <summary>
+            CollectionItemsEqualConstraint is the abstract base class for all
+            collection constraints that apply some notion of item equality
+            as a part of their operation.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.#ctor">
+            <summary>
+            Construct an empty CollectionConstraint
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.#ctor(System.Object)">
+            <summary>
+            Construct a CollectionConstraint
+            </summary>
+            <param name="arg"></param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using(System.Collections.IComparer)">
+            <summary>
+            Flag the constraint to use the supplied IComparer object.
+            </summary>
+            <param name="comparer">The IComparer object to use.</param>
+            <returns>Self.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
+            <summary>
+            Flag the constraint to use the supplied IComparer object.
+            </summary>
+            <param name="comparer">The IComparer object to use.</param>
+            <returns>Self.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using``1(System.Comparison{``0})">
+            <summary>
+            Flag the constraint to use the supplied Comparison object.
+            </summary>
+            <param name="comparer">The IComparer object to use.</param>
+            <returns>Self.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using(System.Collections.IEqualityComparer)">
+            <summary>
+            Flag the constraint to use the supplied IEqualityComparer object.
+            </summary>
+            <param name="comparer">The IComparer object to use.</param>
+            <returns>Self.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using``1(System.Collections.Generic.IEqualityComparer{``0})">
+            <summary>
+            Flag the constraint to use the supplied IEqualityComparer object.
+            </summary>
+            <param name="comparer">The IComparer object to use.</param>
+            <returns>Self.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.ItemsEqual(System.Object,System.Object)">
+            <summary>
+            Compares two collection members for equality
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Tally(System.Collections.IEnumerable)">
+            <summary>
+            Return a new CollectionTally for use in making tests
+            </summary>
+            <param name="c">The collection to be included in the tally</param>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.IgnoreCase">
+            <summary>
+            Flag the constraint to ignore case and return self.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.EmptyCollectionConstraint">
+            <summary>
+            EmptyCollectionConstraint tests whether a collection is empty. 
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EmptyCollectionConstraint.doMatch(System.Collections.IEnumerable)">
+            <summary>
+            Check that the collection is empty
+            </summary>
+            <param name="collection"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EmptyCollectionConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer"></param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.UniqueItemsConstraint">
+            <summary>
+            UniqueItemsConstraint tests whether all the items in a 
+            collection are unique.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.UniqueItemsConstraint.doMatch(System.Collections.IEnumerable)">
+            <summary>
+            Check that all items are unique.
+            </summary>
+            <param name="actual"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.UniqueItemsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write a description of this constraint to a MessageWriter
+            </summary>
+            <param name="writer"></param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.CollectionContainsConstraint">
+            <summary>
+            CollectionContainsConstraint is used to test whether a collection
+            contains an expected object as a member.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionContainsConstraint.#ctor(System.Object)">
+            <summary>
+            Construct a CollectionContainsConstraint
+            </summary>
+            <param name="expected"></param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionContainsConstraint.doMatch(System.Collections.IEnumerable)">
+            <summary>
+            Test whether the expected item is contained in the collection
+            </summary>
+            <param name="actual"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionContainsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write a descripton of the constraint to a MessageWriter
+            </summary>
+            <param name="writer"></param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.CollectionEquivalentConstraint">
+            <summary>
+            CollectionEquivalentCOnstraint is used to determine whether two
+            collections are equivalent.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionEquivalentConstraint.#ctor(System.Collections.IEnumerable)">
+            <summary>
+            Construct a CollectionEquivalentConstraint
+            </summary>
+            <param name="expected"></param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionEquivalentConstraint.doMatch(System.Collections.IEnumerable)">
+            <summary>
+            Test whether two collections are equivalent
+            </summary>
+            <param name="actual"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionEquivalentConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write a description of this constraint to a MessageWriter
+            </summary>
+            <param name="writer"></param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.CollectionSubsetConstraint">
+            <summary>
+            CollectionSubsetConstraint is used to determine whether
+            one collection is a subset of another
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionSubsetConstraint.#ctor(System.Collections.IEnumerable)">
+            <summary>
+            Construct a CollectionSubsetConstraint
+            </summary>
+            <param name="expected">The collection that the actual value is expected to be a subset of</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionSubsetConstraint.doMatch(System.Collections.IEnumerable)">
+            <summary>
+            Test whether the actual collection is a subset of 
+            the expected collection provided.
+            </summary>
+            <param name="actual"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionSubsetConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write a description of this constraint to a MessageWriter
+            </summary>
+            <param name="writer"></param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.CollectionOrderedConstraint">
+            <summary>
+            CollectionOrderedConstraint is used to test whether a collection is ordered.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.#ctor">
+            <summary>
+            Construct a CollectionOrderedConstraint
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.Using(System.Collections.IComparer)">
+            <summary>
+            Modifies the constraint to use an IComparer and returns self.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
+            <summary>
+            Modifies the constraint to use an IComparer&lt;T&gt; and returns self.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.Using``1(System.Comparison{``0})">
+            <summary>
+            Modifies the constraint to use a Comparison&lt;T&gt; and returns self.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.By(System.String)">
+            <summary>
+            Modifies the constraint to test ordering by the value of
+            a specified property and returns self.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.doMatch(System.Collections.IEnumerable)">
+            <summary>
+            Test whether the collection is ordered
+            </summary>
+            <param name="actual"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write a description of the constraint to a MessageWriter
+            </summary>
+            <param name="writer"></param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.GetStringRepresentation">
+            <summary>
+            Returns the string representation of the constraint.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.CollectionOrderedConstraint.Descending">
+            <summary>
+             If used performs a reverse comparison
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.CollectionTally">
+            <summary>
+            CollectionTally counts (tallies) the number of
+            occurences of each object in one or more enumerations.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionTally.#ctor(NUnit.Framework.Constraints.NUnitEqualityComparer,System.Collections.IEnumerable)">
+            <summary>
+            Construct a CollectionTally object from a comparer and a collection
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionTally.TryRemove(System.Object)">
+            <summary>
+            Try to remove an object from the tally
+            </summary>
+            <param name="o">The object to remove</param>
+            <returns>True if successful, false if the object was not found</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionTally.TryRemove(System.Collections.IEnumerable)">
+            <summary>
+            Try to remove a set of objects from the tally
+            </summary>
+            <param name="c">The objects to remove</param>
+            <returns>True if successful, false if any object was not found</returns>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.CollectionTally.Count">
+            <summary>
+            The number of objects remaining in the tally
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ComparisonAdapter">
+            <summary>
+            ComparisonAdapter class centralizes all comparisons of
+            values in NUnit, adapting to the use of any provided
+            IComparer, IComparer&lt;T&gt; or Comparison&lt;T&gt;
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.For(System.Collections.IComparer)">
+            <summary>
+            Returns a ComparisonAdapter that wraps an IComparer
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.For``1(System.Collections.Generic.IComparer{``0})">
+            <summary>
+            Returns a ComparisonAdapter that wraps an IComparer&lt;T&gt;
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.For``1(System.Comparison{``0})">
+            <summary>
+            Returns a ComparisonAdapter that wraps a Comparison&lt;T&gt;
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.Compare(System.Object,System.Object)">
+            <summary>
+            Compares two objects
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ComparisonAdapter.Default">
+            <summary>
+            Gets the default ComparisonAdapter, which wraps an
+            NUnitComparer object.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter.#ctor(System.Collections.IComparer)">
+            <summary>
+            Construct a ComparisonAdapter for an IComparer
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter.Compare(System.Object,System.Object)">
+            <summary>
+            Compares two objects
+            </summary>
+            <param name="expected"></param>
+            <param name="actual"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.DefaultComparisonAdapter.#ctor">
+            <summary>
+            Construct a default ComparisonAdapter
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter`1">
+            <summary>
+            ComparisonAdapter&lt;T&gt; extends ComparisonAdapter and
+            allows use of an IComparer&lt;T&gt; or Comparison&lt;T&gt;
+            to actually perform the comparison.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter`1.#ctor(System.Collections.Generic.IComparer{`0})">
+            <summary>
+            Construct a ComparisonAdapter for an IComparer&lt;T&gt;
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter`1.Compare(System.Object,System.Object)">
+            <summary>
+            Compare a Type T to an object
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparisonAdapterForComparison`1.#ctor(System.Comparison{`0})">
+            <summary>
+            Construct a ComparisonAdapter for a Comparison&lt;T&gt;
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparisonAdapterForComparison`1.Compare(System.Object,System.Object)">
+            <summary>
+            Compare a Type T to an object
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ComparisonConstraint">
+            <summary>
+            Abstract base class for constraints that compare values to
+            determine if one is greater than, equal to or less than
+            the other.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.expected">
+            <summary>
+            The value against which a comparison is to be made
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.ltOK">
+            <summary>
+            If true, less than returns success
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.eqOK">
+            <summary>
+            if true, equal returns success
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.gtOK">
+            <summary>
+            if true, greater than returns success
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.predicate">
+            <summary>
+            The predicate used as a part of the description
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.comparer">
+            <summary>
+            ComparisonAdapter to be used in making the comparison
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.#ctor(System.Object,System.Boolean,System.Boolean,System.Boolean,System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:ComparisonConstraint"/> class.
+            </summary>
+            <param name="value">The value against which to make a comparison.</param>
+            <param name="ltOK">if set to <c>true</c> less succeeds.</param>
+            <param name="eqOK">if set to <c>true</c> equal succeeds.</param>
+            <param name="gtOK">if set to <c>true</c> greater succeeds.</param>
+            <param name="predicate">String used in describing the constraint.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Using(System.Collections.IComparer)">
+            <summary>
+            Modifies the constraint to use an IComparer and returns self
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
+            <summary>
+            Modifies the constraint to use an IComparer&lt;T&gt; and returns self
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Using``1(System.Comparison{``0})">
+            <summary>
+            Modifies the constraint to use a Comparison&lt;T&gt; and returns self
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.GreaterThanConstraint">
+            <summary>
+            Tests whether a value is greater than the value supplied to its constructor
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.GreaterThanConstraint.#ctor(System.Object)">
+            <summary>
+            Initializes a new instance of the <see cref="T:GreaterThanConstraint"/> class.
+            </summary>
+            <param name="expected">The expected value.</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.GreaterThanOrEqualConstraint">
+            <summary>
+            Tests whether a value is greater than or equal to the value supplied to its constructor
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.GreaterThanOrEqualConstraint.#ctor(System.Object)">
+            <summary>
+            Initializes a new instance of the <see cref="T:GreaterThanOrEqualConstraint"/> class.
+            </summary>
+            <param name="expected">The expected value.</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.LessThanConstraint">
+            <summary>
+            Tests whether a value is less than the value supplied to its constructor
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.LessThanConstraint.#ctor(System.Object)">
+            <summary>
+            Initializes a new instance of the <see cref="T:LessThanConstraint"/> class.
+            </summary>
+            <param name="expected">The expected value.</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.LessThanOrEqualConstraint">
+            <summary>
+            Tests whether a value is less than or equal to the value supplied to its constructor
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.LessThanOrEqualConstraint.#ctor(System.Object)">
+            <summary>
+            Initializes a new instance of the <see cref="T:LessThanOrEqualConstraint"/> class.
+            </summary>
+            <param name="expected">The expected value.</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ActualValueDelegate">
+            <summary>
+            Delegate used to delay evaluation of the actual value
+            to be used in evaluating a constraint
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ConstraintBuilder">
+            <summary>
+            ConstraintBuilder maintains the stacks that are used in
+            processing a ConstraintExpression. An OperatorStack
+            is used to hold operators that are waiting for their
+            operands to be reognized. a ConstraintStack holds 
+            input constraints as well as the results of each
+            operator applied.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:ConstraintBuilder"/> class.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.Append(NUnit.Framework.Constraints.ConstraintOperator)">
+            <summary>
+            Appends the specified operator to the expression by first
+            reducing the operator stack and then pushing the new
+            operator on the stack.
+            </summary>
+            <param name="op">The operator to push.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.Append(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Appends the specified constraint to the expresson by pushing
+            it on the constraint stack.
+            </summary>
+            <param name="constraint">The constraint to push.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.SetTopOperatorRightContext(System.Object)">
+            <summary>
+            Sets the top operator right context.
+            </summary>
+            <param name="rightContext">The right context.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ReduceOperatorStack(System.Int32)">
+            <summary>
+            Reduces the operator stack until the topmost item
+            precedence is greater than or equal to the target precedence.
+            </summary>
+            <param name="targetPrecedence">The target precedence.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.Resolve">
+            <summary>
+            Resolves this instance, returning a Constraint. If the builder
+            is not currently in a resolvable state, an exception is thrown.
+            </summary>
+            <returns>The resolved constraint</returns>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.IsResolvable">
+            <summary>
+            Gets a value indicating whether this instance is resolvable.
+            </summary>
+            <value>
+               <c>true</c> if this instance is resolvable; otherwise, <c>false</c>.
+            </value>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack">
+            <summary>
+            OperatorStack is a type-safe stack for holding ConstraintOperators
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">
+            <summary>
+            Initializes a new instance of the <see cref="T:OperatorStack"/> class.
+            </summary>
+            <param name="builder">The builder.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Push(NUnit.Framework.Constraints.ConstraintOperator)">
+            <summary>
+            Pushes the specified operator onto the stack.
+            </summary>
+            <param name="op">The op.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Pop">
+            <summary>
+            Pops the topmost operator from the stack.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Empty">
+            <summary>
+            Gets a value indicating whether this <see cref="T:OpStack"/> is empty.
+            </summary>
+            <value><c>true</c> if empty; otherwise, <c>false</c>.</value>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Top">
+            <summary>
+            Gets the topmost operator without modifying the stack.
+            </summary>
+            <value>The top.</value>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack">
+            <summary>
+            ConstraintStack is a type-safe stack for holding Constraints
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">
+            <summary>
+            Initializes a new instance of the <see cref="T:ConstraintStack"/> class.
+            </summary>
+            <param name="builder">The builder.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Push(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Pushes the specified constraint. As a side effect,
+            the constraint's builder field is set to the 
+            ConstraintBuilder owning this stack.
+            </summary>
+            <param name="constraint">The constraint.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Pop">
+            <summary>
+            Pops this topmost constrait from the stack.
+            As a side effect, the constraint's builder
+            field is set to null.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Empty">
+            <summary>
+            Gets a value indicating whether this <see cref="T:ConstraintStack"/> is empty.
+            </summary>
+            <value><c>true</c> if empty; otherwise, <c>false</c>.</value>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Top">
+            <summary>
+            Gets the topmost constraint without modifying the stack.
+            </summary>
+            <value>The topmost constraint</value>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ConstraintExpression">
+            <summary>
+            ConstraintExpression represents a compound constraint in the 
+            process of being constructed from a series of syntactic elements.
+            
+            Individual elements are appended to the expression as they are
+            reognized. Once an actual Constraint is appended, the expression
+            returns a resolvable Constraint.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ConstraintExpressionBase">
+            <summary>
+            ConstraintExpressionBase is the abstract base class for the 
+            generated ConstraintExpression class, which represents a 
+            compound constraint in the process of being constructed 
+            from a series of syntactic elements.
+            
+            NOTE: ConstraintExpressionBase is aware of some of its
+            derived classes, which is an apparent violation of 
+            encapsulation. Ideally, these classes would be a 
+            single class, but they must be separated in order to
+            allow parts to be generated under .NET 1.x and to
+            provide proper user feedback in syntactically 
+            aware IDEs.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.ConstraintExpressionBase.builder">
+            <summary>
+            The ConstraintBuilder holding the elements recognized so far
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:ConstraintExpressionBase"/> class.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">
+            <summary>
+            Initializes a new instance of the <see cref="T:ConstraintExpressionBase"/> 
+            class passing in a ConstraintBuilder, which may be pre-populated.
+            </summary>
+            <param name="builder">The builder.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.ToString">
+            <summary>
+            Returns a string representation of the expression as it
+            currently stands. This should only be used for testing,
+            since it has the side-effect of resolving the expression.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.Append(NUnit.Framework.Constraints.ConstraintOperator)">
+            <summary>
+            Appends an operator to the expression and returns the
+            resulting expression itself.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.Append(NUnit.Framework.Constraints.SelfResolvingOperator)">
+            <summary>
+            Appends a self-resolving operator to the expression and
+            returns a new ResolvableConstraintExpression.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.Append(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Appends a constraint to the expression and returns that
+            constraint, which is associated with the current state
+            of the expression being built.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.#ctor">
+            <summary>
+            Initializes a new instance of the <see cref="T:ConstraintExpression"/> class.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">
+            <summary>
+            Initializes a new instance of the <see cref="T:ConstraintExpression"/> 
+            class passing in a ConstraintBuilder, which may be pre-populated.
+            </summary>
+            <param name="builder">The builder.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Property(System.String)">
+            <summary>
+            Returns a new PropertyConstraintExpression, which will either
+            test for the existence of the named property on the object
+            being tested or apply any following constraint to that property.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Attribute(System.Type)">
+            <summary>
+            Returns a new AttributeConstraint checking for the
+            presence of a particular attribute on an object.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Attribute``1">
+            <summary>
+            Returns a new AttributeConstraint checking for the
+            presence of a particular attribute on an object.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Matches(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Returns the constraint provided as an argument - used to allow custom
+            custom constraints to easily participate in the syntax.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Matches``1(System.Predicate{``0})">
+            <summary>
+            Returns the constraint provided as an argument - used to allow custom
+            custom constraints to easily participate in the syntax.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.EqualTo(System.Object)">
+            <summary>
+            Returns a constraint that tests two items for equality
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SameAs(System.Object)">
+            <summary>
+            Returns a constraint that tests that two references are the same object
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.GreaterThan(System.Object)">
+            <summary>
+            Returns a constraint that tests whether the
+            actual value is greater than the suppled argument
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.GreaterThanOrEqualTo(System.Object)">
+            <summary>
+            Returns a constraint that tests whether the
+            actual value is greater than or equal to the suppled argument
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AtLeast(System.Object)">
+            <summary>
+            Returns a constraint that tests whether the
+            actual value is greater than or equal to the suppled argument
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.LessThan(System.Object)">
+            <summary>
+            Returns a constraint that tests whether the
+            actual value is less than the suppled argument
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.LessThanOrEqualTo(System.Object)">
+            <summary>
+            Returns a constraint that tests whether the
+            actual value is less than or equal to the suppled argument
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AtMost(System.Object)">
+            <summary>
+            Returns a constraint that tests whether the
+            actual value is less than or equal to the suppled argument
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.TypeOf(System.Type)">
+            <summary>
+            Returns a constraint that tests whether the actual
+            value is of the exact type supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.TypeOf``1">
+            <summary>
+            Returns a constraint that tests whether the actual
+            value is of the exact type supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOf(System.Type)">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is of the type supplied as an argument or a derived type.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOf``1">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is of the type supplied as an argument or a derived type.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOfType(System.Type)">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is of the type supplied as an argument or a derived type.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOfType``1">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is of the type supplied as an argument or a derived type.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableFrom(System.Type)">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is assignable from the type supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableFrom``1">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is assignable from the type supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableTo(System.Type)">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is assignable from the type supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableTo``1">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is assignable from the type supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.EquivalentTo(System.Collections.IEnumerable)">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is a collection containing the same elements as the 
+            collection supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SubsetOf(System.Collections.IEnumerable)">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is a subset of the collection supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Member(System.Object)">
+            <summary>
+            Returns a new CollectionContainsConstraint checking for the
+            presence of a particular object in the collection.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Contains(System.Object)">
+            <summary>
+            Returns a new CollectionContainsConstraint checking for the
+            presence of a particular object in the collection.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Contains(System.String)">
+            <summary>
+            Returns a new ContainsConstraint. This constraint
+            will, in turn, make use of the appropriate second-level
+            constraint, depending on the type of the actual argument. 
+            This overload is only used if the item sought is a string,
+            since any other type implies that we are looking for a 
+            collection member.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringContaining(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value contains the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.ContainsSubstring(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value contains the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StartsWith(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value starts with the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringStarting(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value starts with the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.EndsWith(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value ends with the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringEnding(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value ends with the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Matches(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value matches the Regex pattern supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringMatching(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value matches the Regex pattern supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SamePath(System.String)">
+            <summary>
+            Returns a constraint that tests whether the path provided 
+            is the same as an expected path after canonicalization.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SubPath(System.String)">
+            <summary>
+            Returns a constraint that tests whether the path provided 
+            is the same path or under an expected path after canonicalization.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SamePathOrUnder(System.String)">
+            <summary>
+            Returns a constraint that tests whether the path provided 
+            is the same path or under an expected path after canonicalization.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InRange(System.IComparable,System.IComparable)">
+            <summary>
+            Returns a constraint that tests whether the actual value falls 
+            within a specified range.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Not">
+            <summary>
+            Returns a ConstraintExpression that negates any
+            following constraint.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.No">
+            <summary>
+            Returns a ConstraintExpression that negates any
+            following constraint.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.All">
+            <summary>
+            Returns a ConstraintExpression, which will apply
+            the following constraint to all members of a collection,
+            succeeding if all of them succeed.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Some">
+            <summary>
+            Returns a ConstraintExpression, which will apply
+            the following constraint to all members of a collection,
+            succeeding if at least one of them succeeds.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.None">
+            <summary>
+            Returns a ConstraintExpression, which will apply
+            the following constraint to all members of a collection,
+            succeeding if all of them fail.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Length">
+            <summary>
+            Returns a new ConstraintExpression, which will apply the following
+            constraint to the Length property of the object being tested.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Count">
+            <summary>
+            Returns a new ConstraintExpression, which will apply the following
+            constraint to the Count property of the object being tested.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Message">
+            <summary>
+            Returns a new ConstraintExpression, which will apply the following
+            constraint to the Message property of the object being tested.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.InnerException">
+            <summary>
+            Returns a new ConstraintExpression, which will apply the following
+            constraint to the InnerException property of the object being tested.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.With">
+            <summary>
+            With is currently a NOP - reserved for future use.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Null">
+            <summary>
+            Returns a constraint that tests for null
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.True">
+            <summary>
+            Returns a constraint that tests for True
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.False">
+            <summary>
+            Returns a constraint that tests for False
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.NaN">
+            <summary>
+            Returns a constraint that tests for NaN
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Empty">
+            <summary>
+            Returns a constraint that tests for empty
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Unique">
+            <summary>
+            Returns a constraint that tests whether a collection 
+            contains all unique items.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.BinarySerializable">
+            <summary>
+            Returns a constraint that tests whether an object graph is serializable in binary format.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.XmlSerializable">
+            <summary>
+            Returns a constraint that tests whether an object graph is serializable in xml format.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Ordered">
+            <summary>
+            Returns a constraint that tests whether a collection is ordered
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ConstraintFactory">
+            <summary>
+            Helper class with properties and methods that supply
+            a number of constraints used in Asserts.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Property(System.String)">
+            <summary>
+            Returns a new PropertyConstraintExpression, which will either
+            test for the existence of the named property on the object
+            being tested or apply any following constraint to that property.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Attribute(System.Type)">
+            <summary>
+            Returns a new AttributeConstraint checking for the
+            presence of a particular attribute on an object.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Attribute``1">
+            <summary>
+            Returns a new AttributeConstraint checking for the
+            presence of a particular attribute on an object.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.EqualTo(System.Object)">
+            <summary>
+            Returns a constraint that tests two items for equality
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SameAs(System.Object)">
+            <summary>
+            Returns a constraint that tests that two references are the same object
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.GreaterThan(System.Object)">
+            <summary>
+            Returns a constraint that tests whether the
+            actual value is greater than the suppled argument
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.GreaterThanOrEqualTo(System.Object)">
+            <summary>
+            Returns a constraint that tests whether the
+            actual value is greater than or equal to the suppled argument
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AtLeast(System.Object)">
+            <summary>
+            Returns a constraint that tests whether the
+            actual value is greater than or equal to the suppled argument
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.LessThan(System.Object)">
+            <summary>
+            Returns a constraint that tests whether the
+            actual value is less than the suppled argument
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.LessThanOrEqualTo(System.Object)">
+            <summary>
+            Returns a constraint that tests whether the
+            actual value is less than or equal to the suppled argument
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AtMost(System.Object)">
+            <summary>
+            Returns a constraint that tests whether the
+            actual value is less than or equal to the suppled argument
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.TypeOf(System.Type)">
+            <summary>
+            Returns a constraint that tests whether the actual
+            value is of the exact type supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.TypeOf``1">
+            <summary>
+            Returns a constraint that tests whether the actual
+            value is of the exact type supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOf(System.Type)">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is of the type supplied as an argument or a derived type.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOf``1">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is of the type supplied as an argument or a derived type.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOfType(System.Type)">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is of the type supplied as an argument or a derived type.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOfType``1">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is of the type supplied as an argument or a derived type.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableFrom(System.Type)">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is assignable from the type supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableFrom``1">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is assignable from the type supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableTo(System.Type)">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is assignable from the type supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableTo``1">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is assignable from the type supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.EquivalentTo(System.Collections.IEnumerable)">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is a collection containing the same elements as the 
+            collection supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SubsetOf(System.Collections.IEnumerable)">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is a subset of the collection supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Member(System.Object)">
+            <summary>
+            Returns a new CollectionContainsConstraint checking for the
+            presence of a particular object in the collection.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Contains(System.Object)">
+            <summary>
+            Returns a new CollectionContainsConstraint checking for the
+            presence of a particular object in the collection.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Contains(System.String)">
+            <summary>
+            Returns a new ContainsConstraint. This constraint
+            will, in turn, make use of the appropriate second-level
+            constraint, depending on the type of the actual argument. 
+            This overload is only used if the item sought is a string,
+            since any other type implies that we are looking for a 
+            collection member.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringContaining(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value contains the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.ContainsSubstring(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value contains the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotContain(System.String)">
+            <summary>
+            Returns a constraint that fails if the actual
+            value contains the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StartsWith(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value starts with the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringStarting(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value starts with the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotStartWith(System.String)">
+            <summary>
+            Returns a constraint that fails if the actual
+            value starts with the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.EndsWith(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value ends with the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringEnding(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value ends with the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotEndWith(System.String)">
+            <summary>
+            Returns a constraint that fails if the actual
+            value ends with the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Matches(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value matches the Regex pattern supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringMatching(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value matches the Regex pattern supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotMatch(System.String)">
+            <summary>
+            Returns a constraint that fails if the actual
+            value matches the pattern supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SamePath(System.String)">
+            <summary>
+            Returns a constraint that tests whether the path provided 
+            is the same as an expected path after canonicalization.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SubPath(System.String)">
+            <summary>
+            Returns a constraint that tests whether the path provided 
+            is the same path or under an expected path after canonicalization.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SamePathOrUnder(System.String)">
+            <summary>
+            Returns a constraint that tests whether the path provided 
+            is the same path or under an expected path after canonicalization.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InRange(System.IComparable,System.IComparable)">
+            <summary>
+            Returns a constraint that tests whether the actual value falls 
+            within a specified range.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Not">
+            <summary>
+            Returns a ConstraintExpression that negates any
+            following constraint.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.No">
+            <summary>
+            Returns a ConstraintExpression that negates any
+            following constraint.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.All">
+            <summary>
+            Returns a ConstraintExpression, which will apply
+            the following constraint to all members of a collection,
+            succeeding if all of them succeed.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Some">
+            <summary>
+            Returns a ConstraintExpression, which will apply
+            the following constraint to all members of a collection,
+            succeeding if at least one of them succeeds.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.None">
+            <summary>
+            Returns a ConstraintExpression, which will apply
+            the following constraint to all members of a collection,
+            succeeding if all of them fail.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Length">
+            <summary>
+            Returns a new ConstraintExpression, which will apply the following
+            constraint to the Length property of the object being tested.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Count">
+            <summary>
+            Returns a new ConstraintExpression, which will apply the following
+            constraint to the Count property of the object being tested.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Message">
+            <summary>
+            Returns a new ConstraintExpression, which will apply the following
+            constraint to the Message property of the object being tested.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.InnerException">
+            <summary>
+            Returns a new ConstraintExpression, which will apply the following
+            constraint to the InnerException property of the object being tested.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Null">
+            <summary>
+            Returns a constraint that tests for null
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.True">
+            <summary>
+            Returns a constraint that tests for True
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.False">
+            <summary>
+            Returns a constraint that tests for False
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.NaN">
+            <summary>
+            Returns a constraint that tests for NaN
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Empty">
+            <summary>
+            Returns a constraint that tests for empty
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Unique">
+            <summary>
+            Returns a constraint that tests whether a collection 
+            contains all unique items.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.BinarySerializable">
+            <summary>
+            Returns a constraint that tests whether an object graph is serializable in binary format.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.XmlSerializable">
+            <summary>
+            Returns a constraint that tests whether an object graph is serializable in xml format.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Ordered">
+            <summary>
+            Returns a constraint that tests whether a collection is ordered
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ConstraintOperator">
+            <summary>
+            The ConstraintOperator class is used internally by a
+            ConstraintBuilder to represent an operator that 
+            modifies or combines constraints. 
+            
+            Constraint operators use left and right precedence
+            values to determine whether the top operator on the
+            stack should be reduced before pushing a new operator.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.ConstraintOperator.left_precedence">
+            <summary>
+            The precedence value used when the operator
+            is about to be pushed to the stack.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.ConstraintOperator.right_precedence">
+            <summary>
+            The precedence value used when the operator
+            is on the top of the stack.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ConstraintOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
+            <summary>
+            Reduce produces a constraint from the operator and 
+            any arguments. It takes the arguments from the constraint 
+            stack and pushes the resulting constraint on it.
+            </summary>
+            <param name="stack"></param>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintOperator.LeftContext">
+            <summary>
+            The syntax element preceding this operator
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintOperator.RightContext">
+            <summary>
+            The syntax element folowing this operator
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintOperator.LeftPrecedence">
+            <summary>
+            The precedence value used when the operator
+            is about to be pushed to the stack.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintOperator.RightPrecedence">
+            <summary>
+            The precedence value used when the operator
+            is on the top of the stack.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.PrefixOperator">
+            <summary>
+            PrefixOperator takes a single constraint and modifies
+            it's action in some way.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PrefixOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
+            <summary>
+            Reduce produces a constraint from the operator and 
+            any arguments. It takes the arguments from the constraint 
+            stack and pushes the resulting constraint on it.
+            </summary>
+            <param name="stack"></param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PrefixOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Returns the constraint created by applying this
+            prefix to another constraint.
+            </summary>
+            <param name="constraint"></param>
+            <returns></returns>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.NotOperator">
+            <summary>
+            Negates the test of the constraint it wraps.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NotOperator.#ctor">
+            <summary>
+            Constructs a new NotOperator
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NotOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Returns a NotConstraint applied to its argument.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.CollectionOperator">
+            <summary>
+            Abstract base for operators that indicate how to
+            apply a constraint to items in a collection.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.CollectionOperator.#ctor">
+            <summary>
+            Constructs a CollectionOperator
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.AllOperator">
+            <summary>
+            Represents a constraint that succeeds if all the 
+            members of a collection match a base constraint.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AllOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Returns a constraint that will apply the argument
+            to the members of a collection, succeeding if
+            they all succeed.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.SomeOperator">
+            <summary>
+            Represents a constraint that succeeds if any of the 
+            members of a collection match a base constraint.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.SomeOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Returns a constraint that will apply the argument
+            to the members of a collection, succeeding if
+            any of them succeed.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.NoneOperator">
+            <summary>
+            Represents a constraint that succeeds if none of the 
+            members of a collection match a base constraint.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NoneOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Returns a constraint that will apply the argument
+            to the members of a collection, succeeding if
+            none of them succeed.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.WithOperator">
+            <summary>
+            Represents a constraint that simply wraps the
+            constraint provided as an argument, without any
+            further functionality, but which modifes the
+            order of evaluation because of its precedence.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.WithOperator.#ctor">
+            <summary>
+            Constructor for the WithOperator
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.WithOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Returns a constraint that wraps its argument
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.SelfResolvingOperator">
+            <summary>
+            Abstract base class for operators that are able to reduce to a 
+            constraint whether or not another syntactic element follows.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.PropOperator">
+            <summary>
+            Operator used to test for the presence of a named Property
+            on an object and optionally apply further tests to the
+            value of that property.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PropOperator.#ctor(System.String)">
+            <summary>
+            Constructs a PropOperator for a particular named property
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PropOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
+            <summary>
+            Reduce produces a constraint from the operator and 
+            any arguments. It takes the arguments from the constraint 
+            stack and pushes the resulting constraint on it.
+            </summary>
+            <param name="stack"></param>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.PropOperator.Name">
+            <summary>
+            Gets the name of the property to which the operator applies
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.AttributeOperator">
+            <summary>
+            Operator that tests for the presence of a particular attribute
+            on a type and optionally applies further tests to the attribute.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AttributeOperator.#ctor(System.Type)">
+            <summary>
+            Construct an AttributeOperator for a particular Type
+            </summary>
+            <param name="type">The Type of attribute tested</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AttributeOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
+            <summary>
+            Reduce produces a constraint from the operator and 
+            any arguments. It takes the arguments from the constraint 
+            stack and pushes the resulting constraint on it.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ThrowsOperator">
+            <summary>
+            Operator that tests that an exception is thrown and
+            optionally applies further tests to the exception.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ThrowsOperator.#ctor">
+            <summary>
+            Construct a ThrowsOperator
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ThrowsOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
+            <summary>
+            Reduce produces a constraint from the operator and 
+            any arguments. It takes the arguments from the constraint 
+            stack and pushes the resulting constraint on it.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.BinaryOperator">
+            <summary>
+            Abstract base class for all binary operators
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.BinaryOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
+            <summary>
+            Reduce produces a constraint from the operator and 
+            any arguments. It takes the arguments from the constraint 
+            stack and pushes the resulting constraint on it.
+            </summary>
+            <param name="stack"></param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.BinaryOperator.ApplyOperator(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Abstract method that produces a constraint by applying
+            the operator to its left and right constraint arguments.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.BinaryOperator.LeftPrecedence">
+            <summary>
+            Gets the left precedence of the operator
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.BinaryOperator.RightPrecedence">
+            <summary>
+            Gets the right precedence of the operator
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.AndOperator">
+            <summary>
+            Operator that requires both it's arguments to succeed
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AndOperator.#ctor">
+            <summary>
+            Construct an AndOperator
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AndOperator.ApplyOperator(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Apply the operator to produce an AndConstraint
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.OrOperator">
+            <summary>
+            Operator that requires at least one of it's arguments to succeed
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.OrOperator.#ctor">
+            <summary>
+            Construct an OrOperator
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.OrOperator.ApplyOperator(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Apply the operator to produce an OrConstraint
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ContainsConstraint">
+            <summary>
+            ContainsConstraint tests a whether a string contains a substring
+            or a collection contains an object. It postpones the decision of
+            which test to use until the type of the actual argument is known.
+            This allows testing whether a string is contained in a collection
+            or as a substring of another string using the same syntax.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ContainsConstraint.#ctor(System.Object)">
+            <summary>
+            Initializes a new instance of the <see cref="T:ContainsConstraint"/> class.
+            </summary>
+            <param name="expected">The expected.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ContainsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Using(System.Collections.IComparer)">
+            <summary>
+            Flag the constraint to use the supplied IComparer object.
+            </summary>
+            <param name="comparer">The IComparer object to use.</param>
+            <returns>Self.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
+            <summary>
+            Flag the constraint to use the supplied IComparer object.
+            </summary>
+            <param name="comparer">The IComparer object to use.</param>
+            <returns>Self.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Using``1(System.Comparison{``0})">
+            <summary>
+            Flag the constraint to use the supplied Comparison object.
+            </summary>
+            <param name="comparer">The IComparer object to use.</param>
+            <returns>Self.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Using(System.Collections.IEqualityComparer)">
+            <summary>
+            Flag the constraint to use the supplied IEqualityComparer object.
+            </summary>
+            <param name="comparer">The IComparer object to use.</param>
+            <returns>Self.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Using``1(System.Collections.Generic.IEqualityComparer{``0})">
+            <summary>
+            Flag the constraint to use the supplied IEqualityComparer object.
+            </summary>
+            <param name="comparer">The IComparer object to use.</param>
+            <returns>Self.</returns>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ContainsConstraint.IgnoreCase">
+            <summary>
+            Flag the constraint to ignore case and return self.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.DelayedConstraint">
+            <summary>
+             Applies a delay to the match so that a match can be evaluated in the future.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.DelayedConstraint.#ctor(NUnit.Framework.Constraints.Constraint,System.Int32)">
+            <summary>
+             Creates a new DelayedConstraint
+            </summary>
+            <param name="baseConstraint">The inner constraint two decorate</param>
+            <param name="delayInMilliseconds">The time interval after which the match is performed</param>
+            <exception cref="T:System.InvalidOperationException">If the value of <paramref name="delayInMilliseconds"/> is less than 0</exception>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.DelayedConstraint.#ctor(NUnit.Framework.Constraints.Constraint,System.Int32,System.Int32)">
+            <summary>
+             Creates a new DelayedConstraint
+            </summary>
+            <param name="baseConstraint">The inner constraint two decorate</param>
+            <param name="delayInMilliseconds">The time interval after which the match is performed</param>
+            <param name="pollingInterval">The time interval used for polling</param>
+            <exception cref="T:System.InvalidOperationException">If the value of <paramref name="delayInMilliseconds"/> is less than 0</exception>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.DelayedConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for if the base constraint fails, false if it succeeds</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.DelayedConstraint.Matches(NUnit.Framework.Constraints.ActualValueDelegate)">
+            <summary>
+            Test whether the constraint is satisfied by a delegate
+            </summary>
+            <param name="del">The delegate whose value is to be tested</param>
+            <returns>True for if the base constraint fails, false if it succeeds</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.DelayedConstraint.Matches``1(``0@)">
+            <summary>
+            Test whether the constraint is satisfied by a given reference.
+            Overridden to wait for the specified delay period before
+            calling the base constraint with the dereferenced value.
+            </summary>
+            <param name="actual">A reference to the value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.DelayedConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.DelayedConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the actual value for a failing constraint test to a MessageWriter.
+            </summary>
+            <param name="writer">The writer on which the actual value is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.DelayedConstraint.GetStringRepresentation">
+            <summary>
+            Returns the string representation of the constraint.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.EmptyDirectoryContraint">
+            <summary>
+            EmptyDirectoryConstraint is used to test that a directory is empty
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EmptyDirectoryContraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EmptyDirectoryContraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EmptyDirectoryContraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the actual value for a failing constraint test to a
+            MessageWriter. The default implementation simply writes
+            the raw value of actual, leaving it to the writer to
+            perform any formatting.
+            </summary>
+            <param name="writer">The writer on which the actual value is displayed</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.EmptyConstraint">
+            <summary>
+            EmptyConstraint tests a whether a string or collection is empty,
+            postponing the decision about which test is applied until the
+            type of the actual argument is known.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EmptyConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EmptyConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.EqualConstraint">
+            <summary>
+            EqualConstraint is able to compare an actual value with the
+            expected value provided in its constructor. Two objects are 
+            considered equal if both are null, or if both have the same 
+            value. NUnit has special semantics for some object types.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.EqualConstraint.clipStrings">
+            <summary>
+            If true, strings in error messages will be clipped
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.EqualConstraint.comparer">
+            <summary>
+            NUnitEqualityComparer used to test equality.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.#ctor(System.Object)">
+            <summary>
+            Initializes a new instance of the <see cref="T:NUnit.Framework.Constraints.EqualConstraint"/> class.
+            </summary>
+            <param name="expected">The expected value.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.Within(System.Object)">
+            <summary>
+            Flag the constraint to use a tolerance when determining equality.
+            </summary>
+            <param name="amount">Tolerance value to be used</param>
+            <returns>Self.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.Comparer(System.Collections.IComparer)">
+            <summary>
+            Flag the constraint to use the supplied IComparer object.
+            </summary>
+            <param name="comparer">The IComparer object to use.</param>
+            <returns>Self.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using(System.Collections.IComparer)">
+            <summary>
+            Flag the constraint to use the supplied IComparer object.
+            </summary>
+            <param name="comparer">The IComparer object to use.</param>
+            <returns>Self.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
+            <summary>
+            Flag the constraint to use the supplied IComparer object.
+            </summary>
+            <param name="comparer">The IComparer object to use.</param>
+            <returns>Self.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using``1(System.Comparison{``0})">
+            <summary>
+            Flag the constraint to use the supplied Comparison object.
+            </summary>
+            <param name="comparer">The IComparer object to use.</param>
+            <returns>Self.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using(System.Collections.IEqualityComparer)">
+            <summary>
+            Flag the constraint to use the supplied IEqualityComparer object.
+            </summary>
+            <param name="comparer">The IComparer object to use.</param>
+            <returns>Self.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using``1(System.Collections.Generic.IEqualityComparer{``0})">
+            <summary>
+            Flag the constraint to use the supplied IEqualityComparer object.
+            </summary>
+            <param name="comparer">The IComparer object to use.</param>
+            <returns>Self.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.WriteMessageTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write a failure message. Overridden to provide custom 
+            failure messages for EqualConstraint.
+            </summary>
+            <param name="writer">The MessageWriter to write to</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write description of this constraint
+            </summary>
+            <param name="writer">The MessageWriter to write to</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.DisplayCollectionDifferences(NUnit.Framework.Constraints.MessageWriter,System.Collections.ICollection,System.Collections.ICollection,System.Int32)">
+            <summary>
+            Display the failure information for two collections that did not match.
+            </summary>
+            <param name="writer">The MessageWriter on which to display</param>
+            <param name="expected">The expected collection.</param>
+            <param name="actual">The actual collection</param>
+            <param name="depth">The depth of this failure in a set of nested collections</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.DisplayCollectionTypesAndSizes(NUnit.Framework.Constraints.MessageWriter,System.Collections.ICollection,System.Collections.ICollection,System.Int32)">
+            <summary>
+            Displays a single line showing the types and sizes of the expected
+            and actual collections or arrays. If both are identical, the value is 
+            only shown once.
+            </summary>
+            <param name="writer">The MessageWriter on which to display</param>
+            <param name="expected">The expected collection or array</param>
+            <param name="actual">The actual collection or array</param>
+            <param name="indent">The indentation level for the message line</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualConstraint.DisplayFailurePoint(NUnit.Framework.Constraints.MessageWriter,System.Collections.ICollection,System.Collections.ICollection,System.Int32,System.Int32)">
+            <summary>
+            Displays a single line showing the point in the expected and actual
+            arrays at which the comparison failed. If the arrays have different
+            structures or dimensions, both values are shown.
+            </summary>
+            <param name="writer">The MessageWriter on which to display</param>
+            <param name="expected">The expected array</param>
+            <param name="actual">The actual array</param>
+            <param name="failurePoint">Index of the failure point in the underlying collections</param>
+            <param name="indent">The indentation level for the message line</param>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.IgnoreCase">
+            <summary>
+            Flag the constraint to ignore case and return self.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.NoClip">
+            <summary>
+            Flag the constraint to suppress string clipping 
+            and return self.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.AsCollection">
+            <summary>
+            Flag the constraint to compare arrays as collections
+            and return self.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.Ulps">
+            <summary>
+            Switches the .Within() modifier to interpret its tolerance as
+            a distance in representable values (see remarks).
+            </summary>
+            <returns>Self.</returns>
+            <remarks>
+            Ulp stands for "unit in the last place" and describes the minimum
+            amount a given value can change. For any integers, an ulp is 1 whole
+            digit. For floating point values, the accuracy of which is better
+            for smaller numbers and worse for larger numbers, an ulp depends
+            on the size of the number. Using ulps for comparison of floating
+            point results instead of fixed tolerances is safer because it will
+            automatically compensate for the added inaccuracy of larger numbers.
+            </remarks>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.Percent">
+            <summary>
+            Switches the .Within() modifier to interpret its tolerance as
+            a percentage that the actual values is allowed to deviate from
+            the expected value.
+            </summary>
+            <returns>Self</returns>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.Days">
+            <summary>
+            Causes the tolerance to be interpreted as a TimeSpan in days.
+            </summary>
+            <returns>Self</returns>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.Hours">
+            <summary>
+            Causes the tolerance to be interpreted as a TimeSpan in hours.
+            </summary>
+            <returns>Self</returns>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.Minutes">
+            <summary>
+            Causes the tolerance to be interpreted as a TimeSpan in minutes.
+            </summary>
+            <returns>Self</returns>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.Seconds">
+            <summary>
+            Causes the tolerance to be interpreted as a TimeSpan in seconds.
+            </summary>
+            <returns>Self</returns>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.Milliseconds">
+            <summary>
+            Causes the tolerance to be interpreted as a TimeSpan in milliseconds.
+            </summary>
+            <returns>Self</returns>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.EqualConstraint.Ticks">
+            <summary>
+            Causes the tolerance to be interpreted as a TimeSpan in clock ticks.
+            </summary>
+            <returns>Self</returns>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.EqualityAdapter">
+            <summary>
+            EqualityAdapter class handles all equality comparisons
+            that use an IEqualityComparer, IEqualityComparer&lt;T&gt;
+            or a ComparisonAdapter.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualityAdapter.ObjectsEqual(System.Object,System.Object)">
+            <summary>
+            Compares two objects, returning true if they are equal
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For(System.Collections.IComparer)">
+            <summary>
+            Returns an EqualityAdapter that wraps an IComparer.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For(System.Collections.IEqualityComparer)">
+            <summary>
+            Returns an EqualityAdapter that wraps an IEqualityComparer.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For``1(System.Collections.Generic.IEqualityComparer{``0})">
+            <summary>
+            Returns an EqualityAdapter that wraps an IEqualityComparer&lt;T&gt;.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For``1(System.Collections.Generic.IComparer{``0})">
+            <summary>
+            Returns an EqualityAdapter that wraps an IComparer&lt;T&gt;.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For``1(System.Comparison{``0})">
+            <summary>
+            Returns an EqualityAdapter that wraps a Comparison&lt;T&gt;.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.FloatingPointNumerics">
+            <summary>Helper routines for working with floating point numbers</summary>
+            <remarks>
+              <para>
+                The floating point comparison code is based on this excellent article:
+                http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm
+              </para>
+              <para>
+                "ULP" means Unit in the Last Place and in the context of this library refers to
+                the distance between two adjacent floating point numbers. IEEE floating point
+                numbers can only represent a finite subset of natural numbers, with greater
+                accuracy for smaller numbers and lower accuracy for very large numbers.
+              </para>
+              <para>
+                If a comparison is allowed "2 ulps" of deviation, that means the values are
+                allowed to deviate by up to 2 adjacent floating point values, which might be
+                as low as 0.0000001 for small numbers or as high as 10.0 for large numbers.
+              </para>
+            </remarks>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.AreAlmostEqualUlps(System.Single,System.Single,System.Int32)">
+            <summary>Compares two floating point values for equality</summary>
+            <param name="left">First floating point value to be compared</param>
+            <param name="right">Second floating point value t be compared</param>
+            <param name="maxUlps">
+              Maximum number of representable floating point values that are allowed to
+              be between the left and the right floating point values
+            </param>
+            <returns>True if both numbers are equal or close to being equal</returns>
+            <remarks>
+              <para>
+                Floating point values can only represent a finite subset of natural numbers.
+                For example, the values 2.00000000 and 2.00000024 can be stored in a float,
+                but nothing inbetween them.
+              </para>
+              <para>
+                This comparison will count how many possible floating point values are between
+                the left and the right number. If the number of possible values between both
+                numbers is less than or equal to maxUlps, then the numbers are considered as
+                being equal.
+              </para>
+              <para>
+                Implementation partially follows the code outlined here:
+                http://www.anttirt.net/2007/08/19/proper-floating-point-comparisons/
+              </para>
+            </remarks>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.AreAlmostEqualUlps(System.Double,System.Double,System.Int64)">
+            <summary>Compares two double precision floating point values for equality</summary>
+            <param name="left">First double precision floating point value to be compared</param>
+            <param name="right">Second double precision floating point value t be compared</param>
+            <param name="maxUlps">
+              Maximum number of representable double precision floating point values that are
+              allowed to be between the left and the right double precision floating point values
+            </param>
+            <returns>True if both numbers are equal or close to being equal</returns>
+            <remarks>
+              <para>
+                Double precision floating point values can only represent a limited series of
+                natural numbers. For example, the values 2.0000000000000000 and 2.0000000000000004
+                can be stored in a double, but nothing inbetween them.
+              </para>
+              <para>
+                This comparison will count how many possible double precision floating point
+                values are between the left and the right number. If the number of possible
+                values between both numbers is less than or equal to maxUlps, then the numbers
+                are considered as being equal.
+              </para>
+              <para>
+                Implementation partially follows the code outlined here:
+                http://www.anttirt.net/2007/08/19/proper-floating-point-comparisons/
+              </para>
+            </remarks>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsInt(System.Single)">
+            <summary>
+              Reinterprets the memory contents of a floating point value as an integer value
+            </summary>
+            <param name="value">
+              Floating point value whose memory contents to reinterpret
+            </param>
+            <returns>
+              The memory contents of the floating point value interpreted as an integer
+            </returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsLong(System.Double)">
+            <summary>
+              Reinterprets the memory contents of a double precision floating point
+              value as an integer value
+            </summary>
+            <param name="value">
+              Double precision floating point value whose memory contents to reinterpret
+            </param>
+            <returns>
+              The memory contents of the double precision floating point value
+              interpreted as an integer
+            </returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsFloat(System.Int32)">
+            <summary>
+              Reinterprets the memory contents of an integer as a floating point value
+            </summary>
+            <param name="value">Integer value whose memory contents to reinterpret</param>
+            <returns>
+              The memory contents of the integer value interpreted as a floating point value
+            </returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsDouble(System.Int64)">
+            <summary>
+              Reinterprets the memory contents of an integer value as a double precision
+              floating point value
+            </summary>
+            <param name="value">Integer whose memory contents to reinterpret</param>
+            <returns>
+              The memory contents of the integer interpreted as a double precision
+              floating point value
+            </returns>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion">
+            <summary>Union of a floating point variable and an integer</summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion.Float">
+            <summary>The union's value as a floating point variable</summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion.Int">
+            <summary>The union's value as an integer</summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion.UInt">
+            <summary>The union's value as an unsigned integer</summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion">
+            <summary>Union of a double precision floating point variable and a long</summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion.Double">
+            <summary>The union's value as a double precision floating point variable</summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion.Long">
+            <summary>The union's value as a long</summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion.ULong">
+            <summary>The union's value as an unsigned long</summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.MessageWriter">
+            <summary>
+            MessageWriter is the abstract base for classes that write
+            constraint descriptions and messages in some form. The
+            class has separate methods for writing various components
+            of a message, allowing implementations to tailor the
+            presentation as needed.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.#ctor">
+            <summary>
+            Construct a MessageWriter given a culture
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteMessageLine(System.String,System.Object[])">
+            <summary>
+            Method to write single line  message with optional args, usually
+            written to precede the general failure message.
+            </summary>
+            <param name="message">The message to be written</param>
+            <param name="args">Any arguments used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteMessageLine(System.Int32,System.String,System.Object[])">
+            <summary>
+            Method to write single line  message with optional args, usually
+            written to precede the general failure message, at a givel 
+            indentation level.
+            </summary>
+            <param name="level">The indentation level of the message</param>
+            <param name="message">The message to be written</param>
+            <param name="args">Any arguments used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayDifferences(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Display Expected and Actual lines for a constraint. This
+            is called by MessageWriter's default implementation of 
+            WriteMessageTo and provides the generic two-line display. 
+            </summary>
+            <param name="constraint">The constraint that failed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayDifferences(System.Object,System.Object)">
+            <summary>
+            Display Expected and Actual lines for given values. This
+            method may be called by constraints that need more control over
+            the display of actual and expected values than is provided
+            by the default implementation.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value causing the failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayDifferences(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance)">
+            <summary>
+            Display Expected and Actual lines for given values, including
+            a tolerance value on the Expected line.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value causing the failure</param>
+            <param name="tolerance">The tolerance within which the test was made</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayStringDifferences(System.String,System.String,System.Int32,System.Boolean,System.Boolean)">
+            <summary>
+            Display the expected and actual string values on separate lines.
+            If the mismatch parameter is >=0, an additional line is displayed
+            line containing a caret that points to the mismatch point.
+            </summary>
+            <param name="expected">The expected string value</param>
+            <param name="actual">The actual string value</param>
+            <param name="mismatch">The point at which the strings don't match or -1</param>
+            <param name="ignoreCase">If true, case is ignored in locating the point where the strings differ</param>
+            <param name="clipping">If true, the strings should be clipped to fit the line</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteConnector(System.String)">
+            <summary>
+            Writes the text for a connector.
+            </summary>
+            <param name="connector">The connector.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.WritePredicate(System.String)">
+            <summary>
+            Writes the text for a predicate.
+            </summary>
+            <param name="predicate">The predicate.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteExpectedValue(System.Object)">
+            <summary>
+            Writes the text for an expected value.
+            </summary>
+            <param name="expected">The expected value.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteModifier(System.String)">
+            <summary>
+            Writes the text for a modifier
+            </summary>
+            <param name="modifier">The modifier.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteActualValue(System.Object)">
+            <summary>
+            Writes the text for an actual value.
+            </summary>
+            <param name="actual">The actual value.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteValue(System.Object)">
+            <summary>
+            Writes the text for a generalized value.
+            </summary>
+            <param name="val">The value.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteCollectionElements(System.Collections.ICollection,System.Int32,System.Int32)">
+            <summary>
+            Writes the text for a collection value,
+            starting at a particular point, to a max length
+            </summary>
+            <param name="collection">The collection containing elements to write.</param>
+            <param name="start">The starting point of the elements to write</param>
+            <param name="max">The maximum number of elements to write</param>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.MessageWriter.MaxLineLength">
+            <summary>
+            Abstract method to get the max line length
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.MsgUtils">
+            <summary>
+            Static methods used in creating messages
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.MsgUtils.ELLIPSIS">
+            <summary>
+            Static string used when strings are clipped
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MsgUtils.GetTypeRepresentation(System.Object)">
+            <summary>
+            Returns the representation of a type as used in NUnitLite.
+            This is the same as Type.ToString() except for arrays,
+            which are displayed with their declared sizes.
+            </summary>
+            <param name="obj"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MsgUtils.EscapeControlChars(System.String)">
+            <summary>
+            Converts any control characters in a string 
+            to their escaped representation.
+            </summary>
+            <param name="s">The string to be converted</param>
+            <returns>The converted string</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MsgUtils.GetArrayIndicesAsString(System.Int32[])">
+            <summary>
+            Return the a string representation for a set of indices into an array
+            </summary>
+            <param name="indices">Array of indices for which a string is needed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MsgUtils.GetArrayIndicesFromCollectionIndex(System.Collections.ICollection,System.Int32)">
+            <summary>
+            Get an array of indices representing the point in a collection or
+            array corresponding to a single int index into the collection.
+            </summary>
+            <param name="collection">The collection to which the indices apply</param>
+            <param name="index">Index in the collection</param>
+            <returns>Array of indices</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MsgUtils.ClipString(System.String,System.Int32,System.Int32)">
+            <summary>
+            Clip a string to a given length, starting at a particular offset, returning the clipped
+            string with ellipses representing the removed parts
+            </summary>
+            <param name="s">The string to be clipped</param>
+            <param name="maxStringLength">The maximum permitted length of the result string</param>
+            <param name="clipStart">The point at which to start clipping</param>
+            <returns>The clipped string</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MsgUtils.ClipExpectedAndActual(System.String@,System.String@,System.Int32,System.Int32)">
+            <summary>
+            Clip the expected and actual strings in a coordinated fashion, 
+            so that they may be displayed together.
+            </summary>
+            <param name="expected"></param>
+            <param name="actual"></param>
+            <param name="maxDisplayLength"></param>
+            <param name="mismatch"></param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.MsgUtils.FindMismatchPosition(System.String,System.String,System.Int32,System.Boolean)">
+            <summary>
+            Shows the position two strings start to differ.  Comparison 
+            starts at the start index.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The actual string</param>
+            <param name="istart">The index in the strings at which comparison should start</param>
+            <param name="ignoreCase">Boolean indicating whether case should be ignored</param>
+            <returns>-1 if no mismatch found, or the index where mismatch found</returns>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.Numerics">
+            <summary>
+            The Numerics class contains common operations on numeric values.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Numerics.IsNumericType(System.Object)">
+            <summary>
+            Checks the type of the object, returning true if
+            the object is a numeric type.
+            </summary>
+            <param name="obj">The object to check</param>
+            <returns>true if the object is a numeric type</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Numerics.IsFloatingPointNumeric(System.Object)">
+            <summary>
+            Checks the type of the object, returning true if
+            the object is a floating point numeric type.
+            </summary>
+            <param name="obj">The object to check</param>
+            <returns>true if the object is a floating point numeric type</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Numerics.IsFixedPointNumeric(System.Object)">
+            <summary>
+            Checks the type of the object, returning true if
+            the object is a fixed point numeric type.
+            </summary>
+            <param name="obj">The object to check</param>
+            <returns>true if the object is a fixed point numeric type</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Numerics.AreEqual(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance@)">
+            <summary>
+            Test two numeric values for equality, performing the usual numeric 
+            conversions and using a provided or default tolerance. If the tolerance 
+            provided is Empty, this method may set it to a default tolerance.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="tolerance">A reference to the tolerance in effect</param>
+            <returns>True if the values are equal</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Numerics.Compare(System.Object,System.Object)">
+            <summary>
+            Compare two numeric values, performing the usual numeric conversions.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <returns>The relationship of the values to each other</returns>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.NUnitComparer">
+            <summary>
+            NUnitComparer encapsulates NUnit's default behavior
+            in comparing two objects.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NUnitComparer.Compare(System.Object,System.Object)">
+            <summary>
+            Compares two objects
+            </summary>
+            <param name="x"></param>
+            <param name="y"></param>
+            <returns></returns>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.NUnitComparer.Default">
+            <summary>
+            Returns the default NUnitComparer.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.NUnitEqualityComparer">
+            <summary>
+            NUnitEqualityComparer encapsulates NUnit's handling of
+            equality tests between objects.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.caseInsensitive">
+            <summary>
+            If true, all string comparisons will ignore case
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.compareAsCollection">
+            <summary>
+            If true, arrays will be treated as collections, allowing
+            those of different dimensions to be compared
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.tolerance">
+            <summary>
+            If non-zero, equality comparisons within the specified 
+            tolerance will succeed.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.externalComparer">
+            <summary>
+            Comparison object used in comparisons for some constraints.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NUnitEqualityComparer.ObjectsEqual(System.Object,System.Object)">
+            <summary>
+            Compares two objects for equality.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NUnitEqualityComparer.ArraysEqual(System.Array,System.Array)">
+            <summary>
+            Helper method to compare two arrays
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NUnitEqualityComparer.DirectoriesEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
+            <summary>
+            Method to compare two DirectoryInfo objects
+            </summary>
+            <param name="x">first directory to compare</param>
+            <param name="y">second directory to compare</param>
+            <returns>true if equivalent, false if not</returns>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.Default">
+            <summary>
+            Returns the default NUnitEqualityComparer
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.IgnoreCase">
+            <summary>
+            Gets and sets a flag indicating whether case should
+            be ignored in determining equality.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.CompareAsCollection">
+            <summary>
+            Gets and sets a flag indicating that arrays should be
+            compared as collections, without regard to their shape.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.ExternalComparer">
+            <summary>
+            Gets and sets an external comparer to be used to
+            test for equality. It is applied to members of
+            collections, in place of NUnit's own logic.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.Tolerance">
+            <summary>
+            Gets and sets a tolerance used to compare objects of 
+            certin types.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.FailurePoints">
+            <summary>
+            Gets the list of failure points for the last Match performed.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.PathConstraint">
+            <summary>
+            PathConstraint serves as the abstract base of constraints
+            that operate on paths and provides several helper methods.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.PathConstraint.expectedPath">
+            <summary>
+            The expected path used in the constraint
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.PathConstraint.actualPath">
+            <summary>
+            The actual path being tested
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.PathConstraint.caseInsensitive">
+            <summary>
+            Flag indicating whether a caseInsensitive comparison should be made
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PathConstraint.#ctor(System.String)">
+            <summary>
+            Construct a PathConstraint for a give expected path
+            </summary>
+            <param name="expected">The expected path</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PathConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PathConstraint.IsMatch(System.String,System.String)">
+            <summary>
+            Returns true if the expected path and actual path match
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PathConstraint.GetStringRepresentation">
+            <summary>
+            Returns the string representation of this constraint
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PathConstraint.Canonicalize(System.String)">
+            <summary>
+            Canonicalize the provided path
+            </summary>
+            <param name="path"></param>
+            <returns>The path in standardized form</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PathConstraint.IsSamePath(System.String,System.String,System.Boolean)">
+            <summary>
+            Test whether two paths are the same
+            </summary>
+            <param name="path1">The first path</param>
+            <param name="path2">The second path</param>
+            <param name="ignoreCase">Indicates whether case should be ignored</param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PathConstraint.IsSubPath(System.String,System.String,System.Boolean)">
+            <summary>
+            Test whether one path is under another path
+            </summary>
+            <param name="path1">The first path - supposed to be the parent path</param>
+            <param name="path2">The second path - supposed to be the child path</param>
+            <param name="ignoreCase">Indicates whether case should be ignored</param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PathConstraint.IsSamePathOrUnder(System.String,System.String)">
+            <summary>
+            Test whether one path is the same as or under another path
+            </summary>
+            <param name="path1">The first path - supposed to be the parent path</param>
+            <param name="path2">The second path - supposed to be the child path</param>
+            <returns></returns>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.PathConstraint.IgnoreCase">
+            <summary>
+            Modifies the current instance to be case-insensitve
+            and returns it.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.PathConstraint.RespectCase">
+            <summary>
+            Modifies the current instance to be case-sensitve
+            and returns it.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.SamePathConstraint">
+            <summary>
+            Summary description for SamePathConstraint.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.SamePathConstraint.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:SamePathConstraint"/> class.
+            </summary>
+            <param name="expected">The expected path</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.SamePathConstraint.IsMatch(System.String,System.String)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="expectedPath">The expected path</param>
+            <param name="actualPath">The actual path</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.SamePathConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.SubPathConstraint">
+            <summary>
+            SubPathConstraint tests that the actual path is under the expected path
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.SubPathConstraint.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:SubPathConstraint"/> class.
+            </summary>
+            <param name="expected">The expected path</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.SubPathConstraint.IsMatch(System.String,System.String)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="expectedPath">The expected path</param>
+            <param name="actualPath">The actual path</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.SubPathConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.SamePathOrUnderConstraint">
+            <summary>
+            SamePathOrUnderConstraint tests that one path is under another
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.SamePathOrUnderConstraint.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:SamePathOrUnderConstraint"/> class.
+            </summary>
+            <param name="expected">The expected path</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.SamePathOrUnderConstraint.IsMatch(System.String,System.String)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="expectedPath">The expected path</param>
+            <param name="actualPath">The actual path</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.SamePathOrUnderConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.PredicateConstraint`1">
+            <summary>
+            Predicate constraint wraps a Predicate in a constraint,
+            returning success if the predicate is true.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PredicateConstraint`1.#ctor(System.Predicate{`0})">
+            <summary>
+            Construct a PredicateConstraint from a predicate
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PredicateConstraint`1.Matches(System.Object)">
+            <summary>
+            Determines whether the predicate succeeds when applied
+            to the actual value.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PredicateConstraint`1.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Writes the description to a MessageWriter
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.NotConstraint">
+            <summary>
+            NotConstraint negates the effect of some other constraint
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NotConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Initializes a new instance of the <see cref="T:NotConstraint"/> class.
+            </summary>
+            <param name="baseConstraint">The base constraint to be negated.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NotConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for if the base constraint fails, false if it succeeds</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NotConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NotConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the actual value for a failing constraint test to a MessageWriter.
+            </summary>
+            <param name="writer">The writer on which the actual value is displayed</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.AllItemsConstraint">
+            <summary>
+            AllItemsConstraint applies another constraint to each
+            item in a collection, succeeding if they all succeed.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AllItemsConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Construct an AllItemsConstraint on top of an existing constraint
+            </summary>
+            <param name="itemConstraint"></param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AllItemsConstraint.Matches(System.Object)">
+            <summary>
+            Apply the item constraint to each item in the collection,
+            failing if any item fails.
+            </summary>
+            <param name="actual"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AllItemsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write a description of this constraint to a MessageWriter
+            </summary>
+            <param name="writer"></param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.SomeItemsConstraint">
+            <summary>
+            SomeItemsConstraint applies another constraint to each
+            item in a collection, succeeding if any of them succeeds.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.SomeItemsConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Construct a SomeItemsConstraint on top of an existing constraint
+            </summary>
+            <param name="itemConstraint"></param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.SomeItemsConstraint.Matches(System.Object)">
+            <summary>
+            Apply the item constraint to each item in the collection,
+            succeeding if any item succeeds.
+            </summary>
+            <param name="actual"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.SomeItemsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write a description of this constraint to a MessageWriter
+            </summary>
+            <param name="writer"></param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.NoItemConstraint">
+            <summary>
+            NoItemConstraint applies another constraint to each
+            item in a collection, failing if any of them succeeds.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NoItemConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Construct a SomeItemsConstraint on top of an existing constraint
+            </summary>
+            <param name="itemConstraint"></param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NoItemConstraint.Matches(System.Object)">
+            <summary>
+            Apply the item constraint to each item in the collection,
+            failing if any item fails.
+            </summary>
+            <param name="actual"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NoItemConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write a description of this constraint to a MessageWriter
+            </summary>
+            <param name="writer"></param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.PropertyExistsConstraint">
+            <summary>
+            PropertyExistsConstraint tests that a named property
+            exists on the object provided through Match.
+            
+            Originally, PropertyConstraint provided this feature
+            in addition to making optional tests on the vaue
+            of the property. The two constraints are now separate.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:PropertyExistConstraint"/> class.
+            </summary>
+            <param name="name">The name of the property.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the property exists for a given object
+            </summary>
+            <param name="actual">The object to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the actual value for a failing constraint test to a
+            MessageWriter.
+            </summary>
+            <param name="writer">The writer on which the actual value is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.GetStringRepresentation">
+            <summary>
+            Returns the string representation of the constraint.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.PropertyConstraint">
+            <summary>
+            PropertyConstraint extracts a named property and uses
+            its value as the actual value for a chained constraint.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PropertyConstraint.#ctor(System.String,NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Initializes a new instance of the <see cref="T:PropertyConstraint"/> class.
+            </summary>
+            <param name="name">The name.</param>
+            <param name="baseConstraint">The constraint to apply to the property.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PropertyConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PropertyConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PropertyConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the actual value for a failing constraint test to a
+            MessageWriter. The default implementation simply writes
+            the raw value of actual, leaving it to the writer to
+            perform any formatting.
+            </summary>
+            <param name="writer">The writer on which the actual value is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PropertyConstraint.GetStringRepresentation">
+            <summary>
+            Returns the string representation of the constraint.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.RangeConstraint">
+            <summary>
+            RangeConstraint tests whethe two values are within a 
+            specified range.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.RangeConstraint.#ctor(System.IComparable,System.IComparable)">
+            <summary>
+            Initializes a new instance of the <see cref="T:RangeConstraint"/> class.
+            </summary>
+            <param name="from">From.</param>
+            <param name="to">To.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.RangeConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.RangeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.RangeConstraint.Using(System.Collections.IComparer)">
+            <summary>
+            Modifies the constraint to use an IComparer and returns self.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.RangeConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
+            <summary>
+            Modifies the constraint to use an IComparer&lt;T&gt; and returns self.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.RangeConstraint.Using``1(System.Comparison{``0})">
+            <summary>
+            Modifies the constraint to use a Comparison&lt;T&gt; and returns self.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ResolvableConstraintExpression">
+            <summary>
+            ResolvableConstraintExpression is used to represent a compound
+            constraint being constructed at a point where the last operator
+            may either terminate the expression or may have additional 
+            qualifying constraints added to it. 
+            
+            It is used, for example, for a Property element or for
+            an Exception element, either of which may be optionally
+            followed by constraints that apply to the property or 
+            exception.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.#ctor">
+            <summary>
+            Create a new instance of ResolvableConstraintExpression
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">
+            <summary>
+            Create a new instance of ResolvableConstraintExpression,
+            passing in a pre-populated ConstraintBuilder.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.NUnit#Framework#Constraints#IResolveConstraint#Resolve">
+            <summary>
+            Resolve the current expression to a Constraint
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ResolvableConstraintExpression.And">
+            <summary>
+            Appends an And Operator to the expression
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ResolvableConstraintExpression.Or">
+            <summary>
+            Appends an Or operator to the expression.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ReusableConstraint">
+            <summary>
+            ReusableConstraint wraps a resolved constraint so that it
+            may be saved and reused as needed.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ReusableConstraint.#ctor(NUnit.Framework.Constraints.IResolveConstraint)">
+            <summary>
+            Construct a ReusableConstraint
+            </summary>
+            <param name="c">The constraint or expression to be reused</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ReusableConstraint.op_Implicit(NUnit.Framework.Constraints.Constraint)~NUnit.Framework.Constraints.ReusableConstraint">
+            <summary>
+            Conversion operator from a normal constraint to a ReusableConstraint.
+            </summary>
+            <param name="c">The original constraint to be wrapped as a ReusableConstraint</param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ReusableConstraint.ToString">
+            <summary>
+            Returns the string representation of the constraint.
+            </summary>
+            <returns>A string representing the constraint</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ReusableConstraint.Resolve">
+            <summary>
+            Resolves the ReusableConstraint by returning the constraint
+            that it originally wrapped.
+            </summary>
+            <returns>A resolved constraint</returns>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.SameAsConstraint">
+            <summary>
+            SameAsConstraint tests whether an object is identical to
+            the object passed to its constructor
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.SameAsConstraint.#ctor(System.Object)">
+            <summary>
+            Initializes a new instance of the <see cref="T:SameAsConstraint"/> class.
+            </summary>
+            <param name="expected">The expected object.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.SameAsConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.SameAsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.BinarySerializableConstraint">
+            <summary>
+            BinarySerializableConstraint tests whether 
+            an object is serializable in binary format.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the actual value for a failing constraint test to a
+            MessageWriter. The default implementation simply writes
+            the raw value of actual, leaving it to the writer to
+            perform any formatting.
+            </summary>
+            <param name="writer">The writer on which the actual value is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.GetStringRepresentation">
+            <summary>
+            Returns the string representation
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.XmlSerializableConstraint">
+            <summary>
+            BinarySerializableConstraint tests whether 
+            an object is serializable in binary format.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the actual value for a failing constraint test to a
+            MessageWriter. The default implementation simply writes
+            the raw value of actual, leaving it to the writer to
+            perform any formatting.
+            </summary>
+            <param name="writer">The writer on which the actual value is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.GetStringRepresentation">
+            <summary>
+            Returns the string representation of this constraint
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.StringConstraint">
+            <summary>
+            StringConstraint is the abstract base for constraints
+            that operate on strings. It supports the IgnoreCase
+            modifier for string operations.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.StringConstraint.expected">
+            <summary>
+            The expected value
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.StringConstraint.caseInsensitive">
+            <summary>
+            Indicates whether tests should be case-insensitive
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.StringConstraint.#ctor(System.String)">
+            <summary>
+            Constructs a StringConstraint given an expected value
+            </summary>
+            <param name="expected">The expected value</param>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.StringConstraint.IgnoreCase">
+            <summary>
+            Modify the constraint to ignore case in matching.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.EmptyStringConstraint">
+            <summary>
+            EmptyStringConstraint tests whether a string is empty.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EmptyStringConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EmptyStringConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.NullOrEmptyStringConstraint">
+            <summary>
+            NullEmptyStringConstraint tests whether a string is either null or empty.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NullOrEmptyStringConstraint.#ctor">
+            <summary>
+            Constructs a new NullOrEmptyStringConstraint
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NullOrEmptyStringConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NullOrEmptyStringConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.SubstringConstraint">
+            <summary>
+            SubstringConstraint can test whether a string contains
+            the expected substring.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.SubstringConstraint.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:SubstringConstraint"/> class.
+            </summary>
+            <param name="expected">The expected.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.SubstringConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.SubstringConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.StartsWithConstraint">
+            <summary>
+            StartsWithConstraint can test whether a string starts
+            with an expected substring.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.StartsWithConstraint.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:StartsWithConstraint"/> class.
+            </summary>
+            <param name="expected">The expected string</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.StartsWithConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is matched by the actual value.
+            This is a template method, which calls the IsMatch method
+            of the derived class.
+            </summary>
+            <param name="actual"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.StartsWithConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.EndsWithConstraint">
+            <summary>
+            EndsWithConstraint can test whether a string ends
+            with an expected substring.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EndsWithConstraint.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:EndsWithConstraint"/> class.
+            </summary>
+            <param name="expected">The expected string</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EndsWithConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is matched by the actual value.
+            This is a template method, which calls the IsMatch method
+            of the derived class.
+            </summary>
+            <param name="actual"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EndsWithConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.RegexConstraint">
+            <summary>
+            RegexConstraint can test whether a string matches
+            the pattern provided.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.RegexConstraint.#ctor(System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:RegexConstraint"/> class.
+            </summary>
+            <param name="pattern">The pattern.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.RegexConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.RegexConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ThrowsConstraint">
+            <summary>
+            ThrowsConstraint is used to test the exception thrown by 
+            a delegate by applying a constraint to it.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Initializes a new instance of the <see cref="T:ThrowsConstraint"/> class,
+            using a constraint to be applied to the exception.
+            </summary>
+            <param name="baseConstraint">A constraint to apply to the caught exception.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.Matches(System.Object)">
+            <summary>
+            Executes the code of the delegate and captures any exception.
+            If a non-null base constraint was provided, it applies that
+            constraint to the exception.
+            </summary>
+            <param name="actual">A delegate representing the code to be tested</param>
+            <returns>True if an exception is thrown and the constraint succeeds, otherwise false</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.Matches(NUnit.Framework.Constraints.ActualValueDelegate)">
+            <summary>
+            Converts an ActualValueDelegate to a TestDelegate
+            before calling the primary overload.
+            </summary>
+            <param name="del"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the actual value for a failing constraint test to a
+            MessageWriter. The default implementation simply writes
+            the raw value of actual, leaving it to the writer to
+            perform any formatting.
+            </summary>
+            <param name="writer">The writer on which the actual value is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.GetStringRepresentation">
+            <summary>
+            Returns the string representation of this constraint
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ThrowsConstraint.ActualException">
+            <summary>
+            Get the actual exception thrown - used by Assert.Throws.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ThrowsNothingConstraint">
+            <summary>
+            ThrowsNothingConstraint tests that a delegate does not
+            throw an exception.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.Matches(System.Object)">
+            <summary>
+            Test whether the constraint is satisfied by a given value
+            </summary>
+            <param name="actual">The value to be tested</param>
+            <returns>True if no exception is thrown, otherwise false</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.Matches(NUnit.Framework.Constraints.ActualValueDelegate)">
+            <summary>
+            Converts an ActualValueDelegate to a TestDelegate
+            before calling the primary overload.
+            </summary>
+            <param name="del"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the constraint description to a MessageWriter
+            </summary>
+            <param name="writer">The writer on which the description is displayed</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the actual value for a failing constraint test to a
+            MessageWriter. The default implementation simply writes
+            the raw value of actual, leaving it to the writer to
+            perform any formatting.
+            </summary>
+            <param name="writer">The writer on which the actual value is displayed</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ToleranceMode">
+            <summary>
+            Modes in which the tolerance value for a comparison can
+            be interpreted.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.ToleranceMode.None">
+            <summary>
+            The tolerance was created with a value, without specifying 
+            how the value would be used. This is used to prevent setting
+            the mode more than once and is generally changed to Linear
+            upon execution of the test.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.ToleranceMode.Linear">
+            <summary>
+            The tolerance is used as a numeric range within which
+            two compared values are considered to be equal.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.ToleranceMode.Percent">
+            <summary>
+            Interprets the tolerance as the percentage by which
+            the two compared values my deviate from each other.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.ToleranceMode.Ulps">
+            <summary>
+            Compares two values based in their distance in
+            representable numbers.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.Tolerance">
+            <summary>
+            The Tolerance class generalizes the notion of a tolerance
+            within which an equality test succeeds. Normally, it is
+            used with numeric types, but it can be used with any
+            type that supports taking a difference between two 
+            objects and comparing that difference to a value.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Tolerance.#ctor(System.Object)">
+            <summary>
+            Constructs a linear tolerance of a specdified amount
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Tolerance.#ctor(System.Object,NUnit.Framework.Constraints.ToleranceMode)">
+            <summary>
+            Constructs a tolerance given an amount and ToleranceMode
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.Tolerance.CheckLinearAndNumeric">
+            <summary>
+            Tests that the current Tolerance is linear with a 
+            numeric value, throwing an exception if it is not.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Empty">
+            <summary>
+            Returns an empty Tolerance object, equivalent to 
+            specifying an exact match.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Mode">
+            <summary>
+            Gets the ToleranceMode for the current Tolerance
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Value">
+            <summary>
+            Gets the value of the current Tolerance instance.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Percent">
+            <summary>
+            Returns a new tolerance, using the current amount as a percentage.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Ulps">
+            <summary>
+            Returns a new tolerance, using the current amount in Ulps.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Days">
+            <summary>
+            Returns a new tolerance with a TimeSpan as the amount, using 
+            the current amount as a number of days.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Hours">
+            <summary>
+            Returns a new tolerance with a TimeSpan as the amount, using 
+            the current amount as a number of hours.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Minutes">
+            <summary>
+            Returns a new tolerance with a TimeSpan as the amount, using 
+            the current amount as a number of minutes.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Seconds">
+            <summary>
+            Returns a new tolerance with a TimeSpan as the amount, using 
+            the current amount as a number of seconds.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Milliseconds">
+            <summary>
+            Returns a new tolerance with a TimeSpan as the amount, using 
+            the current amount as a number of milliseconds.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Ticks">
+            <summary>
+            Returns a new tolerance with a TimeSpan as the amount, using 
+            the current amount as a number of clock ticks.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.Tolerance.IsEmpty">
+            <summary>
+            Returns true if the current tolerance is empty.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.TypeConstraint">
+            <summary>
+            TypeConstraint is the abstract base for constraints
+            that take a Type as their expected value.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.TypeConstraint.expectedType">
+            <summary>
+            The expected Type used by the constraint
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.TypeConstraint.#ctor(System.Type)">
+            <summary>
+            Construct a TypeConstraint for a given Type
+            </summary>
+            <param name="type"></param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.TypeConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the actual value for a failing constraint test to a
+            MessageWriter. TypeConstraints override this method to write
+            the name of the type.
+            </summary>
+            <param name="writer">The writer on which the actual value is displayed</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ExactTypeConstraint">
+            <summary>
+            ExactTypeConstraint is used to test that an object
+            is of the exact type provided in the constructor
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ExactTypeConstraint.#ctor(System.Type)">
+            <summary>
+            Construct an ExactTypeConstraint for a given Type
+            </summary>
+            <param name="type">The expected Type.</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ExactTypeConstraint.Matches(System.Object)">
+            <summary>
+            Test that an object is of the exact type specified
+            </summary>
+            <param name="actual">The actual value.</param>
+            <returns>True if the tested object is of the exact type provided, otherwise false.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ExactTypeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the description of this constraint to a MessageWriter
+            </summary>
+            <param name="writer">The MessageWriter to use</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.InstanceOfTypeConstraint">
+            <summary>
+            InstanceOfTypeConstraint is used to test that an object
+            is of the same type provided or derived from it.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.InstanceOfTypeConstraint.#ctor(System.Type)">
+            <summary>
+            Construct an InstanceOfTypeConstraint for the type provided
+            </summary>
+            <param name="type">The expected Type</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.InstanceOfTypeConstraint.Matches(System.Object)">
+            <summary>
+            Test whether an object is of the specified type or a derived type
+            </summary>
+            <param name="actual">The object to be tested</param>
+            <returns>True if the object is of the provided type or derives from it, otherwise false.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.InstanceOfTypeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write a description of this constraint to a MessageWriter
+            </summary>
+            <param name="writer">The MessageWriter to use</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.AssignableFromConstraint">
+            <summary>
+            AssignableFromConstraint is used to test that an object
+            can be assigned from a given Type.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AssignableFromConstraint.#ctor(System.Type)">
+            <summary>
+            Construct an AssignableFromConstraint for the type provided
+            </summary>
+            <param name="type"></param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AssignableFromConstraint.Matches(System.Object)">
+            <summary>
+            Test whether an object can be assigned from the specified type
+            </summary>
+            <param name="actual">The object to be tested</param>
+            <returns>True if the object can be assigned a value of the expected Type, otherwise false.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AssignableFromConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write a description of this constraint to a MessageWriter
+            </summary>
+            <param name="writer">The MessageWriter to use</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.AssignableToConstraint">
+            <summary>
+            AssignableToConstraint is used to test that an object
+            can be assigned to a given Type.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AssignableToConstraint.#ctor(System.Type)">
+            <summary>
+            Construct an AssignableToConstraint for the type provided
+            </summary>
+            <param name="type"></param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AssignableToConstraint.Matches(System.Object)">
+            <summary>
+            Test whether an object can be assigned to the specified type
+            </summary>
+            <param name="actual">The object to be tested</param>
+            <returns>True if the object can be assigned a value of the expected Type, otherwise false.</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.AssignableToConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write a description of this constraint to a MessageWriter
+            </summary>
+            <param name="writer">The MessageWriter to use</param>
+        </member>
+        <member name="T:NUnit.Framework.AssertionException">
+            <summary>
+            Thrown when an assertion failed.
+            </summary>
+            
+        </member>
+        <member name="M:NUnit.Framework.AssertionException.#ctor(System.String)">
+            <param name="message">The error message that explains 
+            the reason for the exception</param>
+        </member>
+        <member name="M:NUnit.Framework.AssertionException.#ctor(System.String,System.Exception)">
+            <param name="message">The error message that explains 
+            the reason for the exception</param>
+            <param name="inner">The exception that caused the 
+            current exception</param>
+        </member>
+        <member name="M:NUnit.Framework.AssertionException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization Constructor
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.IgnoreException">
+            <summary>
+            Thrown when an assertion failed.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.IgnoreException.#ctor(System.String)">
+            <param name="message"></param>
+        </member>
+        <member name="M:NUnit.Framework.IgnoreException.#ctor(System.String,System.Exception)">
+            <param name="message">The error message that explains 
+            the reason for the exception</param>
+            <param name="inner">The exception that caused the 
+            current exception</param>
+        </member>
+        <member name="M:NUnit.Framework.IgnoreException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization Constructor
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.InconclusiveException">
+            <summary>
+            Thrown when a test executes inconclusively.
+            </summary>
+            
+        </member>
+        <member name="M:NUnit.Framework.InconclusiveException.#ctor(System.String)">
+            <param name="message">The error message that explains 
+            the reason for the exception</param>
+        </member>
+        <member name="M:NUnit.Framework.InconclusiveException.#ctor(System.String,System.Exception)">
+            <param name="message">The error message that explains 
+            the reason for the exception</param>
+            <param name="inner">The exception that caused the 
+            current exception</param>
+        </member>
+        <member name="M:NUnit.Framework.InconclusiveException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization Constructor
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.SuccessException">
+            <summary>
+            Thrown when an assertion failed.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.SuccessException.#ctor(System.String)">
+            <param name="message"></param>
+        </member>
+        <member name="M:NUnit.Framework.SuccessException.#ctor(System.String,System.Exception)">
+            <param name="message">The error message that explains 
+            the reason for the exception</param>
+            <param name="inner">The exception that caused the 
+            current exception</param>
+        </member>
+        <member name="M:NUnit.Framework.SuccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Serialization Constructor
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.TestDelegate">
+            <summary>
+            Delegate used by tests that execute code and
+            capture any thrown exception.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Assert">
+            <summary>
+            The Assert class contains a collection of static methods that
+            implement the most common assertions used in NUnit.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Assert.#ctor">
+            <summary>
+            We don't actually want any instances of this object, but some people
+            like to inherit from it to add other static methods. Hence, the
+            protected constructor disallows any instances of this object. 
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Equals(System.Object,System.Object)">
+            <summary>
+            The Equals method throws an AssertionException. This is done 
+            to make sure there is no mistake by calling this function.
+            </summary>
+            <param name="a"></param>
+            <param name="b"></param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.ReferenceEquals(System.Object,System.Object)">
+            <summary>
+            override the default ReferenceEquals to throw an AssertionException. This 
+            implementation makes sure there is no mistake in calling this function 
+            as part of Assert. 
+            </summary>
+            <param name="a"></param>
+            <param name="b"></param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AssertDoublesAreEqual(System.Double,System.Double,System.Double,System.String,System.Object[])">
+            <summary>
+            Helper for Assert.AreEqual(double expected, double actual, ...)
+            allowing code generation to work consistently.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="delta">The maximum acceptable difference between the
+            the expected and the actual</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Pass(System.String,System.Object[])">
+            <summary>
+            Throws a <see cref="T:NUnit.Framework.SuccessException"/> with the message and arguments 
+            that are passed in. This allows a test to be cut short, with a result
+            of success returned to NUnit.
+            </summary>
+            <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Pass(System.String)">
+            <summary>
+            Throws a <see cref="T:NUnit.Framework.SuccessException"/> with the message and arguments 
+            that are passed in. This allows a test to be cut short, with a result
+            of success returned to NUnit.
+            </summary>
+            <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Pass">
+            <summary>
+            Throws a <see cref="T:NUnit.Framework.SuccessException"/> with the message and arguments 
+            that are passed in. This allows a test to be cut short, with a result
+            of success returned to NUnit.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Fail(System.String,System.Object[])">
+            <summary>
+            Throws an <see cref="T:NUnit.Framework.AssertionException"/> with the message and arguments 
+            that are passed in. This is used by the other Assert functions. 
+            </summary>
+            <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Fail(System.String)">
+            <summary>
+            Throws an <see cref="T:NUnit.Framework.AssertionException"/> with the message that is 
+            passed in. This is used by the other Assert functions. 
+            </summary>
+            <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Fail">
+            <summary>
+            Throws an <see cref="T:NUnit.Framework.AssertionException"/>. 
+            This is used by the other Assert functions. 
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Ignore(System.String,System.Object[])">
+            <summary>
+            Throws an <see cref="T:NUnit.Framework.IgnoreException"/> with the message and arguments 
+            that are passed in.  This causes the test to be reported as ignored.
+            </summary>
+            <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Ignore(System.String)">
+            <summary>
+            Throws an <see cref="T:NUnit.Framework.IgnoreException"/> with the message that is 
+            passed in. This causes the test to be reported as ignored. 
+            </summary>
+            <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Ignore">
+            <summary>
+            Throws an <see cref="T:NUnit.Framework.IgnoreException"/>. 
+            This causes the test to be reported as ignored. 
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Inconclusive(System.String,System.Object[])">
+            <summary>
+            Throws an <see cref="T:NUnit.Framework.InconclusiveException"/> with the message and arguments 
+            that are passed in.  This causes the test to be reported as inconclusive.
+            </summary>
+            <param name="message">The message to initialize the <see cref="T:NUnit.Framework.InconclusiveException"/> with.</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Inconclusive(System.String)">
+            <summary>
+            Throws an <see cref="T:NUnit.Framework.InconclusiveException"/> with the message that is 
+            passed in. This causes the test to be reported as inconclusive. 
+            </summary>
+            <param name="message">The message to initialize the <see cref="T:NUnit.Framework.InconclusiveException"/> with.</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Inconclusive">
+            <summary>
+            Throws an <see cref="T:NUnit.Framework.InconclusiveException"/>. 
+            This causes the test to be reported as Inconclusive. 
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint)">
+            <summary>
+            Apply a constraint to an actual value, succeeding if the constraint
+            is satisfied and throwing an assertion exception on failure.
+            </summary>
+            <param name="expression">A Constraint to be applied</param>
+            <param name="actual">The actual value to test</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+            <summary>
+            Apply a constraint to an actual value, succeeding if the constraint
+            is satisfied and throwing an assertion exception on failure.
+            </summary>
+            <param name="expression">A Constraint to be applied</param>
+            <param name="actual">The actual value to test</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+            <summary>
+            Apply a constraint to an actual value, succeeding if the constraint
+            is satisfied and throwing an assertion exception on failure.
+            </summary>
+            <param name="expression">A Constraint expression to be applied</param>
+            <param name="actual">The actual value to test</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint)">
+            <summary>
+            Apply a constraint to an actual value, succeeding if the constraint
+            is satisfied and throwing an assertion exception on failure.
+            </summary>
+            <param name="expr">A Constraint expression to be applied</param>
+            <param name="del">An ActualValueDelegate returning the value to be tested</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+            <summary>
+            Apply a constraint to an actual value, succeeding if the constraint
+            is satisfied and throwing an assertion exception on failure.
+            </summary>
+            <param name="expr">A Constraint expression to be applied</param>
+            <param name="del">An ActualValueDelegate returning the value to be tested</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+            <summary>
+            Apply a constraint to an actual value, succeeding if the constraint
+            is satisfied and throwing an assertion exception on failure.
+            </summary>
+            <param name="del">An ActualValueDelegate returning the value to be tested</param>
+            <param name="expr">A Constraint expression to be applied</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint)">
+            <summary>
+            Apply a constraint to a referenced value, succeeding if the constraint
+            is satisfied and throwing an assertion exception on failure.
+            </summary>
+            <param name="expression">A Constraint to be applied</param>
+            <param name="actual">The actual value to test</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+            <summary>
+            Apply a constraint to a referenced value, succeeding if the constraint
+            is satisfied and throwing an assertion exception on failure.
+            </summary>
+            <param name="expression">A Constraint to be applied</param>
+            <param name="actual">The actual value to test</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+            <summary>
+            Apply a constraint to a referenced value, succeeding if the constraint
+            is satisfied and throwing an assertion exception on failure.
+            </summary>
+            <param name="expression">A Constraint to be applied</param>
+            <param name="actual">The actual value to test</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.That(System.Boolean,System.String,System.Object[])">
+            <summary>
+            Asserts that a condition is true. If the condition is false the method throws
+            an <see cref="T:NUnit.Framework.AssertionException"/>.
+            </summary> 
+            <param name="condition">The evaluated condition</param>
+            <param name="message">The message to display if the condition is false</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.That(System.Boolean,System.String)">
+            <summary>
+            Asserts that a condition is true. If the condition is false the method throws
+            an <see cref="T:NUnit.Framework.AssertionException"/>.
+            </summary>
+            <param name="condition">The evaluated condition</param>
+            <param name="message">The message to display if the condition is false</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.That(System.Boolean)">
+            <summary>
+            Asserts that a condition is true. If the condition is false the method throws
+            an <see cref="T:NUnit.Framework.AssertionException"/>.
+            </summary>
+            <param name="condition">The evaluated condition</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.That(NUnit.Framework.TestDelegate,NUnit.Framework.Constraints.IResolveConstraint)">
+            <summary>
+            Asserts that the code represented by a delegate throws an exception
+            that satisfies the constraint provided.
+            </summary>
+            <param name="code">A TestDelegate to be executed</param>
+            <param name="constraint">A ThrowsConstraint used in the test</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Throws(NUnit.Framework.Constraints.IResolveConstraint,NUnit.Framework.TestDelegate,System.String,System.Object[])">
+            <summary>
+            Verifies that a delegate throws a particular exception when called.
+            </summary>
+            <param name="expression">A constraint to be satisfied by the exception</param>
+            <param name="code">A TestSnippet delegate</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Throws(NUnit.Framework.Constraints.IResolveConstraint,NUnit.Framework.TestDelegate,System.String)">
+            <summary>
+            Verifies that a delegate throws a particular exception when called.
+            </summary>
+            <param name="expression">A constraint to be satisfied by the exception</param>
+            <param name="code">A TestSnippet delegate</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Throws(NUnit.Framework.Constraints.IResolveConstraint,NUnit.Framework.TestDelegate)">
+            <summary>
+            Verifies that a delegate throws a particular exception when called.
+            </summary>
+            <param name="expression">A constraint to be satisfied by the exception</param>
+            <param name="code">A TestSnippet delegate</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Throws(System.Type,NUnit.Framework.TestDelegate,System.String,System.Object[])">
+            <summary>
+            Verifies that a delegate throws a particular exception when called.
+            </summary>
+            <param name="expectedExceptionType">The exception Type expected</param>
+            <param name="code">A TestSnippet delegate</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Throws(System.Type,NUnit.Framework.TestDelegate,System.String)">
+            <summary>
+            Verifies that a delegate throws a particular exception when called.
+            </summary>
+            <param name="expectedExceptionType">The exception Type expected</param>
+            <param name="code">A TestSnippet delegate</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Throws(System.Type,NUnit.Framework.TestDelegate)">
+            <summary>
+            Verifies that a delegate throws a particular exception when called.
+            </summary>
+            <param name="expectedExceptionType">The exception Type expected</param>
+            <param name="code">A TestSnippet delegate</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Throws``1(NUnit.Framework.TestDelegate,System.String,System.Object[])">
+            <summary>
+            Verifies that a delegate throws a particular exception when called.
+            </summary>
+            <typeparam name="T">Type of the expected exception</typeparam>
+            <param name="code">A TestSnippet delegate</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Throws``1(NUnit.Framework.TestDelegate,System.String)">
+            <summary>
+            Verifies that a delegate throws a particular exception when called.
+            </summary>
+            <typeparam name="T">Type of the expected exception</typeparam>
+            <param name="code">A TestSnippet delegate</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Throws``1(NUnit.Framework.TestDelegate)">
+            <summary>
+            Verifies that a delegate throws a particular exception when called.
+            </summary>
+            <typeparam name="T">Type of the expected exception</typeparam>
+            <param name="code">A TestSnippet delegate</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Catch(NUnit.Framework.TestDelegate,System.String,System.Object[])">
+            <summary>
+            Verifies that a delegate throws an exception when called
+            and returns it.
+            </summary>
+            <param name="code">A TestDelegate</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Catch(NUnit.Framework.TestDelegate,System.String)">
+            <summary>
+            Verifies that a delegate throws an exception when called
+            and returns it.
+            </summary>
+            <param name="code">A TestDelegate</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Catch(NUnit.Framework.TestDelegate)">
+            <summary>
+            Verifies that a delegate throws an exception when called
+            and returns it.
+            </summary>
+            <param name="code">A TestDelegate</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Catch(System.Type,NUnit.Framework.TestDelegate,System.String,System.Object[])">
+            <summary>
+            Verifies that a delegate throws an exception of a certain Type
+            or one derived from it when called and returns it.
+            </summary>
+            <param name="expectedExceptionType">The expected Exception Type</param>
+            <param name="code">A TestDelegate</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Catch(System.Type,NUnit.Framework.TestDelegate,System.String)">
+            <summary>
+            Verifies that a delegate throws an exception of a certain Type
+            or one derived from it when called and returns it.
+            </summary>
+            <param name="expectedExceptionType">The expected Exception Type</param>
+            <param name="code">A TestDelegate</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Catch(System.Type,NUnit.Framework.TestDelegate)">
+            <summary>
+            Verifies that a delegate throws an exception of a certain Type
+            or one derived from it when called and returns it.
+            </summary>
+            <param name="expectedExceptionType">The expected Exception Type</param>
+            <param name="code">A TestDelegate</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Catch``1(NUnit.Framework.TestDelegate,System.String,System.Object[])">
+            <summary>
+            Verifies that a delegate throws an exception of a certain Type
+            or one derived from it when called and returns it.
+            </summary>
+            <typeparam name="T">The expected Exception Type</typeparam>
+            <param name="code">A TestDelegate</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Catch``1(NUnit.Framework.TestDelegate,System.String)">
+            <summary>
+            Verifies that a delegate throws an exception of a certain Type
+            or one derived from it when called and returns it.
+            </summary>
+            <typeparam name="T">The expected Exception Type</typeparam>
+            <param name="code">A TestDelegate</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Catch``1(NUnit.Framework.TestDelegate)">
+            <summary>
+            Verifies that a delegate throws an exception of a certain Type
+            or one derived from it when called and returns it.
+            </summary>
+            <typeparam name="T">The expected Exception Type</typeparam>
+            <param name="code">A TestDelegate</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.DoesNotThrow(NUnit.Framework.TestDelegate,System.String,System.Object[])">
+            <summary>
+            Verifies that a delegate does not throw an exception
+            </summary>
+            <param name="code">A TestSnippet delegate</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.DoesNotThrow(NUnit.Framework.TestDelegate,System.String)">
+            <summary>
+            Verifies that a delegate does not throw an exception.
+            </summary>
+            <param name="code">A TestSnippet delegate</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.DoesNotThrow(NUnit.Framework.TestDelegate)">
+            <summary>
+            Verifies that a delegate does not throw an exception.
+            </summary>
+            <param name="code">A TestSnippet delegate</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.True(System.Boolean,System.String,System.Object[])">
+            <summary>
+            Asserts that a condition is true. If the condition is false the method throws
+            an <see cref="T:NUnit.Framework.AssertionException"/>.
+            </summary>
+            <param name="condition">The evaluated condition</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.True(System.Boolean,System.String)">
+            <summary>
+            Asserts that a condition is true. If the condition is false the method throws
+            an <see cref="T:NUnit.Framework.AssertionException"/>.
+            </summary>
+            <param name="condition">The evaluated condition</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.True(System.Boolean)">
+            <summary>
+            Asserts that a condition is true. If the condition is false the method throws
+            an <see cref="T:NUnit.Framework.AssertionException"/>.
+            </summary>
+            <param name="condition">The evaluated condition</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsTrue(System.Boolean,System.String,System.Object[])">
+            <summary>
+            Asserts that a condition is true. If the condition is false the method throws
+            an <see cref="T:NUnit.Framework.AssertionException"/>.
+            </summary>
+            <param name="condition">The evaluated condition</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsTrue(System.Boolean,System.String)">
+            <summary>
+            Asserts that a condition is true. If the condition is false the method throws
+            an <see cref="T:NUnit.Framework.AssertionException"/>.
+            </summary>
+            <param name="condition">The evaluated condition</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsTrue(System.Boolean)">
+            <summary>
+            Asserts that a condition is true. If the condition is false the method throws
+            an <see cref="T:NUnit.Framework.AssertionException"/>.
+            </summary>
+            <param name="condition">The evaluated condition</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.False(System.Boolean,System.String,System.Object[])">
+            <summary>
+            Asserts that a condition is false. If the condition is true the method throws
+            an <see cref="T:NUnit.Framework.AssertionException"/>.
+            </summary> 
+            <param name="condition">The evaluated condition</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.False(System.Boolean,System.String)">
+            <summary>
+            Asserts that a condition is false. If the condition is true the method throws
+            an <see cref="T:NUnit.Framework.AssertionException"/>.
+            </summary> 
+            <param name="condition">The evaluated condition</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.False(System.Boolean)">
+            <summary>
+            Asserts that a condition is false. If the condition is true the method throws
+            an <see cref="T:NUnit.Framework.AssertionException"/>.
+            </summary> 
+            <param name="condition">The evaluated condition</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsFalse(System.Boolean,System.String,System.Object[])">
+            <summary>
+            Asserts that a condition is false. If the condition is true the method throws
+            an <see cref="T:NUnit.Framework.AssertionException"/>.
+            </summary> 
+            <param name="condition">The evaluated condition</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsFalse(System.Boolean,System.String)">
+            <summary>
+            Asserts that a condition is false. If the condition is true the method throws
+            an <see cref="T:NUnit.Framework.AssertionException"/>.
+            </summary> 
+            <param name="condition">The evaluated condition</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsFalse(System.Boolean)">
+            <summary>
+            Asserts that a condition is false. If the condition is true the method throws
+            an <see cref="T:NUnit.Framework.AssertionException"/>.
+            </summary> 
+            <param name="condition">The evaluated condition</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.NotNull(System.Object,System.String,System.Object[])">
+            <summary>
+            Verifies that the object that is passed in is not equal to <code>null</code>
+            If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+            is thrown.
+            </summary>
+            <param name="anObject">The object that is to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.NotNull(System.Object,System.String)">
+            <summary>
+            Verifies that the object that is passed in is not equal to <code>null</code>
+            If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+            is thrown.
+            </summary>
+            <param name="anObject">The object that is to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.NotNull(System.Object)">
+            <summary>
+            Verifies that the object that is passed in is not equal to <code>null</code>
+            If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+            is thrown.
+            </summary>
+            <param name="anObject">The object that is to be tested</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotNull(System.Object,System.String,System.Object[])">
+            <summary>
+            Verifies that the object that is passed in is not equal to <code>null</code>
+            If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+            is thrown.
+            </summary>
+            <param name="anObject">The object that is to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotNull(System.Object,System.String)">
+            <summary>
+            Verifies that the object that is passed in is not equal to <code>null</code>
+            If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+            is thrown.
+            </summary>
+            <param name="anObject">The object that is to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotNull(System.Object)">
+            <summary>
+            Verifies that the object that is passed in is not equal to <code>null</code>
+            If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+            is thrown.
+            </summary>
+            <param name="anObject">The object that is to be tested</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Null(System.Object,System.String,System.Object[])">
+            <summary>
+            Verifies that the object that is passed in is equal to <code>null</code>
+            If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+            is thrown.
+            </summary>
+            <param name="anObject">The object that is to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Null(System.Object,System.String)">
+            <summary>
+            Verifies that the object that is passed in is equal to <code>null</code>
+            If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+            is thrown.
+            </summary>
+            <param name="anObject">The object that is to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Null(System.Object)">
+            <summary>
+            Verifies that the object that is passed in is equal to <code>null</code>
+            If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+            is thrown.
+            </summary>
+            <param name="anObject">The object that is to be tested</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNull(System.Object,System.String,System.Object[])">
+            <summary>
+            Verifies that the object that is passed in is equal to <code>null</code>
+            If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+            is thrown.
+            </summary>
+            <param name="anObject">The object that is to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNull(System.Object,System.String)">
+            <summary>
+            Verifies that the object that is passed in is equal to <code>null</code>
+            If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+            is thrown.
+            </summary>
+            <param name="anObject">The object that is to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNull(System.Object)">
+            <summary>
+            Verifies that the object that is passed in is equal to <code>null</code>
+            If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+            is thrown.
+            </summary>
+            <param name="anObject">The object that is to be tested</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNaN(System.Double,System.String,System.Object[])">
+            <summary>
+            Verifies that the double that is passed in is an <code>NaN</code> value.
+            If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+            is thrown.
+            </summary>
+            <param name="aDouble">The value that is to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNaN(System.Double,System.String)">
+            <summary>
+            Verifies that the double that is passed in is an <code>NaN</code> value.
+            If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+            is thrown.
+            </summary>
+            <param name="aDouble">The value that is to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNaN(System.Double)">
+            <summary>
+            Verifies that the double that is passed in is an <code>NaN</code> value.
+            If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+            is thrown.
+            </summary>
+            <param name="aDouble">The value that is to be tested</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNaN(System.Nullable{System.Double},System.String,System.Object[])">
+            <summary>
+            Verifies that the double that is passed in is an <code>NaN</code> value.
+            If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+            is thrown.
+            </summary>
+            <param name="aDouble">The value that is to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNaN(System.Nullable{System.Double},System.String)">
+            <summary>
+            Verifies that the double that is passed in is an <code>NaN</code> value.
+            If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+            is thrown.
+            </summary>
+            <param name="aDouble">The value that is to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNaN(System.Nullable{System.Double})">
+            <summary>
+            Verifies that the double that is passed in is an <code>NaN</code> value.
+            If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+            is thrown.
+            </summary>
+            <param name="aDouble">The value that is to be tested</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsEmpty(System.String,System.String,System.Object[])">
+            <summary>
+            Assert that a string is empty - that is equal to string.Empty
+            </summary>
+            <param name="aString">The string to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsEmpty(System.String,System.String)">
+            <summary>
+            Assert that a string is empty - that is equal to string.Empty
+            </summary>
+            <param name="aString">The string to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsEmpty(System.String)">
+            <summary>
+            Assert that a string is empty - that is equal to string.Empty
+            </summary>
+            <param name="aString">The string to be tested</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsEmpty(System.Collections.ICollection,System.String,System.Object[])">
+            <summary>
+            Assert that an array, list or other collection is empty
+            </summary>
+            <param name="collection">An array, list or other collection implementing ICollection</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsEmpty(System.Collections.ICollection,System.String)">
+            <summary>
+            Assert that an array, list or other collection is empty
+            </summary>
+            <param name="collection">An array, list or other collection implementing ICollection</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsEmpty(System.Collections.ICollection)">
+            <summary>
+            Assert that an array, list or other collection is empty
+            </summary>
+            <param name="collection">An array, list or other collection implementing ICollection</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.String,System.String,System.Object[])">
+            <summary>
+            Assert that a string is not empty - that is not equal to string.Empty
+            </summary>
+            <param name="aString">The string to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.String,System.String)">
+            <summary>
+            Assert that a string is not empty - that is not equal to string.Empty
+            </summary>
+            <param name="aString">The string to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.String)">
+            <summary>
+            Assert that a string is not empty - that is not equal to string.Empty
+            </summary>
+            <param name="aString">The string to be tested</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.Collections.ICollection,System.String,System.Object[])">
+            <summary>
+            Assert that an array, list or other collection is not empty
+            </summary>
+            <param name="collection">An array, list or other collection implementing ICollection</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.Collections.ICollection,System.String)">
+            <summary>
+            Assert that an array, list or other collection is not empty
+            </summary>
+            <param name="collection">An array, list or other collection implementing ICollection</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.Collections.ICollection)">
+            <summary>
+            Assert that an array, list or other collection is not empty
+            </summary>
+            <param name="collection">An array, list or other collection implementing ICollection</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNullOrEmpty(System.String,System.String,System.Object[])">
+            <summary>
+            Assert that a string is either null or equal to string.Empty
+            </summary>
+            <param name="aString">The string to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNullOrEmpty(System.String,System.String)">
+            <summary>
+            Assert that a string is either null or equal to string.Empty
+            </summary>
+            <param name="aString">The string to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNullOrEmpty(System.String)">
+            <summary>
+            Assert that a string is either null or equal to string.Empty
+            </summary>
+            <param name="aString">The string to be tested</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotNullOrEmpty(System.String,System.String,System.Object[])">
+            <summary>
+            Assert that a string is not null or empty
+            </summary>
+            <param name="aString">The string to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotNullOrEmpty(System.String,System.String)">
+            <summary>
+            Assert that a string is not null or empty
+            </summary>
+            <param name="aString">The string to be tested</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotNullOrEmpty(System.String)">
+            <summary>
+            Assert that a string is not null or empty
+            </summary>
+            <param name="aString">The string to be tested</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsAssignableFrom(System.Type,System.Object,System.String,System.Object[])">
+            <summary>
+            Asserts that an object may be assigned a  value of a given Type.
+            </summary>
+            <param name="expected">The expected Type.</param>
+            <param name="actual">The object under examination</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsAssignableFrom(System.Type,System.Object,System.String)">
+            <summary>
+            Asserts that an object may be assigned a  value of a given Type.
+            </summary>
+            <param name="expected">The expected Type.</param>
+            <param name="actual">The object under examination</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsAssignableFrom(System.Type,System.Object)">
+            <summary>
+            Asserts that an object may be assigned a  value of a given Type.
+            </summary>
+            <param name="expected">The expected Type.</param>
+            <param name="actual">The object under examination</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsAssignableFrom``1(System.Object,System.String,System.Object[])">
+            <summary>
+            Asserts that an object may be assigned a  value of a given Type.
+            </summary>
+            <typeparam name="T">The expected Type.</typeparam>
+            <param name="actual">The object under examination</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsAssignableFrom``1(System.Object,System.String)">
+            <summary>
+            Asserts that an object may be assigned a  value of a given Type.
+            </summary>
+            <typeparam name="T">The expected Type.</typeparam>
+            <param name="actual">The object under examination</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsAssignableFrom``1(System.Object)">
+            <summary>
+            Asserts that an object may be assigned a  value of a given Type.
+            </summary>
+            <typeparam name="T">The expected Type.</typeparam>
+            <param name="actual">The object under examination</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom(System.Type,System.Object,System.String,System.Object[])">
+            <summary>
+            Asserts that an object may not be assigned a  value of a given Type.
+            </summary>
+            <param name="expected">The expected Type.</param>
+            <param name="actual">The object under examination</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom(System.Type,System.Object,System.String)">
+            <summary>
+            Asserts that an object may not be assigned a  value of a given Type.
+            </summary>
+            <param name="expected">The expected Type.</param>
+            <param name="actual">The object under examination</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom(System.Type,System.Object)">
+            <summary>
+            Asserts that an object may not be assigned a  value of a given Type.
+            </summary>
+            <param name="expected">The expected Type.</param>
+            <param name="actual">The object under examination</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom``1(System.Object,System.String,System.Object[])">
+            <summary>
+            Asserts that an object may not be assigned a  value of a given Type.
+            </summary>
+            <typeparam name="T">The expected Type.</typeparam>
+            <param name="actual">The object under examination</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom``1(System.Object,System.String)">
+            <summary>
+            Asserts that an object may not be assigned a  value of a given Type.
+            </summary>
+            <typeparam name="T">The expected Type.</typeparam>
+            <param name="actual">The object under examination</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom``1(System.Object)">
+            <summary>
+            Asserts that an object may not be assigned a  value of a given Type.
+            </summary>
+            <typeparam name="T">The expected Type.</typeparam>
+            <param name="actual">The object under examination</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsInstanceOf(System.Type,System.Object,System.String,System.Object[])">
+            <summary>
+            Asserts that an object is an instance of a given type.
+            </summary>
+            <param name="expected">The expected Type</param>
+            <param name="actual">The object being examined</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsInstanceOf(System.Type,System.Object,System.String)">
+            <summary>
+            Asserts that an object is an instance of a given type.
+            </summary>
+            <param name="expected">The expected Type</param>
+            <param name="actual">The object being examined</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsInstanceOf(System.Type,System.Object)">
+            <summary>
+            Asserts that an object is an instance of a given type.
+            </summary>
+            <param name="expected">The expected Type</param>
+            <param name="actual">The object being examined</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsInstanceOfType(System.Type,System.Object,System.String,System.Object[])">
+            <summary>
+            Asserts that an object is an instance of a given type.
+            </summary>
+            <param name="expected">The expected Type</param>
+            <param name="actual">The object being examined</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsInstanceOfType(System.Type,System.Object,System.String)">
+            <summary>
+            Asserts that an object is an instance of a given type.
+            </summary>
+            <param name="expected">The expected Type</param>
+            <param name="actual">The object being examined</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsInstanceOfType(System.Type,System.Object)">
+            <summary>
+            Asserts that an object is an instance of a given type.
+            </summary>
+            <param name="expected">The expected Type</param>
+            <param name="actual">The object being examined</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsInstanceOf``1(System.Object,System.String,System.Object[])">
+            <summary>
+            Asserts that an object is an instance of a given type.
+            </summary>
+            <typeparam name="T">The expected Type</typeparam>
+            <param name="actual">The object being examined</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsInstanceOf``1(System.Object,System.String)">
+            <summary>
+            Asserts that an object is an instance of a given type.
+            </summary>
+            <typeparam name="T">The expected Type</typeparam>
+            <param name="actual">The object being examined</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsInstanceOf``1(System.Object)">
+            <summary>
+            Asserts that an object is an instance of a given type.
+            </summary>
+            <typeparam name="T">The expected Type</typeparam>
+            <param name="actual">The object being examined</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotInstanceOf(System.Type,System.Object,System.String,System.Object[])">
+            <summary>
+            Asserts that an object is not an instance of a given type.
+            </summary>
+            <param name="expected">The expected Type</param>
+            <param name="actual">The object being examined</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotInstanceOf(System.Type,System.Object,System.String)">
+            <summary>
+            Asserts that an object is not an instance of a given type.
+            </summary>
+            <param name="expected">The expected Type</param>
+            <param name="actual">The object being examined</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotInstanceOf(System.Type,System.Object)">
+            <summary>
+            Asserts that an object is not an instance of a given type.
+            </summary>
+            <param name="expected">The expected Type</param>
+            <param name="actual">The object being examined</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotInstanceOfType(System.Type,System.Object,System.String,System.Object[])">
+            <summary>
+            Asserts that an object is not an instance of a given type.
+            </summary>
+            <param name="expected">The expected Type</param>
+            <param name="actual">The object being examined</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotInstanceOfType(System.Type,System.Object,System.String)">
+            <summary>
+            Asserts that an object is not an instance of a given type.
+            </summary>
+            <param name="expected">The expected Type</param>
+            <param name="actual">The object being examined</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotInstanceOfType(System.Type,System.Object)">
+            <summary>
+            Asserts that an object is not an instance of a given type.
+            </summary>
+            <param name="expected">The expected Type</param>
+            <param name="actual">The object being examined</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotInstanceOf``1(System.Object,System.String,System.Object[])">
+            <summary>
+            Asserts that an object is not an instance of a given type.
+            </summary>
+            <typeparam name="T">The expected Type</typeparam>
+            <param name="actual">The object being examined</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotInstanceOf``1(System.Object,System.String)">
+            <summary>
+            Asserts that an object is not an instance of a given type.
+            </summary>
+            <typeparam name="T">The expected Type</typeparam>
+            <param name="actual">The object being examined</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.IsNotInstanceOf``1(System.Object)">
+            <summary>
+            Asserts that an object is not an instance of a given type.
+            </summary>
+            <typeparam name="T">The expected Type</typeparam>
+            <param name="actual">The object being examined</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.Int32,System.Int32,System.String,System.Object[])">
+            <summary>
+            Verifies that two values are equal. If they are not, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.Int32,System.Int32,System.String)">
+            <summary>
+            Verifies that two values are equal. If they are not, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.Int32,System.Int32)">
+            <summary>
+            Verifies that two values are equal. If they are not, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.Int64,System.Int64,System.String,System.Object[])">
+            <summary>
+            Verifies that two values are equal. If they are not, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.Int64,System.Int64,System.String)">
+            <summary>
+            Verifies that two values are equal. If they are not, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.Int64,System.Int64)">
+            <summary>
+            Verifies that two values are equal. If they are not, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt32,System.UInt32,System.String,System.Object[])">
+            <summary>
+            Verifies that two values are equal. If they are not, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt32,System.UInt32,System.String)">
+            <summary>
+            Verifies that two values are equal. If they are not, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt32,System.UInt32)">
+            <summary>
+            Verifies that two values are equal. If they are not, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt64,System.UInt64,System.String,System.Object[])">
+            <summary>
+            Verifies that two values are equal. If they are not, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt64,System.UInt64,System.String)">
+            <summary>
+            Verifies that two values are equal. If they are not, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt64,System.UInt64)">
+            <summary>
+            Verifies that two values are equal. If they are not, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.Decimal,System.Decimal,System.String,System.Object[])">
+            <summary>
+            Verifies that two values are equal. If they are not, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.Decimal,System.Decimal,System.String)">
+            <summary>
+            Verifies that two values are equal. If they are not, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.Decimal,System.Decimal)">
+            <summary>
+            Verifies that two values are equal. If they are not, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Double,System.Double,System.String,System.Object[])">
+            <summary>
+            Verifies that two doubles are equal considering a delta. If the
+            expected value is infinity then the delta value is ignored. If 
+            they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is
+            thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="delta">The maximum acceptable difference between the
+            the expected and the actual</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Double,System.Double,System.String)">
+            <summary>
+            Verifies that two doubles are equal considering a delta. If the
+            expected value is infinity then the delta value is ignored. If 
+            they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is
+            thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="delta">The maximum acceptable difference between the
+            the expected and the actual</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Double,System.Double)">
+            <summary>
+            Verifies that two doubles are equal considering a delta. If the
+            expected value is infinity then the delta value is ignored. If 
+            they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is
+            thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="delta">The maximum acceptable difference between the
+            the expected and the actual</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Nullable{System.Double},System.Double,System.String,System.Object[])">
+            <summary>
+            Verifies that two doubles are equal considering a delta. If the
+            expected value is infinity then the delta value is ignored. If 
+            they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is
+            thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="delta">The maximum acceptable difference between the
+            the expected and the actual</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Nullable{System.Double},System.Double,System.String)">
+            <summary>
+            Verifies that two doubles are equal considering a delta. If the
+            expected value is infinity then the delta value is ignored. If 
+            they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is
+            thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="delta">The maximum acceptable difference between the
+            the expected and the actual</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Nullable{System.Double},System.Double)">
+            <summary>
+            Verifies that two doubles are equal considering a delta. If the
+            expected value is infinity then the delta value is ignored. If 
+            they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is
+            thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="delta">The maximum acceptable difference between the
+            the expected and the actual</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.Object,System.Object,System.String,System.Object[])">
+            <summary>
+            Verifies that two objects are equal.  Two objects are considered
+            equal if both are null, or if both have the same value. NUnit
+            has special semantics for some object types.
+            If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The value that is expected</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.Object,System.Object,System.String)">
+            <summary>
+            Verifies that two objects are equal.  Two objects are considered
+            equal if both are null, or if both have the same value. NUnit
+            has special semantics for some object types.
+            If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The value that is expected</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreEqual(System.Object,System.Object)">
+            <summary>
+            Verifies that two objects are equal.  Two objects are considered
+            equal if both are null, or if both have the same value. NUnit
+            has special semantics for some object types.
+            If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The value that is expected</param>
+            <param name="actual">The actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int32,System.Int32,System.String,System.Object[])">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int32,System.Int32,System.String)">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int32,System.Int32)">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int64,System.Int64,System.String,System.Object[])">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int64,System.Int64,System.String)">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int64,System.Int64)">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt32,System.UInt32,System.String,System.Object[])">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt32,System.UInt32,System.String)">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt32,System.UInt32)">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt64,System.UInt64,System.String,System.Object[])">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt64,System.UInt64,System.String)">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt64,System.UInt64)">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Decimal,System.Decimal,System.String,System.Object[])">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Decimal,System.Decimal,System.String)">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Decimal,System.Decimal)">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Single,System.Single,System.String,System.Object[])">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Single,System.Single,System.String)">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Single,System.Single)">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Double,System.Double,System.String,System.Object[])">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Double,System.Double,System.String)">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Double,System.Double)">
+            <summary>
+            Verifies that two values are not equal. If they are equal, then an 
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Object,System.Object,System.String,System.Object[])">
+            <summary>
+            Verifies that two objects are not equal.  Two objects are considered
+            equal if both are null, or if both have the same value. NUnit
+            has special semantics for some object types.
+            If they are equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The value that is expected</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Object,System.Object,System.String)">
+            <summary>
+            Verifies that two objects are not equal.  Two objects are considered
+            equal if both are null, or if both have the same value. NUnit
+            has special semantics for some object types.
+            If they are equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The value that is expected</param>
+            <param name="actual">The actual value</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Object,System.Object)">
+            <summary>
+            Verifies that two objects are not equal.  Two objects are considered
+            equal if both are null, or if both have the same value. NUnit
+            has special semantics for some object types.
+            If they are equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The value that is expected</param>
+            <param name="actual">The actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreSame(System.Object,System.Object,System.String,System.Object[])">
+            <summary>
+            Asserts that two objects refer to the same object. If they
+            are not the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected object</param>
+            <param name="actual">The actual object</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreSame(System.Object,System.Object,System.String)">
+            <summary>
+            Asserts that two objects refer to the same object. If they
+            are not the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected object</param>
+            <param name="actual">The actual object</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreSame(System.Object,System.Object)">
+            <summary>
+            Asserts that two objects refer to the same object. If they
+            are not the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected object</param>
+            <param name="actual">The actual object</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotSame(System.Object,System.Object,System.String,System.Object[])">
+            <summary>
+            Asserts that two objects do not refer to the same object. If they
+            are the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected object</param>
+            <param name="actual">The actual object</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotSame(System.Object,System.Object,System.String)">
+            <summary>
+            Asserts that two objects do not refer to the same object. If they
+            are the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected object</param>
+            <param name="actual">The actual object</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.AreNotSame(System.Object,System.Object)">
+            <summary>
+            Asserts that two objects do not refer to the same object. If they
+            are the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected object</param>
+            <param name="actual">The actual object</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.Int32,System.Int32,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.Int32,System.Int32,System.String)">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.Int32,System.Int32)">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.UInt32,System.UInt32,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.UInt32,System.UInt32,System.String)">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.UInt32,System.UInt32)">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.Int64,System.Int64,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.Int64,System.Int64,System.String)">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.Int64,System.Int64)">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.UInt64,System.UInt64,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.UInt64,System.UInt64,System.String)">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.UInt64,System.UInt64)">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.Decimal,System.Decimal,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.Decimal,System.Decimal,System.String)">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.Decimal,System.Decimal)">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.Double,System.Double,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.Double,System.Double,System.String)">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.Double,System.Double)">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.Single,System.Single,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.Single,System.Single,System.String)">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.Single,System.Single)">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.IComparable,System.IComparable,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.IComparable,System.IComparable,System.String)">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Greater(System.IComparable,System.IComparable)">
+            <summary>
+            Verifies that the first value is greater than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.Int32,System.Int32,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.Int32,System.Int32,System.String)">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.Int32,System.Int32)">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.UInt32,System.UInt32,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.UInt32,System.UInt32,System.String)">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.UInt32,System.UInt32)">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.Int64,System.Int64,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.Int64,System.Int64,System.String)">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.Int64,System.Int64)">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.UInt64,System.UInt64,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.UInt64,System.UInt64,System.String)">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.UInt64,System.UInt64)">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.Decimal,System.Decimal,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.Decimal,System.Decimal,System.String)">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.Decimal,System.Decimal)">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.Double,System.Double,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.Double,System.Double,System.String)">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.Double,System.Double)">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.Single,System.Single,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.Single,System.Single,System.String)">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.Single,System.Single)">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.IComparable,System.IComparable,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.IComparable,System.IComparable,System.String)">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Less(System.IComparable,System.IComparable)">
+            <summary>
+            Verifies that the first value is less than the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int32,System.Int32,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int32,System.Int32,System.String)">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int32,System.Int32)">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt32,System.UInt32,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt32,System.UInt32,System.String)">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt32,System.UInt32)">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int64,System.Int64,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int64,System.Int64,System.String)">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int64,System.Int64)">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt64,System.UInt64,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt64,System.UInt64,System.String)">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt64,System.UInt64)">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Decimal,System.Decimal,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Decimal,System.Decimal,System.String)">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Decimal,System.Decimal)">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Double,System.Double,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Double,System.Double,System.String)">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Double,System.Double)">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Single,System.Single,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Single,System.Single,System.String)">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Single,System.Single)">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.IComparable,System.IComparable,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.IComparable,System.IComparable,System.String)">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.IComparable,System.IComparable)">
+            <summary>
+            Verifies that the first value is greater than or equal tothe second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be greater</param>
+            <param name="arg2">The second value, expected to be less</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int32,System.Int32,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int32,System.Int32,System.String)">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int32,System.Int32)">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt32,System.UInt32,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt32,System.UInt32,System.String)">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt32,System.UInt32)">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int64,System.Int64,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int64,System.Int64,System.String)">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int64,System.Int64)">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt64,System.UInt64,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt64,System.UInt64,System.String)">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt64,System.UInt64)">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Decimal,System.Decimal,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Decimal,System.Decimal,System.String)">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Decimal,System.Decimal)">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Double,System.Double,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Double,System.Double,System.String)">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Double,System.Double)">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Single,System.Single,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Single,System.Single,System.String)">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Single,System.Single)">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.IComparable,System.IComparable,System.String,System.Object[])">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.IComparable,System.IComparable,System.String)">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.LessOrEqual(System.IComparable,System.IComparable)">
+            <summary>
+            Verifies that the first value is less than or equal to the second
+            value. If it is not, then an
+            <see cref="T:NUnit.Framework.AssertionException"/> is thrown. 
+            </summary>
+            <param name="arg1">The first value, expected to be less</param>
+            <param name="arg2">The second value, expected to be greater</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Contains(System.Object,System.Collections.ICollection,System.String,System.Object[])">
+            <summary>
+            Asserts that an object is contained in a list.
+            </summary>
+            <param name="expected">The expected object</param>
+            <param name="actual">The list to be examined</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Array of objects to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Contains(System.Object,System.Collections.ICollection,System.String)">
+            <summary>
+            Asserts that an object is contained in a list.
+            </summary>
+            <param name="expected">The expected object</param>
+            <param name="actual">The list to be examined</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.Contains(System.Object,System.Collections.ICollection)">
+            <summary>
+            Asserts that an object is contained in a list.
+            </summary>
+            <param name="expected">The expected object</param>
+            <param name="actual">The list to be examined</param>
+        </member>
+        <member name="P:NUnit.Framework.Assert.Counter">
+            <summary>
+            Gets the number of assertions executed so far and 
+            resets the counter to zero.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.AssertionHelper">
+            <summary>
+            AssertionHelper is an optional base class for user tests,
+            allowing the use of shorter names for constraints and
+            asserts and avoiding conflict with the definition of 
+            <see cref="T:NUnit.Framework.Is"/>, from which it inherits much of its
+            behavior, in certain mock object frameworks.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Object,NUnit.Framework.Constraints.IResolveConstraint)">
+            <summary>
+            Apply a constraint to an actual value, succeeding if the constraint
+            is satisfied and throwing an assertion exception on failure. Works
+            identically to <see cref="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint)"/>
+            </summary>
+            <param name="constraint">A Constraint to be applied</param>
+            <param name="actual">The actual value to test</param>
+        </member>
+        <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+            <summary>
+            Apply a constraint to an actual value, succeeding if the constraint
+            is satisfied and throwing an assertion exception on failure. Works
+            identically to <see cref="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String)"/>
+            </summary>
+            <param name="constraint">A Constraint to be applied</param>
+            <param name="actual">The actual value to test</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+            <summary>
+            Apply a constraint to an actual value, succeeding if the constraint
+            is satisfied and throwing an assertion exception on failure. Works
+            identically to <see cref="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])"/>
+            </summary>
+            <param name="constraint">A Constraint to be applied</param>
+            <param name="actual">The actual value to test</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.AssertionHelper.Expect(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint)">
+            <summary>
+            Apply a constraint to an actual value, succeeding if the constraint
+            is satisfied and throwing an assertion exception on failure.
+            </summary>
+            <param name="expr">A Constraint expression to be applied</param>
+            <param name="del">An ActualValueDelegate returning the value to be tested</param>
+        </member>
+        <member name="M:NUnit.Framework.AssertionHelper.Expect(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+            <summary>
+            Apply a constraint to an actual value, succeeding if the constraint
+            is satisfied and throwing an assertion exception on failure.
+            </summary>
+            <param name="expr">A Constraint expression to be applied</param>
+            <param name="del">An ActualValueDelegate returning the value to be tested</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.AssertionHelper.Expect(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+            <summary>
+            Apply a constraint to an actual value, succeeding if the constraint
+            is satisfied and throwing an assertion exception on failure.
+            </summary>
+            <param name="del">An ActualValueDelegate returning the value to be tested</param>
+            <param name="expr">A Constraint expression to be applied</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.AssertionHelper.Expect``1(``0@,NUnit.Framework.Constraints.IResolveConstraint)">
+            <summary>
+            Apply a constraint to a referenced value, succeeding if the constraint
+            is satisfied and throwing an assertion exception on failure.
+            </summary>
+            <param name="constraint">A Constraint to be applied</param>
+            <param name="actual">The actual value to test</param>
+        </member>
+        <member name="M:NUnit.Framework.AssertionHelper.Expect``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+            <summary>
+            Apply a constraint to a referenced value, succeeding if the constraint
+            is satisfied and throwing an assertion exception on failure.
+            </summary>
+            <param name="constraint">A Constraint to be applied</param>
+            <param name="actual">The actual value to test</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.AssertionHelper.Expect``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+            <summary>
+            Apply a constraint to a referenced value, succeeding if the constraint
+            is satisfied and throwing an assertion exception on failure.
+            </summary>
+            <param name="expression">A Constraint to be applied</param>
+            <param name="actual">The actual value to test</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Boolean,System.String,System.Object[])">
+            <summary>
+            Asserts that a condition is true. If the condition is false the method throws
+            an <see cref="T:NUnit.Framework.AssertionException"/>. Works Identically to 
+            <see cref="M:NUnit.Framework.Assert.That(System.Boolean,System.String,System.Object[])"/>.
+            </summary> 
+            <param name="condition">The evaluated condition</param>
+            <param name="message">The message to display if the condition is false</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Boolean,System.String)">
+            <summary>
+            Asserts that a condition is true. If the condition is false the method throws
+            an <see cref="T:NUnit.Framework.AssertionException"/>. Works Identically to 
+            <see cref="M:NUnit.Framework.Assert.That(System.Boolean,System.String)"/>.
+            </summary>
+            <param name="condition">The evaluated condition</param>
+            <param name="message">The message to display if the condition is false</param>
+        </member>
+        <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Boolean)">
+            <summary>
+            Asserts that a condition is true. If the condition is false the method throws
+            an <see cref="T:NUnit.Framework.AssertionException"/>. Works Identically to <see cref="M:NUnit.Framework.Assert.That(System.Boolean)"/>.
+            </summary>
+            <param name="condition">The evaluated condition</param>
+        </member>
+        <member name="M:NUnit.Framework.AssertionHelper.Expect(NUnit.Framework.TestDelegate,NUnit.Framework.Constraints.IResolveConstraint)">
+            <summary>
+            Asserts that the code represented by a delegate throws an exception
+            that satisfies the constraint provided.
+            </summary>
+            <param name="code">A TestDelegate to be executed</param>
+            <param name="constraint">A ThrowsConstraint used in the test</param>
+        </member>
+        <member name="M:NUnit.Framework.AssertionHelper.Map(System.Collections.ICollection)">
+            <summary>
+            Returns a ListMapper based on a collection.
+            </summary>
+            <param name="original">The original collection</param>
+            <returns></returns>
+        </member>
+        <member name="T:NUnit.Framework.Assume">
+            <summary>
+            Provides static methods to express the assumptions
+            that must be met for a test to give a meaningful
+            result. If an assumption is not met, the test
+            should produce an inconclusive result.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Assume.Equals(System.Object,System.Object)">
+            <summary>
+            The Equals method throws an AssertionException. This is done 
+            to make sure there is no mistake by calling this function.
+            </summary>
+            <param name="a"></param>
+            <param name="b"></param>
+        </member>
+        <member name="M:NUnit.Framework.Assume.ReferenceEquals(System.Object,System.Object)">
+            <summary>
+            override the default ReferenceEquals to throw an AssertionException. This 
+            implementation makes sure there is no mistake in calling this function 
+            as part of Assert. 
+            </summary>
+            <param name="a"></param>
+            <param name="b"></param>
+        </member>
+        <member name="M:NUnit.Framework.Assume.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint)">
+            <summary>
+            Apply a constraint to an actual value, succeeding if the constraint
+            is satisfied and throwing an InconclusiveException on failure.
+            </summary>
+            <param name="expression">A Constraint expression to be applied</param>
+            <param name="actual">The actual value to test</param>
+        </member>
+        <member name="M:NUnit.Framework.Assume.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+            <summary>
+            Apply a constraint to an actual value, succeeding if the constraint
+            is satisfied and throwing an InconclusiveException on failure.
+            </summary>
+            <param name="expression">A Constraint expression to be applied</param>
+            <param name="actual">The actual value to test</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assume.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+            <summary>
+            Apply a constraint to an actual value, succeeding if the constraint
+            is satisfied and throwing an InconclusiveException on failure.
+            </summary>
+            <param name="expression">A Constraint expression to be applied</param>
+            <param name="actual">The actual value to test</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assume.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint)">
+            <summary>
+            Apply a constraint to an actual value, succeeding if the constraint
+            is satisfied and throwing an InconclusiveException on failure.
+            </summary>
+            <param name="expr">A Constraint expression to be applied</param>
+            <param name="del">An ActualValueDelegate returning the value to be tested</param>
+        </member>
+        <member name="M:NUnit.Framework.Assume.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+            <summary>
+            Apply a constraint to an actual value, succeeding if the constraint
+            is satisfied and throwing an InconclusiveException on failure.
+            </summary>
+            <param name="expr">A Constraint expression to be applied</param>
+            <param name="del">An ActualValueDelegate returning the value to be tested</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assume.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+            <summary>
+            Apply a constraint to an actual value, succeeding if the constraint
+            is satisfied and throwing an InconclusiveException on failure.
+            </summary>
+            <param name="del">An ActualValueDelegate returning the value to be tested</param>
+            <param name="expr">A Constraint expression to be applied</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assume.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint)">
+            <summary>
+            Apply a constraint to a referenced value, succeeding if the constraint
+            is satisfied and throwing an InconclusiveException on failure.
+            </summary>
+            <param name="expression">A Constraint expression to be applied</param>
+            <param name="actual">The actual value to test</param>
+        </member>
+        <member name="M:NUnit.Framework.Assume.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+            <summary>
+            Apply a constraint to a referenced value, succeeding if the constraint
+            is satisfied and throwing an InconclusiveException on failure.
+            </summary>
+            <param name="expression">A Constraint expression to be applied</param>
+            <param name="actual">The actual value to test</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assume.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+            <summary>
+            Apply a constraint to a referenced value, succeeding if the constraint
+            is satisfied and throwing an InconclusiveException on failure.
+            </summary>
+            <param name="expression">A Constraint expression to be applied</param>
+            <param name="actual">The actual value to test</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assume.That(System.Boolean,System.String,System.Object[])">
+            <summary>
+            Asserts that a condition is true. If the condition is false the method throws
+            an <see cref="T:NUnit.Framework.InconclusiveException"/>.
+            </summary> 
+            <param name="condition">The evaluated condition</param>
+            <param name="message">The message to display if the condition is false</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.Assume.That(System.Boolean,System.String)">
+            <summary>
+            Asserts that a condition is true. If the condition is false the method throws
+            an <see cref="T:NUnit.Framework.InconclusiveException"/>.
+            </summary>
+            <param name="condition">The evaluated condition</param>
+            <param name="message">The message to display if the condition is false</param>
+        </member>
+        <member name="M:NUnit.Framework.Assume.That(System.Boolean)">
+            <summary>
+            Asserts that a condition is true. If the condition is false the 
+            method throws an <see cref="T:NUnit.Framework.InconclusiveException"/>.
+            </summary>
+            <param name="condition">The evaluated condition</param>
+        </member>
+        <member name="M:NUnit.Framework.Assume.That(NUnit.Framework.TestDelegate,NUnit.Framework.Constraints.IResolveConstraint)">
+            <summary>
+            Asserts that the code represented by a delegate throws an exception
+            that satisfies the constraint provided.
+            </summary>
+            <param name="code">A TestDelegate to be executed</param>
+            <param name="constraint">A ThrowsConstraint used in the test</param>
+        </member>
+        <member name="T:NUnit.Framework.CollectionAssert">
+            <summary>
+            A set of Assert methods operationg on one or more collections
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.Equals(System.Object,System.Object)">
+            <summary>
+            The Equals method throws an AssertionException. This is done 
+            to make sure there is no mistake by calling this function.
+            </summary>
+            <param name="a"></param>
+            <param name="b"></param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.ReferenceEquals(System.Object,System.Object)">
+            <summary>
+            override the default ReferenceEquals to throw an AssertionException. This 
+            implementation makes sure there is no mistake in calling this function 
+            as part of Assert. 
+            </summary>
+            <param name="a"></param>
+            <param name="b"></param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreInstancesOfType(System.Collections.IEnumerable,System.Type)">
+            <summary>
+            Asserts that all items contained in collection are of the type specified by expectedType.
+            </summary>
+            <param name="collection">IEnumerable containing objects to be considered</param>
+            <param name="expectedType">System.Type that all objects in collection must be instances of</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreInstancesOfType(System.Collections.IEnumerable,System.Type,System.String)">
+            <summary>
+            Asserts that all items contained in collection are of the type specified by expectedType.
+            </summary>
+            <param name="collection">IEnumerable containing objects to be considered</param>
+            <param name="expectedType">System.Type that all objects in collection must be instances of</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreInstancesOfType(System.Collections.IEnumerable,System.Type,System.String,System.Object[])">
+            <summary>
+            Asserts that all items contained in collection are of the type specified by expectedType.
+            </summary>
+            <param name="collection">IEnumerable containing objects to be considered</param>
+            <param name="expectedType">System.Type that all objects in collection must be instances of</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreNotNull(System.Collections.IEnumerable)">
+            <summary>
+            Asserts that all items contained in collection are not equal to null.
+            </summary>
+            <param name="collection">IEnumerable containing objects to be considered</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreNotNull(System.Collections.IEnumerable,System.String)">
+            <summary>
+            Asserts that all items contained in collection are not equal to null.
+            </summary>
+            <param name="collection">IEnumerable containing objects to be considered</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreNotNull(System.Collections.IEnumerable,System.String,System.Object[])">
+            <summary>
+            Asserts that all items contained in collection are not equal to null.
+            </summary>
+            <param name="collection">IEnumerable of objects to be considered</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreUnique(System.Collections.IEnumerable)">
+            <summary>
+            Ensures that every object contained in collection exists within the collection
+            once and only once.
+            </summary>
+            <param name="collection">IEnumerable of objects to be considered</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreUnique(System.Collections.IEnumerable,System.String)">
+            <summary>
+            Ensures that every object contained in collection exists within the collection
+            once and only once.
+            </summary>
+            <param name="collection">IEnumerable of objects to be considered</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreUnique(System.Collections.IEnumerable,System.String,System.Object[])">
+            <summary>
+            Ensures that every object contained in collection exists within the collection
+            once and only once.
+            </summary>
+            <param name="collection">IEnumerable of objects to be considered</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable)">
+            <summary>
+            Asserts that expected and actual are exactly equal.  The collections must have the same count, 
+            and contain the exact same objects in the same order.
+            </summary>
+            <param name="expected">The first IEnumerable of objects to be considered</param>
+            <param name="actual">The second IEnumerable of objects to be considered</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer)">
+            <summary>
+            Asserts that expected and actual are exactly equal.  The collections must have the same count, 
+            and contain the exact same objects in the same order.
+            If comparer is not null then it will be used to compare the objects.
+            </summary>
+            <param name="expected">The first IEnumerable of objects to be considered</param>
+            <param name="actual">The second IEnumerable of objects to be considered</param>
+            <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+            <summary>
+            Asserts that expected and actual are exactly equal.  The collections must have the same count, 
+            and contain the exact same objects in the same order.
+            </summary>
+            <param name="expected">The first IEnumerable of objects to be considered</param>
+            <param name="actual">The second IEnumerable of objects to be considered</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer,System.String)">
+            <summary>
+            Asserts that expected and actual are exactly equal.  The collections must have the same count, 
+            and contain the exact same objects in the same order.
+            If comparer is not null then it will be used to compare the objects.
+            </summary>
+            <param name="expected">The first IEnumerable of objects to be considered</param>
+            <param name="actual">The second IEnumerable of objects to be considered</param>
+            <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])">
+            <summary>
+            Asserts that expected and actual are exactly equal.  The collections must have the same count, 
+            and contain the exact same objects in the same order.
+            </summary>
+            <param name="expected">The first IEnumerable of objects to be considered</param>
+            <param name="actual">The second IEnumerable of objects to be considered</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer,System.String,System.Object[])">
+            <summary>
+            Asserts that expected and actual are exactly equal.  The collections must have the same count, 
+            and contain the exact same objects in the same order.
+            If comparer is not null then it will be used to compare the objects.
+            </summary>
+            <param name="expected">The first IEnumerable of objects to be considered</param>
+            <param name="actual">The second IEnumerable of objects to be considered</param>
+            <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AreEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable)">
+            <summary>
+            Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order.
+            </summary>
+            <param name="expected">The first IEnumerable of objects to be considered</param>
+            <param name="actual">The second IEnumerable of objects to be considered</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AreEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+            <summary>
+            Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order.
+            </summary>
+            <param name="expected">The first IEnumerable of objects to be considered</param>
+            <param name="actual">The second IEnumerable of objects to be considered</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AreEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])">
+            <summary>
+            Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order.
+            </summary>
+            <param name="expected">The first IEnumerable of objects to be considered</param>
+            <param name="actual">The second IEnumerable of objects to be considered</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable)">
+            <summary>
+            Asserts that expected and actual are not exactly equal.
+            </summary>
+            <param name="expected">The first IEnumerable of objects to be considered</param>
+            <param name="actual">The second IEnumerable of objects to be considered</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer)">
+            <summary>
+            Asserts that expected and actual are not exactly equal.
+            If comparer is not null then it will be used to compare the objects.
+            </summary>
+            <param name="expected">The first IEnumerable of objects to be considered</param>
+            <param name="actual">The second IEnumerable of objects to be considered</param>
+            <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+            <summary>
+            Asserts that expected and actual are not exactly equal.
+            </summary>
+            <param name="expected">The first IEnumerable of objects to be considered</param>
+            <param name="actual">The second IEnumerable of objects to be considered</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer,System.String)">
+            <summary>
+            Asserts that expected and actual are not exactly equal.
+            If comparer is not null then it will be used to compare the objects.
+            </summary>
+            <param name="expected">The first IEnumerable of objects to be considered</param>
+            <param name="actual">The second IEnumerable of objects to be considered</param>
+            <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])">
+            <summary>
+            Asserts that expected and actual are not exactly equal.
+            </summary>
+            <param name="expected">The first IEnumerable of objects to be considered</param>
+            <param name="actual">The second IEnumerable of objects to be considered</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer,System.String,System.Object[])">
+            <summary>
+            Asserts that expected and actual are not exactly equal.
+            If comparer is not null then it will be used to compare the objects.
+            </summary>
+            <param name="expected">The first IEnumerable of objects to be considered</param>
+            <param name="actual">The second IEnumerable of objects to be considered</param>
+            <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AreNotEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable)">
+            <summary>
+            Asserts that expected and actual are not equivalent.
+            </summary>
+            <param name="expected">The first IEnumerable of objects to be considered</param>
+            <param name="actual">The second IEnumerable of objects to be considered</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AreNotEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+            <summary>
+            Asserts that expected and actual are not equivalent.
+            </summary>
+            <param name="expected">The first IEnumerable of objects to be considered</param>
+            <param name="actual">The second IEnumerable of objects to be considered</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.AreNotEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])">
+            <summary>
+            Asserts that expected and actual are not equivalent.
+            </summary>
+            <param name="expected">The first IEnumerable of objects to be considered</param>
+            <param name="actual">The second IEnumerable of objects to be considered</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.Contains(System.Collections.IEnumerable,System.Object)">
+            <summary>
+            Asserts that collection contains actual as an item.
+            </summary>
+            <param name="collection">IEnumerable of objects to be considered</param>
+            <param name="actual">Object to be found within collection</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.Contains(System.Collections.IEnumerable,System.Object,System.String)">
+            <summary>
+            Asserts that collection contains actual as an item.
+            </summary>
+            <param name="collection">IEnumerable of objects to be considered</param>
+            <param name="actual">Object to be found within collection</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.Contains(System.Collections.IEnumerable,System.Object,System.String,System.Object[])">
+            <summary>
+            Asserts that collection contains actual as an item.
+            </summary>
+            <param name="collection">IEnumerable of objects to be considered</param>
+            <param name="actual">Object to be found within collection</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.DoesNotContain(System.Collections.IEnumerable,System.Object)">
+            <summary>
+            Asserts that collection does not contain actual as an item.
+            </summary>
+            <param name="collection">IEnumerable of objects to be considered</param>
+            <param name="actual">Object that cannot exist within collection</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.DoesNotContain(System.Collections.IEnumerable,System.Object,System.String)">
+            <summary>
+            Asserts that collection does not contain actual as an item.
+            </summary>
+            <param name="collection">IEnumerable of objects to be considered</param>
+            <param name="actual">Object that cannot exist within collection</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.DoesNotContain(System.Collections.IEnumerable,System.Object,System.String,System.Object[])">
+            <summary>
+            Asserts that collection does not contain actual as an item.
+            </summary>
+            <param name="collection">IEnumerable of objects to be considered</param>
+            <param name="actual">Object that cannot exist within collection</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsNotSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable)">
+            <summary>
+            Asserts that superset is not a subject of subset.
+            </summary>
+            <param name="subset">The IEnumerable superset to be considered</param>
+            <param name="superset">The IEnumerable subset to be considered</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsNotSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+            <summary>
+            Asserts that superset is not a subject of subset.
+            </summary>
+            <param name="subset">The IEnumerable superset to be considered</param>
+            <param name="superset">The IEnumerable subset to be considered</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsNotSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])">
+            <summary>
+            Asserts that superset is not a subject of subset.
+            </summary>
+            <param name="subset">The IEnumerable superset to be considered</param>
+            <param name="superset">The IEnumerable subset to be considered</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable)">
+            <summary>
+            Asserts that superset is a subset of subset.
+            </summary>
+            <param name="subset">The IEnumerable superset to be considered</param>
+            <param name="superset">The IEnumerable subset to be considered</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+            <summary>
+            Asserts that superset is a subset of subset.
+            </summary>
+            <param name="subset">The IEnumerable superset to be considered</param>
+            <param name="superset">The IEnumerable subset to be considered</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])">
+            <summary>
+            Asserts that superset is a subset of subset.
+            </summary>
+            <param name="subset">The IEnumerable superset to be considered</param>
+            <param name="superset">The IEnumerable subset to be considered</param>
+            <param name="message">The message that will be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsEmpty(System.Collections.IEnumerable,System.String,System.Object[])">
+            <summary>
+            Assert that an array, list or other collection is empty
+            </summary>
+            <param name="collection">An array, list or other collection implementing IEnumerable</param>
+            <param name="message">The message to be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsEmpty(System.Collections.IEnumerable,System.String)">
+            <summary>
+            Assert that an array, list or other collection is empty
+            </summary>
+            <param name="collection">An array, list or other collection implementing IEnumerable</param>
+            <param name="message">The message to be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsEmpty(System.Collections.IEnumerable)">
+            <summary>
+            Assert that an array,list or other collection is empty
+            </summary>
+            <param name="collection">An array, list or other collection implementing IEnumerable</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsNotEmpty(System.Collections.IEnumerable,System.String,System.Object[])">
+            <summary>
+            Assert that an array, list or other collection is empty
+            </summary>
+            <param name="collection">An array, list or other collection implementing IEnumerable</param>
+            <param name="message">The message to be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsNotEmpty(System.Collections.IEnumerable,System.String)">
+            <summary>
+            Assert that an array, list or other collection is empty
+            </summary>
+            <param name="collection">An array, list or other collection implementing IEnumerable</param>
+            <param name="message">The message to be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsNotEmpty(System.Collections.IEnumerable)">
+            <summary>
+            Assert that an array,list or other collection is empty
+            </summary>
+            <param name="collection">An array, list or other collection implementing IEnumerable</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.String,System.Object[])">
+            <summary>
+            Assert that an array, list or other collection is ordered
+            </summary>
+            <param name="collection">An array, list or other collection implementing IEnumerable</param>
+            <param name="message">The message to be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.String)">
+            <summary>
+            Assert that an array, list or other collection is ordered
+            </summary>
+            <param name="collection">An array, list or other collection implementing IEnumerable</param>
+            <param name="message">The message to be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable)">
+            <summary>
+            Assert that an array, list or other collection is ordered
+            </summary>
+            <param name="collection">An array, list or other collection implementing IEnumerable</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.Collections.IComparer,System.String,System.Object[])">
+            <summary>
+            Assert that an array, list or other collection is ordered
+            </summary>
+            <param name="collection">An array, list or other collection implementing IEnumerable</param>
+            <param name="comparer">A custom comparer to perform the comparisons</param>
+            <param name="message">The message to be displayed on failure</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.Collections.IComparer,System.String)">
+            <summary>
+            Assert that an array, list or other collection is ordered
+            </summary>
+            <param name="collection">An array, list or other collection implementing IEnumerable</param>
+            <param name="comparer">A custom comparer to perform the comparisons</param>
+            <param name="message">The message to be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.Collections.IComparer)">
+            <summary>
+            Assert that an array, list or other collection is ordered
+            </summary>
+            <param name="collection">An array, list or other collection implementing IEnumerable</param>
+            <param name="comparer">A custom comparer to perform the comparisons</param>
+        </member>
+        <member name="T:NUnit.Framework.Contains">
+            <summary>
+            Static helper class used in the constraint-based syntax
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Contains.Substring(System.String)">
+            <summary>
+            Creates a new SubstringConstraint
+            </summary>
+            <param name="substring">The value of the substring</param>
+            <returns>A SubstringConstraint</returns>
+        </member>
+        <member name="M:NUnit.Framework.Contains.Item(System.Object)">
+            <summary>
+            Creates a new CollectionContainsConstraint.
+            </summary>
+            <param name="item">The item that should be found.</param>
+            <returns>A new CollectionContainsConstraint</returns>
+        </member>
+        <member name="T:NUnit.Framework.DirectoryAssert">
+            <summary>
+            Summary description for DirectoryAssert
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.Equals(System.Object,System.Object)">
+            <summary>
+            The Equals method throws an AssertionException. This is done 
+            to make sure there is no mistake by calling this function.
+            </summary>
+            <param name="a"></param>
+            <param name="b"></param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.ReferenceEquals(System.Object,System.Object)">
+            <summary>
+            override the default ReferenceEquals to throw an AssertionException. This 
+            implementation makes sure there is no mistake in calling this function 
+            as part of Assert. 
+            </summary>
+            <param name="a"></param>
+            <param name="b"></param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.#ctor">
+            <summary>
+            We don't actually want any instances of this object, but some people
+            like to inherit from it to add other static methods. Hence, the
+            protected constructor disallows any instances of this object. 
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String,System.Object[])">
+            <summary>
+            Verifies that two directories are equal.  Two directories are considered
+            equal if both are null, or if both have the same value byte for byte.
+            If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">A directory containing the value that is expected</param>
+            <param name="actual">A directory containing the actual value</param>
+            <param name="message">The message to display if directories are not equal</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String)">
+            <summary>
+            Verifies that two directories are equal.  Two directories are considered
+            equal if both are null, or if both have the same value byte for byte.
+            If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">A directory containing the value that is expected</param>
+            <param name="actual">A directory containing the actual value</param>
+            <param name="message">The message to display if directories are not equal</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
+            <summary>
+            Verifies that two directories are equal.  Two directories are considered
+            equal if both are null, or if both have the same value byte for byte.
+            If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">A directory containing the value that is expected</param>
+            <param name="actual">A directory containing the actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.String,System.String,System.String,System.Object[])">
+            <summary>
+            Verifies that two directories are equal.  Two directories are considered
+            equal if both are null, or if both have the same value byte for byte.
+            If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">A directory path string containing the value that is expected</param>
+            <param name="actual">A directory path string containing the actual value</param>
+            <param name="message">The message to display if directories are not equal</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.String,System.String,System.String)">
+            <summary>
+            Verifies that two directories are equal.  Two directories are considered
+            equal if both are null, or if both have the same value byte for byte.
+            If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">A directory path string containing the value that is expected</param>
+            <param name="actual">A directory path string containing the actual value</param>
+            <param name="message">The message to display if directories are not equal</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.String,System.String)">
+            <summary>
+            Verifies that two directories are equal.  Two directories are considered
+            equal if both are null, or if both have the same value byte for byte.
+            If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">A directory path string containing the value that is expected</param>
+            <param name="actual">A directory path string containing the actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String,System.Object[])">
+            <summary>
+            Asserts that two directories are not equal. If they are equal
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">A directory containing the value that is expected</param>
+            <param name="actual">A directory containing the actual value</param>
+            <param name="message">The message to display if directories are not equal</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String)">
+            <summary>
+            Asserts that two directories are not equal. If they are equal
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">A directory containing the value that is expected</param>
+            <param name="actual">A directory containing the actual value</param>
+            <param name="message">The message to display if directories are not equal</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
+            <summary>
+            Asserts that two directories are not equal. If they are equal
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">A directory containing the value that is expected</param>
+            <param name="actual">A directory containing the actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.String,System.String,System.String,System.Object[])">
+            <summary>
+            Asserts that two directories are not equal. If they are equal
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">A directory path string containing the value that is expected</param>
+            <param name="actual">A directory path string containing the actual value</param>
+            <param name="message">The message to display if directories are equal</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.String,System.String,System.String)">
+            <summary>
+            Asserts that two directories are not equal. If they are equal
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">A directory path string containing the value that is expected</param>
+            <param name="actual">A directory path string containing the actual value</param>
+            <param name="message">The message to display if directories are equal</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.String,System.String)">
+            <summary>
+            Asserts that two directories are not equal. If they are equal
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">A directory path string containing the value that is expected</param>
+            <param name="actual">A directory path string containing the actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.IO.DirectoryInfo,System.String,System.Object[])">
+            <summary>
+            Asserts that the directory is empty. If it is not empty
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="message">The message to display if directories are not equal</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.IO.DirectoryInfo,System.String)">
+            <summary>
+            Asserts that the directory is empty. If it is not empty
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="message">The message to display if directories are not equal</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.IO.DirectoryInfo)">
+            <summary>
+            Asserts that the directory is empty. If it is not empty
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.String,System.String,System.Object[])">
+            <summary>
+            Asserts that the directory is empty. If it is not empty
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="message">The message to display if directories are not equal</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.String,System.String)">
+            <summary>
+            Asserts that the directory is empty. If it is not empty
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="message">The message to display if directories are not equal</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.String)">
+            <summary>
+            Asserts that the directory is empty. If it is not empty
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.IO.DirectoryInfo,System.String,System.Object[])">
+            <summary>
+            Asserts that the directory is not empty. If it is empty
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="message">The message to display if directories are not equal</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.IO.DirectoryInfo,System.String)">
+            <summary>
+            Asserts that the directory is not empty. If it is empty
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="message">The message to display if directories are not equal</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.IO.DirectoryInfo)">
+            <summary>
+            Asserts that the directory is not empty. If it is empty
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.String,System.String,System.Object[])">
+            <summary>
+            Asserts that the directory is not empty. If it is empty
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="message">The message to display if directories are not equal</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.String,System.String)">
+            <summary>
+            Asserts that the directory is not empty. If it is empty
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="message">The message to display if directories are not equal</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.String)">
+            <summary>
+            Asserts that the directory is not empty. If it is empty
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String,System.Object[])">
+            <summary>
+            Asserts that path contains actual as a subdirectory or
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="actual">sub-directory asserted to exist under directory</param>
+            <param name="message">The message to display if directory is not within the path</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String)">
+            <summary>
+            Asserts that path contains actual as a subdirectory or
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="actual">sub-directory asserted to exist under directory</param>
+            <param name="message">The message to display if directory is not within the path</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
+            <summary>
+            Asserts that path contains actual as a subdirectory or
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="actual">sub-directory asserted to exist under directory</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.String,System.String,System.String,System.Object[])">
+            <summary>
+            Asserts that path contains actual as a subdirectory or
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="actual">sub-directory asserted to exist under directory</param>
+            <param name="message">The message to display if directory is not within the path</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.String,System.String,System.String)">
+            <summary>
+            Asserts that path contains actual as a subdirectory or
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="actual">sub-directory asserted to exist under directory</param>
+            <param name="message">The message to display if directory is not within the path</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.String,System.String)">
+            <summary>
+            Asserts that path contains actual as a subdirectory or
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="actual">sub-directory asserted to exist under directory</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String,System.Object[])">
+            <summary>
+            Asserts that path does not contain actual as a subdirectory or
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="actual">sub-directory asserted to exist under directory</param>
+            <param name="message">The message to display if directory is not within the path</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String)">
+            <summary>
+            Asserts that path does not contain actual as a subdirectory or
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="actual">sub-directory asserted to exist under directory</param>
+            <param name="message">The message to display if directory is not within the path</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
+            <summary>
+            Asserts that path does not contain actual as a subdirectory or
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="actual">sub-directory asserted to exist under directory</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.String,System.String,System.String,System.Object[])">
+            <summary>
+            Asserts that path does not contain actual as a subdirectory or
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="actual">sub-directory asserted to exist under directory</param>
+            <param name="message">The message to display if directory is not within the path</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.String,System.String,System.String)">
+            <summary>
+            Asserts that path does not contain actual as a subdirectory or
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="actual">sub-directory asserted to exist under directory</param>
+            <param name="message">The message to display if directory is not within the path</param>
+        </member>
+        <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.String,System.String)">
+            <summary>
+            Asserts that path does not contain actual as a subdirectory or
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="directory">A directory to search</param>
+            <param name="actual">sub-directory asserted to exist under directory</param>
+        </member>
+        <member name="T:NUnit.Framework.FileAssert">
+            <summary>
+            Summary description for FileAssert.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.Equals(System.Object,System.Object)">
+            <summary>
+            The Equals method throws an AssertionException. This is done 
+            to make sure there is no mistake by calling this function.
+            </summary>
+            <param name="a"></param>
+            <param name="b"></param>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.ReferenceEquals(System.Object,System.Object)">
+            <summary>
+            override the default ReferenceEquals to throw an AssertionException. This 
+            implementation makes sure there is no mistake in calling this function 
+            as part of Assert. 
+            </summary>
+            <param name="a"></param>
+            <param name="b"></param>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.#ctor">
+            <summary>
+            We don't actually want any instances of this object, but some people
+            like to inherit from it to add other static methods. Hence, the
+            protected constructor disallows any instances of this object. 
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.Stream,System.IO.Stream,System.String,System.Object[])">
+            <summary>
+            Verifies that two Streams are equal.  Two Streams are considered
+            equal if both are null, or if both have the same value byte for byte.
+            If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected Stream</param>
+            <param name="actual">The actual Stream</param>
+            <param name="message">The message to display if Streams are not equal</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.Stream,System.IO.Stream,System.String)">
+            <summary>
+            Verifies that two Streams are equal.  Two Streams are considered
+            equal if both are null, or if both have the same value byte for byte.
+            If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected Stream</param>
+            <param name="actual">The actual Stream</param>
+            <param name="message">The message to display if objects are not equal</param>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.Stream,System.IO.Stream)">
+            <summary>
+            Verifies that two Streams are equal.  Two Streams are considered
+            equal if both are null, or if both have the same value byte for byte.
+            If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected Stream</param>
+            <param name="actual">The actual Stream</param>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.FileInfo,System.IO.FileInfo,System.String,System.Object[])">
+            <summary>
+            Verifies that two files are equal.  Two files are considered
+            equal if both are null, or if both have the same value byte for byte.
+            If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">A file containing the value that is expected</param>
+            <param name="actual">A file containing the actual value</param>
+            <param name="message">The message to display if Streams are not equal</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.FileInfo,System.IO.FileInfo,System.String)">
+            <summary>
+            Verifies that two files are equal.  Two files are considered
+            equal if both are null, or if both have the same value byte for byte.
+            If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">A file containing the value that is expected</param>
+            <param name="actual">A file containing the actual value</param>
+            <param name="message">The message to display if objects are not equal</param>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.FileInfo,System.IO.FileInfo)">
+            <summary>
+            Verifies that two files are equal.  Two files are considered
+            equal if both are null, or if both have the same value byte for byte.
+            If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">A file containing the value that is expected</param>
+            <param name="actual">A file containing the actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.AreEqual(System.String,System.String,System.String,System.Object[])">
+            <summary>
+            Verifies that two files are equal.  Two files are considered
+            equal if both are null, or if both have the same value byte for byte.
+            If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The path to a file containing the value that is expected</param>
+            <param name="actual">The path to a file containing the actual value</param>
+            <param name="message">The message to display if Streams are not equal</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.AreEqual(System.String,System.String,System.String)">
+            <summary>
+            Verifies that two files are equal.  Two files are considered
+            equal if both are null, or if both have the same value byte for byte.
+            If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The path to a file containing the value that is expected</param>
+            <param name="actual">The path to a file containing the actual value</param>
+            <param name="message">The message to display if objects are not equal</param>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.AreEqual(System.String,System.String)">
+            <summary>
+            Verifies that two files are equal.  Two files are considered
+            equal if both are null, or if both have the same value byte for byte.
+            If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The path to a file containing the value that is expected</param>
+            <param name="actual">The path to a file containing the actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.Stream,System.IO.Stream,System.String,System.Object[])">
+            <summary>
+            Asserts that two Streams are not equal. If they are equal
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected Stream</param>
+            <param name="actual">The actual Stream</param>
+            <param name="message">The message to be displayed when the two Stream are the same.</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.Stream,System.IO.Stream,System.String)">
+            <summary>
+            Asserts that two Streams are not equal. If they are equal
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected Stream</param>
+            <param name="actual">The actual Stream</param>
+            <param name="message">The message to be displayed when the Streams are the same.</param>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.Stream,System.IO.Stream)">
+            <summary>
+            Asserts that two Streams are not equal. If they are equal
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The expected Stream</param>
+            <param name="actual">The actual Stream</param>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.FileInfo,System.IO.FileInfo,System.String,System.Object[])">
+            <summary>
+            Asserts that two files are not equal. If they are equal
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">A file containing the value that is expected</param>
+            <param name="actual">A file containing the actual value</param>
+            <param name="message">The message to display if Streams are not equal</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.FileInfo,System.IO.FileInfo,System.String)">
+            <summary>
+            Asserts that two files are not equal. If they are equal
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">A file containing the value that is expected</param>
+            <param name="actual">A file containing the actual value</param>
+            <param name="message">The message to display if objects are not equal</param>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.FileInfo,System.IO.FileInfo)">
+            <summary>
+            Asserts that two files are not equal. If they are equal
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">A file containing the value that is expected</param>
+            <param name="actual">A file containing the actual value</param>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.String,System.String,System.String,System.Object[])">
+            <summary>
+            Asserts that two files are not equal. If they are equal
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The path to a file containing the value that is expected</param>
+            <param name="actual">The path to a file containing the actual value</param>
+            <param name="message">The message to display if Streams are not equal</param>
+            <param name="args">Arguments to be used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.String,System.String,System.String)">
+            <summary>
+            Asserts that two files are not equal. If they are equal
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The path to a file containing the value that is expected</param>
+            <param name="actual">The path to a file containing the actual value</param>
+            <param name="message">The message to display if objects are not equal</param>
+        </member>
+        <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.String,System.String)">
+            <summary>
+            Asserts that two files are not equal. If they are equal
+            an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+            </summary>
+            <param name="expected">The path to a file containing the value that is expected</param>
+            <param name="actual">The path to a file containing the actual value</param>
+        </member>
+        <member name="T:NUnit.Framework.GlobalSettings">
+            <summary>
+            GlobalSettings is a place for setting default values used
+            by the framework in performing asserts.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.GlobalSettings.DefaultFloatingPointTolerance">
+            <summary>
+            Default tolerance for floating point equality
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Has">
+            <summary>
+            Helper class with properties and methods that supply
+            a number of constraints used in Asserts.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Has.Property(System.String)">
+            <summary>
+            Returns a new PropertyConstraintExpression, which will either
+            test for the existence of the named property on the object
+            being tested or apply any following constraint to that property.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Has.Attribute(System.Type)">
+            <summary>
+            Returns a new AttributeConstraint checking for the
+            presence of a particular attribute on an object.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Has.Attribute``1">
+            <summary>
+            Returns a new AttributeConstraint checking for the
+            presence of a particular attribute on an object.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Has.Member(System.Object)">
+            <summary>
+            Returns a new CollectionContainsConstraint checking for the
+            presence of a particular object in the collection.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Has.No">
+            <summary>
+            Returns a ConstraintExpression that negates any
+            following constraint.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Has.All">
+            <summary>
+            Returns a ConstraintExpression, which will apply
+            the following constraint to all members of a collection,
+            succeeding if all of them succeed.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Has.Some">
+            <summary>
+            Returns a ConstraintExpression, which will apply
+            the following constraint to all members of a collection,
+            succeeding if at least one of them succeeds.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Has.None">
+            <summary>
+            Returns a ConstraintExpression, which will apply
+            the following constraint to all members of a collection,
+            succeeding if all of them fail.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Has.Length">
+            <summary>
+            Returns a new ConstraintExpression, which will apply the following
+            constraint to the Length property of the object being tested.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Has.Count">
+            <summary>
+            Returns a new ConstraintExpression, which will apply the following
+            constraint to the Count property of the object being tested.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Has.Message">
+            <summary>
+            Returns a new ConstraintExpression, which will apply the following
+            constraint to the Message property of the object being tested.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Has.InnerException">
+            <summary>
+            Returns a new ConstraintExpression, which will apply the following
+            constraint to the InnerException property of the object being tested.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.IExpectException">
+            <summary>
+            Interface implemented by a user fixture in order to
+            validate any expected exceptions. It is only called
+            for test methods marked with the ExpectedException
+            attribute.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.IExpectException.HandleException(System.Exception)">
+            <summary>
+            Method to handle an expected exception
+            </summary>
+            <param name="ex">The exception to be handled</param>
+        </member>
+        <member name="T:NUnit.Framework.Is">
+            <summary>
+            Helper class with properties and methods that supply
+            a number of constraints used in Asserts.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.EqualTo(System.Object)">
+            <summary>
+            Returns a constraint that tests two items for equality
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.SameAs(System.Object)">
+            <summary>
+            Returns a constraint that tests that two references are the same object
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.GreaterThan(System.Object)">
+            <summary>
+            Returns a constraint that tests whether the
+            actual value is greater than the suppled argument
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.GreaterThanOrEqualTo(System.Object)">
+            <summary>
+            Returns a constraint that tests whether the
+            actual value is greater than or equal to the suppled argument
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.AtLeast(System.Object)">
+            <summary>
+            Returns a constraint that tests whether the
+            actual value is greater than or equal to the suppled argument
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.LessThan(System.Object)">
+            <summary>
+            Returns a constraint that tests whether the
+            actual value is less than the suppled argument
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.LessThanOrEqualTo(System.Object)">
+            <summary>
+            Returns a constraint that tests whether the
+            actual value is less than or equal to the suppled argument
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.AtMost(System.Object)">
+            <summary>
+            Returns a constraint that tests whether the
+            actual value is less than or equal to the suppled argument
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.TypeOf(System.Type)">
+            <summary>
+            Returns a constraint that tests whether the actual
+            value is of the exact type supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.TypeOf``1">
+            <summary>
+            Returns a constraint that tests whether the actual
+            value is of the exact type supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.InstanceOf(System.Type)">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is of the type supplied as an argument or a derived type.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.InstanceOf``1">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is of the type supplied as an argument or a derived type.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.InstanceOfType(System.Type)">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is of the type supplied as an argument or a derived type.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.InstanceOfType``1">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is of the type supplied as an argument or a derived type.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.AssignableFrom(System.Type)">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is assignable from the type supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.AssignableFrom``1">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is assignable from the type supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.AssignableTo(System.Type)">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is assignable from the type supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.AssignableTo``1">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is assignable from the type supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.EquivalentTo(System.Collections.IEnumerable)">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is a collection containing the same elements as the 
+            collection supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.SubsetOf(System.Collections.IEnumerable)">
+            <summary>
+            Returns a constraint that tests whether the actual value
+            is a subset of the collection supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.StringContaining(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value contains the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.StringStarting(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value starts with the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.StringEnding(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value ends with the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.StringMatching(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value matches the Regex pattern supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.SamePath(System.String)">
+            <summary>
+            Returns a constraint that tests whether the path provided 
+            is the same as an expected path after canonicalization.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.SubPath(System.String)">
+            <summary>
+            Returns a constraint that tests whether the path provided 
+            is the same path or under an expected path after canonicalization.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.SamePathOrUnder(System.String)">
+            <summary>
+            Returns a constraint that tests whether the path provided 
+            is the same path or under an expected path after canonicalization.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Is.InRange(System.IComparable,System.IComparable)">
+            <summary>
+            Returns a constraint that tests whether the actual value falls 
+            within a specified range.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Is.Not">
+            <summary>
+            Returns a ConstraintExpression that negates any
+            following constraint.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Is.All">
+            <summary>
+            Returns a ConstraintExpression, which will apply
+            the following constraint to all members of a collection,
+            succeeding if all of them succeed.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Is.Null">
+            <summary>
+            Returns a constraint that tests for null
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Is.True">
+            <summary>
+            Returns a constraint that tests for True
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Is.False">
+            <summary>
+            Returns a constraint that tests for False
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Is.NaN">
+            <summary>
+            Returns a constraint that tests for NaN
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Is.Empty">
+            <summary>
+            Returns a constraint that tests for empty
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Is.Unique">
+            <summary>
+            Returns a constraint that tests whether a collection 
+            contains all unique items.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Is.BinarySerializable">
+            <summary>
+            Returns a constraint that tests whether an object graph is serializable in binary format.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Is.XmlSerializable">
+            <summary>
+            Returns a constraint that tests whether an object graph is serializable in xml format.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Is.Ordered">
+            <summary>
+            Returns a constraint that tests whether a collection is ordered
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Iz">
+            <summary>
+            The Iz class is a synonym for Is intended for use in VB,
+            which regards Is as a keyword.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.List">
+            <summary>
+            The List class is a helper class with properties and methods
+            that supply a number of constraints used with lists and collections.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.List.Map(System.Collections.ICollection)">
+            <summary>
+            List.Map returns a ListMapper, which can be used to map
+            the original collection to another collection.
+            </summary>
+            <param name="actual"></param>
+            <returns></returns>
+        </member>
+        <member name="T:NUnit.Framework.ListMapper">
+            <summary>
+            ListMapper is used to transform a collection used as an actual argument
+            producing another collection to be used in the assertion.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.ListMapper.#ctor(System.Collections.ICollection)">
+            <summary>
+            Construct a ListMapper based on a collection
+            </summary>
+            <param name="original">The collection to be transformed</param>
+        </member>
+        <member name="M:NUnit.Framework.ListMapper.Property(System.String)">
+            <summary>
+            Produces a collection containing all the values of a property
+            </summary>
+            <param name="name">The collection of property values</param>
+            <returns></returns>
+        </member>
+        <member name="T:NUnit.Framework.Randomizer">
+            <summary>
+            Randomizer returns a set of random values in a repeatable
+            way, to allow re-running of tests if necessary.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Randomizer.GetRandomizer(System.Reflection.MemberInfo)">
+            <summary>
+            Get a randomizer for a particular member, returning
+            one that has already been created if it exists.
+            This ensures that the same values are generated
+            each time the tests are reloaded.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Randomizer.GetRandomizer(System.Reflection.ParameterInfo)">
+            <summary>
+            Get a randomizer for a particular parameter, returning
+            one that has already been created if it exists.
+            This ensures that the same values are generated
+            each time the tests are reloaded.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Randomizer.#ctor">
+            <summary>
+            Construct a randomizer using a random seed
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Randomizer.#ctor(System.Int32)">
+            <summary>
+            Construct a randomizer using a specified seed
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Randomizer.GetDoubles(System.Int32)">
+            <summary>
+            Return an array of random doubles between 0.0 and 1.0.
+            </summary>
+            <param name="count"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Randomizer.GetDoubles(System.Double,System.Double,System.Int32)">
+            <summary>
+            Return an array of random doubles with values in a specified range.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Randomizer.GetInts(System.Int32,System.Int32,System.Int32)">
+            <summary>
+            Return an array of random ints with values in a specified range.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Randomizer.RandomSeed">
+            <summary>
+            Get a random seed for use in creating a randomizer.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.SpecialValue">
+            <summary>
+            The SpecialValue enum is used to represent TestCase arguments
+            that cannot be used as arguments to an Attribute.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.SpecialValue.Null">
+            <summary>
+            Null represents a null value, which cannot be used as an 
+            argument to an attriute under .NET 1.x
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.StringAssert">
+            <summary>
+            Basic Asserts on strings.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.Equals(System.Object,System.Object)">
+            <summary>
+            The Equals method throws an AssertionException. This is done 
+            to make sure there is no mistake by calling this function.
+            </summary>
+            <param name="a"></param>
+            <param name="b"></param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.ReferenceEquals(System.Object,System.Object)">
+            <summary>
+            override the default ReferenceEquals to throw an AssertionException. This 
+            implementation makes sure there is no mistake in calling this function 
+            as part of Assert. 
+            </summary>
+            <param name="a"></param>
+            <param name="b"></param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.Contains(System.String,System.String,System.String,System.Object[])">
+            <summary>
+            Asserts that a string is found within another string.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The string to be examined</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Arguments used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.Contains(System.String,System.String,System.String)">
+            <summary>
+            Asserts that a string is found within another string.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The string to be examined</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.Contains(System.String,System.String)">
+            <summary>
+            Asserts that a string is found within another string.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The string to be examined</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.DoesNotContain(System.String,System.String,System.String,System.Object[])">
+            <summary>
+            Asserts that a string is not found within another string.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The string to be examined</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Arguments used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.DoesNotContain(System.String,System.String,System.String)">
+            <summary>
+            Asserts that a string is found within another string.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The string to be examined</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.DoesNotContain(System.String,System.String)">
+            <summary>
+            Asserts that a string is found within another string.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The string to be examined</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.StartsWith(System.String,System.String,System.String,System.Object[])">
+            <summary>
+            Asserts that a string starts with another string.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The string to be examined</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Arguments used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.StartsWith(System.String,System.String,System.String)">
+            <summary>
+            Asserts that a string starts with another string.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The string to be examined</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.StartsWith(System.String,System.String)">
+            <summary>
+            Asserts that a string starts with another string.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The string to be examined</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.DoesNotStartWith(System.String,System.String,System.String,System.Object[])">
+            <summary>
+            Asserts that a string does not start with another string.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The string to be examined</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Arguments used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.DoesNotStartWith(System.String,System.String,System.String)">
+            <summary>
+            Asserts that a string does not start with another string.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The string to be examined</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.DoesNotStartWith(System.String,System.String)">
+            <summary>
+            Asserts that a string does not start with another string.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The string to be examined</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.EndsWith(System.String,System.String,System.String,System.Object[])">
+            <summary>
+            Asserts that a string ends with another string.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The string to be examined</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Arguments used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.EndsWith(System.String,System.String,System.String)">
+            <summary>
+            Asserts that a string ends with another string.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The string to be examined</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.EndsWith(System.String,System.String)">
+            <summary>
+            Asserts that a string ends with another string.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The string to be examined</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.DoesNotEndWith(System.String,System.String,System.String,System.Object[])">
+            <summary>
+            Asserts that a string does not end with another string.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The string to be examined</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Arguments used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.DoesNotEndWith(System.String,System.String,System.String)">
+            <summary>
+            Asserts that a string does not end with another string.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The string to be examined</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.DoesNotEndWith(System.String,System.String)">
+            <summary>
+            Asserts that a string does not end with another string.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The string to be examined</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.AreEqualIgnoringCase(System.String,System.String,System.String,System.Object[])">
+            <summary>
+            Asserts that two strings are equal, without regard to case.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The actual string</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Arguments used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.AreEqualIgnoringCase(System.String,System.String,System.String)">
+            <summary>
+            Asserts that two strings are equal, without regard to case.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The actual string</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.AreEqualIgnoringCase(System.String,System.String)">
+            <summary>
+            Asserts that two strings are equal, without regard to case.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The actual string</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.AreNotEqualIgnoringCase(System.String,System.String,System.String,System.Object[])">
+            <summary>
+            Asserts that two strings are not equal, without regard to case.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The actual string</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Arguments used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.AreNotEqualIgnoringCase(System.String,System.String,System.String)">
+            <summary>
+            Asserts that two strings are Notequal, without regard to case.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The actual string</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.AreNotEqualIgnoringCase(System.String,System.String)">
+            <summary>
+            Asserts that two strings are not equal, without regard to case.
+            </summary>
+            <param name="expected">The expected string</param>
+            <param name="actual">The actual string</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.IsMatch(System.String,System.String,System.String,System.Object[])">
+            <summary>
+            Asserts that a string matches an expected regular expression pattern.
+            </summary>
+            <param name="pattern">The regex pattern to be matched</param>
+            <param name="actual">The actual string</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Arguments used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.IsMatch(System.String,System.String,System.String)">
+            <summary>
+            Asserts that a string matches an expected regular expression pattern.
+            </summary>
+            <param name="pattern">The regex pattern to be matched</param>
+            <param name="actual">The actual string</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.IsMatch(System.String,System.String)">
+            <summary>
+            Asserts that a string matches an expected regular expression pattern.
+            </summary>
+            <param name="pattern">The regex pattern to be matched</param>
+            <param name="actual">The actual string</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.DoesNotMatch(System.String,System.String,System.String,System.Object[])">
+            <summary>
+            Asserts that a string does not match an expected regular expression pattern.
+            </summary>
+            <param name="pattern">The regex pattern to be used</param>
+            <param name="actual">The actual string</param>
+            <param name="message">The message to display in case of failure</param>
+            <param name="args">Arguments used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.DoesNotMatch(System.String,System.String,System.String)">
+            <summary>
+            Asserts that a string does not match an expected regular expression pattern.
+            </summary>
+            <param name="pattern">The regex pattern to be used</param>
+            <param name="actual">The actual string</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.StringAssert.DoesNotMatch(System.String,System.String)">
+            <summary>
+            Asserts that a string does not match an expected regular expression pattern.
+            </summary>
+            <param name="pattern">The regex pattern to be used</param>
+            <param name="actual">The actual string</param>
+        </member>
+        <member name="T:NUnit.Framework.TestCaseData">
+            <summary>
+            The TestCaseData class represents a set of arguments
+            and other parameter info to be used for a parameterized
+            test case. It provides a number of instance modifiers
+            for use in initializing the test case.
+            
+            Note: Instance modifiers are getters that return
+            the same instance after modifying it's state.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestCaseData.arguments">
+            <summary>
+            The argument list to be provided to the test
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestCaseData.result">
+            <summary>
+            The expected result to be returned
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestCaseData.expectedExceptionType">
+            <summary>
+             The expected exception Type
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestCaseData.expectedExceptionName">
+            <summary>
+            The FullName of the expected exception
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestCaseData.testName">
+            <summary>
+            The name to be used for the test
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestCaseData.description">
+            <summary>
+            The description of the test
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestCaseData.properties">
+            <summary>
+            A dictionary of properties, used to add information
+            to tests without requiring the class to change.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestCaseData.isIgnored">
+            <summary>
+            If true, indicates that the test case is to be ignored
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestCaseData.ignoreReason">
+            <summary>
+            The reason for ignoring a test case
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseData.#ctor(System.Object[])">
+            <summary>
+            Initializes a new instance of the <see cref="T:TestCaseData"/> class.
+            </summary>
+            <param name="args">The arguments.</param>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseData.#ctor(System.Object)">
+            <summary>
+            Initializes a new instance of the <see cref="T:TestCaseData"/> class.
+            </summary>
+            <param name="arg">The argument.</param>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseData.#ctor(System.Object,System.Object)">
+            <summary>
+            Initializes a new instance of the <see cref="T:TestCaseData"/> class.
+            </summary>
+            <param name="arg1">The first argument.</param>
+            <param name="arg2">The second argument.</param>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseData.#ctor(System.Object,System.Object,System.Object)">
+            <summary>
+            Initializes a new instance of the <see cref="T:TestCaseData"/> class.
+            </summary>
+            <param name="arg1">The first argument.</param>
+            <param name="arg2">The second argument.</param>
+            <param name="arg3">The third argument.</param>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseData.Returns(System.Object)">
+            <summary>
+            Sets the expected result for the test
+            </summary>
+            <param name="result">The expected result</param>
+            <returns>A modified TestCaseData</returns>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseData.Throws(System.Type)">
+            <summary>
+            Sets the expected exception type for the test
+            </summary>
+            <param name="exceptionType">Type of the expected exception.</param>
+            <returns>The modified TestCaseData instance</returns>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseData.Throws(System.String)">
+            <summary>
+            Sets the expected exception type for the test
+            </summary>
+            <param name="exceptionName">FullName of the expected exception.</param>
+            <returns>The modified TestCaseData instance</returns>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseData.SetName(System.String)">
+            <summary>
+            Sets the name of the test case
+            </summary>
+            <returns>The modified TestCaseData instance</returns>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseData.SetDescription(System.String)">
+            <summary>
+            Sets the description for the test case
+            being constructed.
+            </summary>
+            <param name="description">The description.</param>
+            <returns>The modified TestCaseData instance.</returns>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseData.SetCategory(System.String)">
+            <summary>
+            Applies a category to the test
+            </summary>
+            <param name="category"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseData.SetProperty(System.String,System.String)">
+            <summary>
+            Applies a named property to the test
+            </summary>
+            <param name="propName"></param>
+            <param name="propValue"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseData.SetProperty(System.String,System.Int32)">
+            <summary>
+            Applies a named property to the test
+            </summary>
+            <param name="propName"></param>
+            <param name="propValue"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseData.SetProperty(System.String,System.Double)">
+            <summary>
+            Applies a named property to the test
+            </summary>
+            <param name="propName"></param>
+            <param name="propValue"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseData.Ignore">
+            <summary>
+            Ignores this TestCase.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseData.Ignore(System.String)">
+            <summary>
+            Ignores this TestCase, specifying the reason.
+            </summary>
+            <param name="reason">The reason.</param>
+            <returns></returns>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseData.Arguments">
+            <summary>
+            Gets the argument list to be provided to the test
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseData.Result">
+            <summary>
+            Gets the expected result
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseData.ExpectedException">
+            <summary>
+             Gets the expected exception Type
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseData.ExpectedExceptionName">
+            <summary>
+            Gets the FullName of the expected exception
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseData.TestName">
+            <summary>
+            Gets the name to be used for the test
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseData.Description">
+            <summary>
+            Gets the description of the test
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseData.Ignored">
+            <summary>
+            Gets a value indicating whether this <see cref="T:NUnit.Framework.ITestCaseData"/> is ignored.
+            </summary>
+            <value><c>true</c> if ignored; otherwise, <c>false</c>.</value>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseData.IgnoreReason">
+            <summary>
+            Gets the ignore reason.
+            </summary>
+            <value>The ignore reason.</value>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseData.Categories">
+            <summary>
+            Gets a list of categories associated with this test.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseData.Properties">
+            <summary>
+            Gets the property dictionary for this test
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.TestContext">
+            <summary>
+            Provide the context information of the current test
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.TestContext.#ctor(System.Collections.IDictionary)">
+            <summary>
+            Constructs a TestContext using the provided context dictionary
+            </summary>
+            <param name="context">A context dictionary</param>
+        </member>
+        <member name="P:NUnit.Framework.TestContext.CurrentContext">
+            <summary>
+            Get the current test context. This is created
+            as needed. The user may save the context for
+            use within a test, but it should not be used
+            outside the test for which it is created.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestContext.Test">
+            <summary>
+            Gets a TestAdapter representing the currently executing test in this context.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestContext.Result">
+            <summary>
+            Gets a ResultAdapter representing the current result for the test 
+            executing in this context.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestContext.TestDirectory">
+            <summary>
+            Gets the current directory for this TestContext
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.TestContext.TestAdapter">
+            <summary>
+            TestAdapter adapts a Test for consumption by
+            the user test code.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.TestContext.TestAdapter.#ctor(System.Collections.IDictionary)">
+            <summary>
+            Constructs a TestAdapter for this context
+            </summary>
+            <param name="context">The context dictionary</param>
+        </member>
+        <member name="P:NUnit.Framework.TestContext.TestAdapter.Name">
+            <summary>
+            The name of the test.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestContext.TestAdapter.FullName">
+            <summary>
+            The FullName of the test
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestContext.TestAdapter.Properties">
+            <summary>
+            The properties of the test.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.TestContext.ResultAdapter">
+            <summary>
+            ResultAdapter adapts a TestResult for consumption by
+            the user test code.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.TestContext.ResultAdapter.#ctor(System.Collections.IDictionary)">
+            <summary>
+            Construct a ResultAdapter for a context
+            </summary>
+            <param name="context">The context holding the result</param>
+        </member>
+        <member name="P:NUnit.Framework.TestContext.ResultAdapter.State">
+            <summary>
+            The TestState of current test. This maps to the ResultState
+            used in nunit.core and is subject to change in the future.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestContext.ResultAdapter.Status">
+            <summary>
+            The TestStatus of current test. This enum will be used
+            in future versions of NUnit and so is to be preferred
+            to the TestState value.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.TestState">
+            <summary>
+            The ResultState enum indicates the result of running a test
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestState.Inconclusive">
+            <summary>
+            The result is inconclusive
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestState.NotRunnable">
+            <summary>
+            The test was not runnable.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestState.Skipped">
+            <summary>
+            The test has been skipped. 
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestState.Ignored">
+            <summary>
+            The test has been ignored.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestState.Success">
+            <summary>
+            The test succeeded
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestState.Failure">
+            <summary>
+            The test failed
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestState.Error">
+            <summary>
+            The test encountered an unexpected exception
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestState.Cancelled">
+            <summary>
+            The test was cancelled by the user
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.TestStatus">
+            <summary>
+            The TestStatus enum indicates the result of running a test
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestStatus.Inconclusive">
+            <summary>
+            The test was inconclusive
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestStatus.Skipped">
+            <summary>
+            The test has skipped 
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestStatus.Passed">
+            <summary>
+            The test succeeded
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestStatus.Failed">
+            <summary>
+            The test failed
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Text">
+            <summary>
+            Helper class with static methods used to supply constraints
+            that operate on strings.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Text.Contains(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value contains the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Text.DoesNotContain(System.String)">
+            <summary>
+            Returns a constraint that fails if the actual
+            value contains the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Text.StartsWith(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value starts with the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Text.DoesNotStartWith(System.String)">
+            <summary>
+            Returns a constraint that fails if the actual
+            value starts with the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Text.EndsWith(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value ends with the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Text.DoesNotEndWith(System.String)">
+            <summary>
+            Returns a constraint that fails if the actual
+            value ends with the substring supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Text.Matches(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value matches the Regex pattern supplied as an argument.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Text.DoesNotMatch(System.String)">
+            <summary>
+            Returns a constraint that fails if the actual
+            value matches the pattern supplied as an argument.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Text.All">
+            <summary>
+            Returns a ConstraintExpression, which will apply
+            the following constraint to all members of a collection,
+            succeeding if all of them succeed.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.TextMessageWriter">
+            <summary>
+            TextMessageWriter writes constraint descriptions and messages
+            in displayable form as a text stream. It tailors the display
+            of individual message components to form the standard message
+            format of NUnit assertion failure messages.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TextMessageWriter.Pfx_Expected">
+            <summary>
+            Prefix used for the expected value line of a message
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TextMessageWriter.Pfx_Actual">
+            <summary>
+            Prefix used for the actual value line of a message
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TextMessageWriter.PrefixLength">
+            <summary>
+            Length of a message prefix
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.TextMessageWriter.#ctor">
+            <summary>
+            Construct a TextMessageWriter
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.TextMessageWriter.#ctor(System.String,System.Object[])">
+            <summary>
+            Construct a TextMessageWriter, specifying a user message
+            and optional formatting arguments.
+            </summary>
+            <param name="userMessage"></param>
+            <param name="args"></param>
+        </member>
+        <member name="M:NUnit.Framework.TextMessageWriter.WriteMessageLine(System.Int32,System.String,System.Object[])">
+            <summary>
+            Method to write single line  message with optional args, usually
+            written to precede the general failure message, at a givel 
+            indentation level.
+            </summary>
+            <param name="level">The indentation level of the message</param>
+            <param name="message">The message to be written</param>
+            <param name="args">Any arguments used in formatting the message</param>
+        </member>
+        <member name="M:NUnit.Framework.TextMessageWriter.DisplayDifferences(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Display Expected and Actual lines for a constraint. This
+            is called by MessageWriter's default implementation of 
+            WriteMessageTo and provides the generic two-line display. 
+            </summary>
+            <param name="constraint">The constraint that failed</param>
+        </member>
+        <member name="M:NUnit.Framework.TextMessageWriter.DisplayDifferences(System.Object,System.Object)">
+            <summary>
+            Display Expected and Actual lines for given values. This
+            method may be called by constraints that need more control over
+            the display of actual and expected values than is provided
+            by the default implementation.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value causing the failure</param>
+        </member>
+        <member name="M:NUnit.Framework.TextMessageWriter.DisplayDifferences(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance)">
+            <summary>
+            Display Expected and Actual lines for given values, including
+            a tolerance value on the expected line.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="actual">The actual value causing the failure</param>
+            <param name="tolerance">The tolerance within which the test was made</param>
+        </member>
+        <member name="M:NUnit.Framework.TextMessageWriter.DisplayStringDifferences(System.String,System.String,System.Int32,System.Boolean,System.Boolean)">
+            <summary>
+            Display the expected and actual string values on separate lines.
+            If the mismatch parameter is >=0, an additional line is displayed
+            line containing a caret that points to the mismatch point.
+            </summary>
+            <param name="expected">The expected string value</param>
+            <param name="actual">The actual string value</param>
+            <param name="mismatch">The point at which the strings don't match or -1</param>
+            <param name="ignoreCase">If true, case is ignored in string comparisons</param>
+            <param name="clipping">If true, clip the strings to fit the max line length</param>
+        </member>
+        <member name="M:NUnit.Framework.TextMessageWriter.WriteConnector(System.String)">
+            <summary>
+            Writes the text for a connector.
+            </summary>
+            <param name="connector">The connector.</param>
+        </member>
+        <member name="M:NUnit.Framework.TextMessageWriter.WritePredicate(System.String)">
+            <summary>
+            Writes the text for a predicate.
+            </summary>
+            <param name="predicate">The predicate.</param>
+        </member>
+        <member name="M:NUnit.Framework.TextMessageWriter.WriteModifier(System.String)">
+            <summary>
+            Write the text for a modifier.
+            </summary>
+            <param name="modifier">The modifier.</param>
+        </member>
+        <member name="M:NUnit.Framework.TextMessageWriter.WriteExpectedValue(System.Object)">
+            <summary>
+            Writes the text for an expected value.
+            </summary>
+            <param name="expected">The expected value.</param>
+        </member>
+        <member name="M:NUnit.Framework.TextMessageWriter.WriteActualValue(System.Object)">
+            <summary>
+            Writes the text for an actual value.
+            </summary>
+            <param name="actual">The actual value.</param>
+        </member>
+        <member name="M:NUnit.Framework.TextMessageWriter.WriteValue(System.Object)">
+            <summary>
+            Writes the text for a generalized value.
+            </summary>
+            <param name="val">The value.</param>
+        </member>
+        <member name="M:NUnit.Framework.TextMessageWriter.WriteCollectionElements(System.Collections.ICollection,System.Int32,System.Int32)">
+            <summary>
+            Writes the text for a collection value,
+            starting at a particular point, to a max length
+            </summary>
+            <param name="collection">The collection containing elements to write.</param>
+            <param name="start">The starting point of the elements to write</param>
+            <param name="max">The maximum number of elements to write</param>
+        </member>
+        <member name="M:NUnit.Framework.TextMessageWriter.WriteExpectedLine(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Write the generic 'Expected' line for a constraint
+            </summary>
+            <param name="constraint">The constraint that failed</param>
+        </member>
+        <member name="M:NUnit.Framework.TextMessageWriter.WriteExpectedLine(System.Object)">
+            <summary>
+            Write the generic 'Expected' line for a given value
+            </summary>
+            <param name="expected">The expected value</param>
+        </member>
+        <member name="M:NUnit.Framework.TextMessageWriter.WriteExpectedLine(System.Object,NUnit.Framework.Constraints.Tolerance)">
+            <summary>
+            Write the generic 'Expected' line for a given value
+            and tolerance.
+            </summary>
+            <param name="expected">The expected value</param>
+            <param name="tolerance">The tolerance within which the test was made</param>
+        </member>
+        <member name="M:NUnit.Framework.TextMessageWriter.WriteActualLine(NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Write the generic 'Actual' line for a constraint
+            </summary>
+            <param name="constraint">The constraint for which the actual value is to be written</param>
+        </member>
+        <member name="M:NUnit.Framework.TextMessageWriter.WriteActualLine(System.Object)">
+            <summary>
+            Write the generic 'Actual' line for a given value
+            </summary>
+            <param name="actual">The actual value causing a failure</param>
+        </member>
+        <member name="P:NUnit.Framework.TextMessageWriter.MaxLineLength">
+            <summary>
+            Gets or sets the maximum line length for this writer
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Throws">
+            <summary>
+            Helper class with properties and methods that supply
+            constraints that operate on exceptions.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Throws.TypeOf(System.Type)">
+            <summary>
+            Creates a constraint specifying the exact type of exception expected
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Throws.TypeOf``1">
+            <summary>
+            Creates a constraint specifying the exact type of exception expected
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Throws.InstanceOf(System.Type)">
+            <summary>
+            Creates a constraint specifying the type of exception expected
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Throws.InstanceOf``1">
+            <summary>
+            Creates a constraint specifying the type of exception expected
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Throws.Exception">
+            <summary>
+            Creates a constraint specifying an expected exception
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Throws.InnerException">
+            <summary>
+            Creates a constraint specifying an exception with a given InnerException
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Throws.TargetInvocationException">
+            <summary>
+            Creates a constraint specifying an expected TargetInvocationException
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Throws.ArgumentException">
+            <summary>
+            Creates a constraint specifying an expected TargetInvocationException
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Throws.InvalidOperationException">
+            <summary>
+            Creates a constraint specifying an expected TargetInvocationException
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Throws.Nothing">
+            <summary>
+            Creates a constraint specifying that no exception is thrown
+            </summary>
+        </member>
+    </members>
+</doc>

diff --git a/trunk/packages/NUnit.2.5.10.11092/lib/nunit.mocks.dll b/trunk/packages/NUnit.2.5.10.11092/lib/nunit.mocks.dll
new file mode 100644 (file)
index 0000000..6ee2c1c
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/lib/nunit.mocks.dll differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/lib/pnunit.framework.dll b/trunk/packages/NUnit.2.5.10.11092/lib/pnunit.framework.dll
new file mode 100644 (file)
index 0000000..6c105d7
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/lib/pnunit.framework.dll differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/license.txt b/trunk/packages/NUnit.2.5.10.11092/license.txt
new file mode 100644 (file)
index 0000000..66a5ebf
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/license.txt
@@ -0,0 +1,15 @@
+Copyright © 2002-2008 Charlie Poole
+Copyright © 2002-2004 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov
+Copyright © 2000-2002 Philip A. Craig
+
+This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment (see the following) in the product documentation is required.
+
+Portions Copyright © 2002-2008 Charlie Poole or Copyright © 2002-2004 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov or Copyright © 2000-2002 Philip A. Craig
+
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source distribution.

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/NUnitTests.VisualState.xml b/trunk/packages/NUnit.2.5.10.11092/tools/NUnitTests.VisualState.xml
new file mode 100644 (file)
index 0000000..d975dcd
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/tools/NUnitTests.VisualState.xml
@@ -0,0 +1,124 @@
+<?xml version="1.0" encoding="utf-8"?>
+<VisualState xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" ShowCheckBoxes="false">
+  <TopNode>[0-1000]D:\Dev\NUnit\nunit-2.5\work\build\net\2.0\release\NUnitTests.nunit</TopNode>
+  <SelectedNode>[0-1000]D:\Dev\NUnit\nunit-2.5\work\build\net\2.0\release\NUnitTests.nunit</SelectedNode>
+  <ExcludeCategories>false</ExcludeCategories>
+  <Nodes>
+    <Node UniqueName="[0-1000]D:\Dev\NUnit\nunit-2.5\work\build\net\2.0\release\NUnitTests.nunit" Expanded="true" />
+    <Node UniqueName="[0-2832]D:\Dev\NUnit\nunit-2.5\work\build\net\2.0\release\tests/nunit.framework.tests.dll" Expanded="true" />
+    <Node UniqueName="[0-2833]NUnit" Expanded="true" />
+    <Node UniqueName="[0-2834]NUnit.Framework" Expanded="true" />
+    <Node UniqueName="[0-2835]NUnit.Framework.Constraints" Expanded="true" />
+    <Node UniqueName="[0-1001]NUnit.Framework.Constraints.AfterConstraintTest" Expanded="true" />
+    <Node UniqueName="[0-1023]NUnit.Framework.Constraints.AndTest" Expanded="true" />
+    <Node UniqueName="[0-1914]NUnit.Framework.Constraints.AssignableFromTest" Expanded="true" />
+    <Node UniqueName="[0-1924]NUnit.Framework.Constraints.AssignableToTest" Expanded="true" />
+    <Node UniqueName="[0-1934]NUnit.Framework.Constraints.AttributeExistsConstraintTest" Expanded="true" />
+    <Node UniqueName="[0-1697]NUnit.Framework.Constraints.BinarySerializableTest" Expanded="true" />
+    <Node UniqueName="[0-1144]NUnit.Framework.Constraints.ComparerTests" Expanded="true" />
+    <Node UniqueName="[0-1271]NUnit.Framework.Constraints.EmptyConstraintTest" Expanded="true" />
+    <Node UniqueName="[0-1806]NUnit.Framework.Constraints.EndsWithTest" Expanded="true" />
+    <Node UniqueName="[0-1826]NUnit.Framework.Constraints.EndsWithTestIgnoringCase" Expanded="true" />
+    <Node UniqueName="[0-1300]NUnit.Framework.Constraints.EqualConstraintTest" Expanded="true" />
+    <Node UniqueName="[0-1893]NUnit.Framework.Constraints.ExactTypeTest" Expanded="true" />
+    <Node UniqueName="[0-1060]NUnit.Framework.Constraints.FalseConstraintTest" Expanded="true" />
+    <Node UniqueName="[0-1196]NUnit.Framework.Constraints.GreaterThanOrEqualTest" Expanded="true" />
+    <Node UniqueName="[0-1176]NUnit.Framework.Constraints.GreaterThanTest" Expanded="true" />
+    <Node UniqueName="[0-1904]NUnit.Framework.Constraints.InstanceOfTypeTest" Expanded="true" />
+    <Node UniqueName="[0-1234]NUnit.Framework.Constraints.LessThanOrEqualTest" Expanded="true" />
+    <Node UniqueName="[0-1214]NUnit.Framework.Constraints.LessThanTest" Expanded="true" />
+    <Node UniqueName="[0-1398]NUnit.Framework.Constraints.MsgUtilTests" Expanded="true" />
+    <Node UniqueName="[0-1076]NUnit.Framework.Constraints.NaNConstraintTest" Expanded="true" />
+    <Node UniqueName="[0-1429]NUnit.Framework.Constraints.NotTest" Expanded="true" />
+    <Node UniqueName="[0-1035]NUnit.Framework.Constraints.NullConstraintTest" Expanded="true" />
+    <Node UniqueName="[0-1288]NUnit.Framework.Constraints.NullOrEmptyStringConstraintTest" Expanded="true" />
+    <Node UniqueName="[0-1443]NUnit.Framework.Constraints.NumericsTest" Expanded="true" />
+    <Node UniqueName="[0-1477]NUnit.Framework.Constraints.OrTest" Expanded="true" />
+    <Node UniqueName="[0-1643]NUnit.Framework.Constraints.PropertyExistsTest" Expanded="true" />
+    <Node UniqueName="[0-1660]NUnit.Framework.Constraints.PropertyTest" Expanded="true" />
+    <Node UniqueName="[0-1252]NUnit.Framework.Constraints.RangeConstraintTest" Expanded="true" />
+    <Node UniqueName="[0-1677]NUnit.Framework.Constraints.ReusableConstraintTests" Expanded="true" />
+    <Node UniqueName="[0-1684]NUnit.Framework.Constraints.SameAsTest" Expanded="true" />
+    <Node UniqueName="[0-1615]NUnit.Framework.Constraints.SamePathOrUnderTest_Linux" Expanded="true" />
+    <Node UniqueName="[0-1592]NUnit.Framework.Constraints.SamePathOrUnderTest_Windows" Expanded="true" />
+    <Node UniqueName="[0-1507]NUnit.Framework.Constraints.SamePathTest_Linux" Expanded="true" />
+    <Node UniqueName="[0-1488]NUnit.Framework.Constraints.SamePathTest_Windows" Expanded="true" />
+    <Node UniqueName="[0-1766]NUnit.Framework.Constraints.StartsWithTest" Expanded="true" />
+    <Node UniqueName="[0-1786]NUnit.Framework.Constraints.StartsWithTestIgnoringCase" Expanded="true" />
+    <Node UniqueName="[0-1559]NUnit.Framework.Constraints.SubPathTest_Linux" Expanded="true" />
+    <Node UniqueName="[0-1529]NUnit.Framework.Constraints.SubPathTest_Windows" Expanded="true" />
+    <Node UniqueName="[0-1728]NUnit.Framework.Constraints.SubstringTest" Expanded="true" />
+    <Node UniqueName="[0-1748]NUnit.Framework.Constraints.SubstringTestIgnoringCase" Expanded="true" />
+    <Node UniqueName="[0-1846]NUnit.Framework.Constraints.ThrowsConstraintTest_ExactType" Expanded="true" />
+    <Node UniqueName="[0-1859]NUnit.Framework.Constraints.ThrowsConstraintTest_InstanceOfType" Expanded="true" />
+    <Node UniqueName="[0-1873]NUnit.Framework.Constraints.ThrowsConstraintTest_WithConstraint" Expanded="true" />
+    <Node UniqueName="[0-1044]NUnit.Framework.Constraints.TrueConstraintTest" Expanded="true" />
+    <Node UniqueName="[0-1711]NUnit.Framework.Constraints.XmlSerializableTest" Expanded="true" />
+    <Node UniqueName="[0-2836]NUnit.Framework.Syntax" Expanded="true" />
+    <Node UniqueName="[0-2093]NUnit.Framework.Syntax.InvalidCodeTests" Expanded="true" />
+    <Node UniqueName="[0-2837]NUnit.Framework.Tests" Expanded="true" />
+    <Node UniqueName="[0-2772]NUnit.Framework.Tests.ValuesAttributeTests" Expanded="true" />
+    <Node UniqueName="[0-3878]D:\Dev\NUnit\nunit-2.5\work\build\net\2.0\release\tests/nunit.core.tests.dll" Expanded="true" />
+    <Node UniqueName="[0-3879]NUnit" Expanded="true" />
+    <Node UniqueName="[0-3880]NUnit.Core" Expanded="true" />
+    <Node UniqueName="[0-3881]NUnit.Core.Tests" Expanded="true" />
+    <Node UniqueName="[0-2919]NUnit.Core.Tests.CategoryAttributeTests" Expanded="true" />
+    <Node UniqueName="[0-2929]NUnit.Core.Tests.CombinatorialTests" Expanded="true" />
+    <Node UniqueName="[0-2998]NUnit.Core.Tests.CultureSettingAndDetectionTests" Expanded="true" />
+    <Node UniqueName="[0-3021]NUnit.Core.Tests.EventQueueTests" Expanded="true" />
+    <Node UniqueName="[0-3882]NUnit.Core.Tests.Generic" Expanded="true" />
+    <Node UniqueName="[0-2838]NUnit.Core.Tests.Generic.DeduceTypeArgsFromArgs&lt;T1,T2&gt;" Expanded="true" />
+    <Node UniqueName="[0-2839]NUnit.Core.Tests.Generic.DeduceTypeArgsFromArgs&lt;Double,Int32&gt;(100.0d,42)" Expanded="true" />
+    <Node UniqueName="[0-2842]NUnit.Core.Tests.Generic.DeduceTypeArgsFromArgs&lt;Int32,Double&gt;(42,100.0d)" Expanded="true" />
+    <Node UniqueName="[0-2845]NUnit.Core.Tests.Generic.SimpleGenericFixture&lt;TList&gt;" Expanded="true" />
+    <Node UniqueName="[0-2850]NUnit.Core.Tests.Generic.SimpleGenericMethods" Expanded="true" />
+    <Node UniqueName="[0-2866]NUnit.Core.Tests.Generic.TypeParameterUsedWithTestMethod&lt;T&gt;" Expanded="true" />
+    <Node UniqueName="[0-2867]NUnit.Core.Tests.Generic.TypeParameterUsedWithTestMethod&lt;Double&gt;" Expanded="true" />
+    <Node UniqueName="[0-3158]NUnit.Core.Tests.PairwiseTest" Expanded="true" />
+    <Node UniqueName="[0-3169]NUnit.Core.Tests.PairwiseTest+LiveTest" Expanded="true" />
+    <Node UniqueName="[0-3178]NUnit.Core.Tests.ParameterizedTestFixture" Expanded="true" />
+    <Node UniqueName="[0-3195]NUnit.Core.Tests.ParameterizedTestFixtureWithDataSources" Expanded="true" />
+    <Node UniqueName="[0-3196]NUnit.Core.Tests.ParameterizedTestFixtureWithDataSources(42)" Expanded="true" />
+    <Node UniqueName="[0-3188]NUnit.Core.Tests.ParameterizedTestFixtureWithNullArguments" Expanded="true" />
+    <Node UniqueName="[0-3297]NUnit.Core.Tests.RuntimeFrameworkTests" Expanded="true" />
+    <Node UniqueName="[0-3466]NUnit.Core.Tests.TestCaseAttributeTests" Expanded="true" />
+    <Node UniqueName="[0-3536]NUnit.Core.Tests.TestCaseSourceTests" Expanded="true" />
+    <Node UniqueName="[0-3753]NUnit.Core.Tests.TheoryTests" Expanded="true" />
+    <Node UniqueName="[0-3775]NUnit.Core.Tests.TheoryTests+SqrtTests_DisplayResults" Expanded="true" />
+    <Node UniqueName="[0-3817]NUnit.Core.Tests.TypeHelperTests" Expanded="true" />
+    <Node UniqueName="[0-3844]NUnit.Core.Tests.ValueSourceTests" Expanded="true" />
+    <Node UniqueName="[0-4250]D:\Dev\NUnit\nunit-2.5\work\build\net\2.0\release\tests/nunit.util.tests.dll" Expanded="true" />
+    <Node UniqueName="[0-4251]NUnit" Expanded="true" />
+    <Node UniqueName="[0-4252]NUnit.Util" Expanded="true" />
+    <Node UniqueName="[0-4134]NUnit.Util.Tests.ServiceManagerSetUpFixture" Expanded="true" />
+    <Node UniqueName="[0-4110]NUnit.Util.Tests.RuntimeFrameworkSelectorTests" Expanded="true" />
+    <Node UniqueName="[0-4302]D:\Dev\NUnit\nunit-2.5\work\build\net\2.0\release\tests/nunit.mocks.tests.dll" Expanded="true" />
+    <Node UniqueName="[0-4303]NUnit" Expanded="true" />
+    <Node UniqueName="[0-4304]NUnit.Mocks" Expanded="true" />
+    <Node UniqueName="[0-4305]NUnit.Mocks.Tests" Expanded="true" />
+    <Node UniqueName="[0-4361]D:\Dev\NUnit\nunit-2.5\work\build\net\2.0\release\tests/nunit-console.tests.dll" Expanded="true" />
+    <Node UniqueName="[0-4362]NUnit" Expanded="true" />
+    <Node UniqueName="[0-4363]NUnit.ConsoleRunner" Expanded="true" />
+    <Node UniqueName="[0-4364]NUnit.ConsoleRunner.Tests" Expanded="true" />
+    <Node UniqueName="[0-4345]NUnit.ConsoleRunner.Tests.TestNameParserTests" Expanded="true" />
+    <Node UniqueName="[0-4604]D:\Dev\NUnit\nunit-2.5\work\build\net\2.0\release\tests/nunit.uiexception.tests.dll" Expanded="true" />
+    <Node UniqueName="[0-4605]NUnit" Expanded="true" />
+    <Node UniqueName="[0-4606]NUnit.UiException" Expanded="true" />
+    <Node UniqueName="[0-4607]NUnit.UiException.Tests" Expanded="true" />
+    <Node UniqueName="[0-4608]NUnit.UiException.Tests.CodeFormatters" Expanded="true" />
+    <Node UniqueName="[0-4609]NUnit.UiException.Tests.Controls" Expanded="true" />
+    <Node UniqueName="[0-4610]NUnit.UiException.Tests.StackTraceAnalyzers" Expanded="true" />
+    <Node UniqueName="[0-4665]D:\Dev\NUnit\nunit-2.5\work\build\net\2.0\release\tests/nunit.uikit.tests.dll" Expanded="true" />
+    <Node UniqueName="[0-4666]NUnit" Expanded="true" />
+    <Node UniqueName="[0-4667]NUnit.UiKit" Expanded="true" />
+    <Node UniqueName="[0-4668]NUnit.UiKit.Tests" Expanded="true" />
+    <Node UniqueName="[0-4687]D:\Dev\NUnit\nunit-2.5\work\build\net\2.0\release\tests/nunit-gui.tests.dll" Expanded="true" />
+    <Node UniqueName="[0-4688]NUnit" Expanded="true" />
+    <Node UniqueName="[0-4689]NUnit.Gui" Expanded="true" />
+    <Node UniqueName="[0-4690]NUnit.Gui.Tests" Expanded="true" />
+    <Node UniqueName="[0-4699]D:\Dev\NUnit\nunit-2.5\work\build\net\2.0\release\tests/nunit.fixtures.tests.dll" Expanded="true" />
+    <Node UniqueName="[0-4700]NUnit" Expanded="true" />
+    <Node UniqueName="[0-4701]NUnit.Fixtures" Expanded="true" />
+    <Node UniqueName="[0-4702]NUnit.Fixtures.Tests" Expanded="true" />
+  </Nodes>
+</VisualState>
\ No newline at end of file

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/NUnitTests.config b/trunk/packages/NUnit.2.5.10.11092/tools/NUnitTests.config
new file mode 100644 (file)
index 0000000..fb15771
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/tools/NUnitTests.config
@@ -0,0 +1,85 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+<!--
+        This is the configuration file for the NUnitTests.nunit test project. You may
+        need to create a similar configuration file for your own test project. 
+ -->    
+
+<!--
+        The <NUnit> section is only needed if you want to use a non-default value
+        for any of the settings. It is commented out below. If you are going to use
+   it, you must deifne the NUnit section group and the sections you need.
+ 
+   The syntax shown here works for most runtimes. If NUnit fails at startup, you
+   can try specifying the name of the assembly containing the NameValueSectionHandler:
+   
+      <section name="TestCaseBuilder" type="System.Configuration.NameValueSectionHandler, System" />
+      
+   If that fails, try the fully qualified name of the assembly:
+   
+      <section name="TestCaseBuilder" type="System.Configuration.NameValueSectionHandler, System, 
+             Version=2.0.50727.832, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+             
+   Unfortunately, this last approach makes your config file non-portable across runtimes.
+   -->
+
+<!--
+  <configSections>
+               <sectionGroup name="NUnit">
+                       <section name="TestCaseBuilder" type="System.Configuration.NameValueSectionHandler"/>
+                       <section name="TestRunner" type="System.Configuration.NameValueSectionHandler"/>
+               </sectionGroup>
+       </configSections>
+ -->
+
+  <appSettings>
+               <!--   User application and configured property settings go here.-->
+               <!--   Example: <add key="settingName" value="settingValue"/> -->
+               <add key="test.setting" value="54321" />
+       </appSettings>
+
+<!-- Sample NUnit section group showing all default values -->
+<!--
+       <NUnit>
+               <TestCaseBuilder>
+                       <add key="OldStyleTestCases" value="false" />
+               </TestCaseBuilder>
+               <TestRunner>
+                       <add key="ApartmentState" value="MTA" />
+                       <add key="ThreadPriority" value="Normal" />
+      <add key="DefaultLogThreshold" value="Info" />
+               </TestRunner>
+       </NUnit>
+-->
+  
+   <!--
+    The following <runtime> section allows running nunit tests under 
+    .NET 1.0 by redirecting assemblies. The appliesTo attribute
+    causes the section to be ignored except under .NET 1.0.
+   --> 
+       <runtime>
+               <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1"
+                               appliesTo="v1.0.3705">
+                       <dependentAssembly>
+                               <assemblyIdentity name="System" publicKeyToken="b77a5c561934e089" culture="" />
+                               <bindingRedirect oldVersion="1.0.5000.0" newVersion="1.0.3300.0" />
+                       </dependentAssembly>
+                       <dependentAssembly>
+                               <assemblyIdentity name="System.Data" publicKeyToken="b77a5c561934e089" culture="" />
+                               <bindingRedirect oldVersion="1.0.5000.0" newVersion="1.0.3300.0" />
+                       </dependentAssembly>
+                       <dependentAssembly>
+                               <assemblyIdentity name="System.Drawing" publicKeyToken="b03f5f7f11d50a3a" culture="" />
+                               <bindingRedirect oldVersion="1.0.5000.0" newVersion="1.0.3300.0" />
+                       </dependentAssembly>
+                       <dependentAssembly>
+                               <assemblyIdentity name="System.Windows.Forms" publicKeyToken="b77a5c561934e089" culture="" />
+                               <bindingRedirect oldVersion="1.0.5000.0" newVersion="1.0.3300.0" />
+                       </dependentAssembly>
+                       <dependentAssembly>
+                               <assemblyIdentity name="System.Xml" publicKeyToken="b77a5c561934e089" culture="" />
+                               <bindingRedirect oldVersion="1.0.5000.0" newVersion="1.0.3300.0" />
+                       </dependentAssembly>
+               </assemblyBinding>
+       </runtime>
+</configuration> 

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/NUnitTests.nunit b/trunk/packages/NUnit.2.5.10.11092/tools/NUnitTests.nunit
new file mode 100644 (file)
index 0000000..e7bb7f4
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/tools/NUnitTests.nunit
@@ -0,0 +1,14 @@
+<NUnitProject>
+  <Settings appbase="."/>
+  <Config name="Default" binpath="lib;tests;framework" runtimeFramework="v2.0">
+    <assembly path="tests/nunit.framework.tests.dll" />
+    <assembly path="tests/nunit.core.tests.dll" />
+    <assembly path="tests/nunit.util.tests.dll" />
+    <assembly path="tests/nunit.mocks.tests.dll" />
+    <assembly path="tests/nunit-console.tests.dll" />
+    <assembly path="tests/nunit.uiexception.tests.dll" />
+    <assembly path="tests/nunit.uikit.tests.dll" />
+    <assembly path="tests/nunit-gui.tests.dll" />
+    <assembly path="tests/nunit.fixtures.tests.dll" />
+  </Config>
+</NUnitProject>

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/agent.conf b/trunk/packages/NUnit.2.5.10.11092/tools/agent.conf
new file mode 100644 (file)
index 0000000..ddbcd8e
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/tools/agent.conf
@@ -0,0 +1,4 @@
+<AgentConfig>
+  <Port>8080</Port>
+  <PathToAssemblies>.</PathToAssemblies>
+</AgentConfig>
\ No newline at end of file

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/agent.log.conf b/trunk/packages/NUnit.2.5.10.11092/tools/agent.log.conf
new file mode 100644 (file)
index 0000000..4bd90ca
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/tools/agent.log.conf
@@ -0,0 +1,18 @@
+<log4net>
+       <!-- A1 is set to be a ConsoleAppender -->
+       <appender name="A1" type="log4net.Appender.ConsoleAppender">
+
+               <!-- A1 uses PatternLayout -->
+               <layout type="log4net.Layout.PatternLayout">
+                       <!-- Print the date in ISO 8601 format -->
+                       <conversionPattern value="%-5level %logger - %message%newline" />
+               </layout>
+       </appender>
+       
+       <!-- Set root logger level to DEBUG and its only appender to A1 -->
+       <root>
+               <level value="DEBUG" />
+               <appender-ref ref="A1" />
+       </root>
+
+</log4net>

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/launcher.log.conf b/trunk/packages/NUnit.2.5.10.11092/tools/launcher.log.conf
new file mode 100644 (file)
index 0000000..4bd90ca
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/tools/launcher.log.conf
@@ -0,0 +1,18 @@
+<log4net>
+       <!-- A1 is set to be a ConsoleAppender -->
+       <appender name="A1" type="log4net.Appender.ConsoleAppender">
+
+               <!-- A1 uses PatternLayout -->
+               <layout type="log4net.Layout.PatternLayout">
+                       <!-- Print the date in ISO 8601 format -->
+                       <conversionPattern value="%-5level %logger - %message%newline" />
+               </layout>
+       </appender>
+       
+       <!-- Set root logger level to DEBUG and its only appender to A1 -->
+       <root>
+               <level value="DEBUG" />
+               <appender-ref ref="A1" />
+       </root>
+
+</log4net>

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/lib/Failure.png b/trunk/packages/NUnit.2.5.10.11092/tools/lib/Failure.png
new file mode 100644 (file)
index 0000000..2e400b2
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/tools/lib/Failure.png differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/lib/Ignored.png b/trunk/packages/NUnit.2.5.10.11092/tools/lib/Ignored.png
new file mode 100644 (file)
index 0000000..478efbf
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/tools/lib/Ignored.png differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/lib/Inconclusive.png b/trunk/packages/NUnit.2.5.10.11092/tools/lib/Inconclusive.png
new file mode 100644 (file)
index 0000000..4807b7c
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/tools/lib/Inconclusive.png differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/lib/Skipped.png b/trunk/packages/NUnit.2.5.10.11092/tools/lib/Skipped.png
new file mode 100644 (file)
index 0000000..7c9fc64
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/tools/lib/Skipped.png differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/lib/Success.png b/trunk/packages/NUnit.2.5.10.11092/tools/lib/Success.png
new file mode 100644 (file)
index 0000000..2a30150
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/tools/lib/Success.png differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/lib/fit.dll b/trunk/packages/NUnit.2.5.10.11092/tools/lib/fit.dll
new file mode 100644 (file)
index 0000000..40bbef0
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/tools/lib/fit.dll differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/lib/log4net.dll b/trunk/packages/NUnit.2.5.10.11092/tools/lib/log4net.dll
new file mode 100644 (file)
index 0000000..20a2e1c
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/tools/lib/log4net.dll differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit-console-runner.dll b/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit-console-runner.dll
new file mode 100644 (file)
index 0000000..1709ce7
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit-console-runner.dll differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit-gui-runner.dll b/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit-gui-runner.dll
new file mode 100644 (file)
index 0000000..35efa73
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit-gui-runner.dll differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit.core.dll b/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit.core.dll
new file mode 100644 (file)
index 0000000..a1dd698
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit.core.dll differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit.core.interfaces.dll b/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit.core.interfaces.dll
new file mode 100644 (file)
index 0000000..0ac8788
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit.core.interfaces.dll differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit.fixtures.dll b/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit.fixtures.dll
new file mode 100644 (file)
index 0000000..8fd1932
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit.fixtures.dll differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit.uiexception.dll b/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit.uiexception.dll
new file mode 100644 (file)
index 0000000..610c170
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit.uiexception.dll differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit.uikit.dll b/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit.uikit.dll
new file mode 100644 (file)
index 0000000..9087db2
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit.uikit.dll differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit.util.dll b/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit.util.dll
new file mode 100644 (file)
index 0000000..0b315c2
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/tools/lib/nunit.util.dll differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/nunit-agent-x86.exe.config b/trunk/packages/NUnit.2.5.10.11092/tools/nunit-agent-x86.exe.config
new file mode 100644 (file)
index 0000000..d840f37
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/tools/nunit-agent-x86.exe.config
@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  
+  <runtime>
+    <!-- We need this so test exceptions don't crash NUnit -->
+    <legacyUnhandledExceptionPolicy enabled="1" />
+
+    <!-- Look for addins in the addins directory for now -->
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <probing privatePath="lib;addins"/>
+   </assemblyBinding>
+
+    <!--
+    The following <assemblyBinding> section allows running nunit under 
+    .NET 1.0 by redirecting assemblies. The appliesTo attribute
+    causes the section to be ignored except under .NET 1.0
+    on a machine with only the .NET version 1.0 runtime installed.
+    If application and its tests were built for .NET 1.1 you will
+    also need to redirect system assemblies in the test config file,
+    which controls loading of the tests.
+   -->
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1"
+                       appliesTo="v1.0.3705">
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Data" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Drawing" 
+                          publicKeyToken="b03f5f7f11d50a3a" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Windows.Forms" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Xml" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+    </assemblyBinding>
+  
+  </runtime>
+  
+</configuration>
\ No newline at end of file

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/nunit-agent.exe.config b/trunk/packages/NUnit.2.5.10.11092/tools/nunit-agent.exe.config
new file mode 100644 (file)
index 0000000..d840f37
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/tools/nunit-agent.exe.config
@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  
+  <runtime>
+    <!-- We need this so test exceptions don't crash NUnit -->
+    <legacyUnhandledExceptionPolicy enabled="1" />
+
+    <!-- Look for addins in the addins directory for now -->
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <probing privatePath="lib;addins"/>
+   </assemblyBinding>
+
+    <!--
+    The following <assemblyBinding> section allows running nunit under 
+    .NET 1.0 by redirecting assemblies. The appliesTo attribute
+    causes the section to be ignored except under .NET 1.0
+    on a machine with only the .NET version 1.0 runtime installed.
+    If application and its tests were built for .NET 1.1 you will
+    also need to redirect system assemblies in the test config file,
+    which controls loading of the tests.
+   -->
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1"
+                       appliesTo="v1.0.3705">
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Data" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Drawing" 
+                          publicKeyToken="b03f5f7f11d50a3a" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Windows.Forms" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Xml" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+    </assemblyBinding>
+  
+  </runtime>
+  
+</configuration>
\ No newline at end of file

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/nunit-console-x86.exe.config b/trunk/packages/NUnit.2.5.10.11092/tools/nunit-console-x86.exe.config
new file mode 100644 (file)
index 0000000..fa0a262
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/tools/nunit-console-x86.exe.config
@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+
+  <runtime>
+    <!-- We need this so test exceptions don't crash NUnit -->
+    <legacyUnhandledExceptionPolicy enabled="1" />
+
+    <!-- Look for addins in the addins directory for now -->
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <probing privatePath="lib;addins"/>
+   </assemblyBinding>
+
+   <!--
+    The following <assemblyBinding> section allows running nunit under 
+    .NET 1.0 by redirecting assemblies. The appliesTo attribute
+    causes the section to be ignored except under .NET 1.0
+    on a machine with only the .NET version 1.0 runtime installed.
+    If application and its tests were built for .NET 1.1 you will
+    also need to redirect system assemblies in the test config file,
+    which controls loading of the tests.
+   -->
+   <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1"
+                       appliesTo="v1.0.3705">
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Data" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Drawing" 
+                          publicKeyToken="b03f5f7f11d50a3a" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Windows.Forms" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Xml" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+    </assemblyBinding>
+
+  </runtime>
+  
+</configuration>
\ No newline at end of file

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/nunit-console.exe.config b/trunk/packages/NUnit.2.5.10.11092/tools/nunit-console.exe.config
new file mode 100644 (file)
index 0000000..fa0a262
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/tools/nunit-console.exe.config
@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+
+  <runtime>
+    <!-- We need this so test exceptions don't crash NUnit -->
+    <legacyUnhandledExceptionPolicy enabled="1" />
+
+    <!-- Look for addins in the addins directory for now -->
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <probing privatePath="lib;addins"/>
+   </assemblyBinding>
+
+   <!--
+    The following <assemblyBinding> section allows running nunit under 
+    .NET 1.0 by redirecting assemblies. The appliesTo attribute
+    causes the section to be ignored except under .NET 1.0
+    on a machine with only the .NET version 1.0 runtime installed.
+    If application and its tests were built for .NET 1.1 you will
+    also need to redirect system assemblies in the test config file,
+    which controls loading of the tests.
+   -->
+   <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1"
+                       appliesTo="v1.0.3705">
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Data" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Drawing" 
+                          publicKeyToken="b03f5f7f11d50a3a" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Windows.Forms" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Xml" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+    </assemblyBinding>
+
+  </runtime>
+  
+</configuration>
\ No newline at end of file

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/nunit-x86.exe.config b/trunk/packages/NUnit.2.5.10.11092/tools/nunit-x86.exe.config
new file mode 100644 (file)
index 0000000..1641a50
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/tools/nunit-x86.exe.config
@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <!--
+     Application settings for NUnit-gui.exe. Do NOT put settings
+        for use by your tests here.
+       -->
+  <appSettings>
+    <!--
+     Uncomment to specify the url to be used for help. If not used, the
+     default value is something like
+               file://localhost/C:/Program Files/NUnit 2.2/doc/index.html
+        This setting is provided in case your default browser doesn't
+        support this format.
+       -->
+    <!-- <add key="helpUrl" value="http://www.nunit.org" /> -->
+  </appSettings>
+
+  <runtime>
+    <!-- We need this so test exceptions don't crash NUnit -->
+    <legacyUnhandledExceptionPolicy enabled="1" />
+
+    <!-- Look for addins in the addins directory for now -->
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <probing privatePath="lib;addins" />
+    </assemblyBinding>
+
+    <!--
+    The following <assemblyBinding> section allows running nunit under 
+    .NET 1.0 by redirecting assemblies. The appliesTo attribute
+    causes the section to be ignored except under .NET 1.0
+    on a machine with only the .NET version 1.0 runtime installed.
+    If application and its tests were built for .NET 1.1 you will
+    also need to redirect system assemblies in the test config file,
+    which controls loading of the tests.
+   -->
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1"
+       appliesTo="v1.0.3705">
+
+      <dependentAssembly>
+        <assemblyIdentity name="System"
+                          publicKeyToken="b77a5c561934e089"
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0"
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly>
+        <assemblyIdentity name="System.Data"
+                          publicKeyToken="b77a5c561934e089"
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0"
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly>
+        <assemblyIdentity name="System.Drawing"
+                          publicKeyToken="b03f5f7f11d50a3a"
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0"
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly>
+        <assemblyIdentity name="System.Windows.Forms"
+                          publicKeyToken="b77a5c561934e089"
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0"
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly>
+        <assemblyIdentity name="System.Xml"
+                          publicKeyToken="b77a5c561934e089"
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0"
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+    </assemblyBinding>
+
+  </runtime>
+
+</configuration>
\ No newline at end of file

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/nunit.exe.config b/trunk/packages/NUnit.2.5.10.11092/tools/nunit.exe.config
new file mode 100644 (file)
index 0000000..1641a50
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/tools/nunit.exe.config
@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <!--
+     Application settings for NUnit-gui.exe. Do NOT put settings
+        for use by your tests here.
+       -->
+  <appSettings>
+    <!--
+     Uncomment to specify the url to be used for help. If not used, the
+     default value is something like
+               file://localhost/C:/Program Files/NUnit 2.2/doc/index.html
+        This setting is provided in case your default browser doesn't
+        support this format.
+       -->
+    <!-- <add key="helpUrl" value="http://www.nunit.org" /> -->
+  </appSettings>
+
+  <runtime>
+    <!-- We need this so test exceptions don't crash NUnit -->
+    <legacyUnhandledExceptionPolicy enabled="1" />
+
+    <!-- Look for addins in the addins directory for now -->
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <probing privatePath="lib;addins" />
+    </assemblyBinding>
+
+    <!--
+    The following <assemblyBinding> section allows running nunit under 
+    .NET 1.0 by redirecting assemblies. The appliesTo attribute
+    causes the section to be ignored except under .NET 1.0
+    on a machine with only the .NET version 1.0 runtime installed.
+    If application and its tests were built for .NET 1.1 you will
+    also need to redirect system assemblies in the test config file,
+    which controls loading of the tests.
+   -->
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1"
+       appliesTo="v1.0.3705">
+
+      <dependentAssembly>
+        <assemblyIdentity name="System"
+                          publicKeyToken="b77a5c561934e089"
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0"
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly>
+        <assemblyIdentity name="System.Data"
+                          publicKeyToken="b77a5c561934e089"
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0"
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly>
+        <assemblyIdentity name="System.Drawing"
+                          publicKeyToken="b03f5f7f11d50a3a"
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0"
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly>
+        <assemblyIdentity name="System.Windows.Forms"
+                          publicKeyToken="b77a5c561934e089"
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0"
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly>
+        <assemblyIdentity name="System.Xml"
+                          publicKeyToken="b77a5c561934e089"
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0"
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+    </assemblyBinding>
+
+  </runtime>
+
+</configuration>
\ No newline at end of file

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/nunit.framework.dll b/trunk/packages/NUnit.2.5.10.11092/tools/nunit.framework.dll
new file mode 100644 (file)
index 0000000..6856e51
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/tools/nunit.framework.dll differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/pnunit-agent.exe.config b/trunk/packages/NUnit.2.5.10.11092/tools/pnunit-agent.exe.config
new file mode 100644 (file)
index 0000000..0bf29b3
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/tools/pnunit-agent.exe.config
@@ -0,0 +1,77 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<configuration>
+
+  <!-- Set the level for tracing NUnit itself -->
+  <!-- 0=Off 1=Error 2=Warning 3=Info 4=Debug -->
+  <system.diagnostics>
+         <switches>
+      <add name="NTrace" value="0" />
+         </switches>
+  </system.diagnostics>
+  
+  <runtime>
+    <!-- We need this so test exceptions don't crash NUnit -->
+    <legacyUnhandledExceptionPolicy enabled="1" />
+
+    <!-- Look for addins in the addins directory for now -->
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <probing privatePath="framework;lib;addins"/>
+   </assemblyBinding>
+
+    <!--
+    The following <assemblyBinding> section allows running nunit under 
+    .NET 1.0 by redirecting assemblies. The appliesTo attribute
+    causes the section to be ignored except under .NET 1.0
+    on a machine with only the .NET version 1.0 runtime installed.
+    If application and its tests were built for .NET 1.1 you will
+    also need to redirect system assemblies in the test config file,
+    which controls loading of the tests.
+   -->
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1"
+                       appliesTo="v1.0.3705">
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Data" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Drawing" 
+                          publicKeyToken="b03f5f7f11d50a3a" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Windows.Forms" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Xml" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+    </assemblyBinding>
+  
+  </runtime>
+  
+</configuration>
\ No newline at end of file

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/pnunit-launcher.exe.config b/trunk/packages/NUnit.2.5.10.11092/tools/pnunit-launcher.exe.config
new file mode 100644 (file)
index 0000000..0bf29b3
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/tools/pnunit-launcher.exe.config
@@ -0,0 +1,77 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<configuration>
+
+  <!-- Set the level for tracing NUnit itself -->
+  <!-- 0=Off 1=Error 2=Warning 3=Info 4=Debug -->
+  <system.diagnostics>
+         <switches>
+      <add name="NTrace" value="0" />
+         </switches>
+  </system.diagnostics>
+  
+  <runtime>
+    <!-- We need this so test exceptions don't crash NUnit -->
+    <legacyUnhandledExceptionPolicy enabled="1" />
+
+    <!-- Look for addins in the addins directory for now -->
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <probing privatePath="framework;lib;addins"/>
+   </assemblyBinding>
+
+    <!--
+    The following <assemblyBinding> section allows running nunit under 
+    .NET 1.0 by redirecting assemblies. The appliesTo attribute
+    causes the section to be ignored except under .NET 1.0
+    on a machine with only the .NET version 1.0 runtime installed.
+    If application and its tests were built for .NET 1.1 you will
+    also need to redirect system assemblies in the test config file,
+    which controls loading of the tests.
+   -->
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1"
+                       appliesTo="v1.0.3705">
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Data" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Drawing" 
+                          publicKeyToken="b03f5f7f11d50a3a" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Windows.Forms" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+      <dependentAssembly> 
+        <assemblyIdentity name="System.Xml" 
+                          publicKeyToken="b77a5c561934e089" 
+                          culture="neutral"/>
+        <bindingRedirect  oldVersion="1.0.5000.0" 
+                          newVersion="1.0.3300.0"/>
+      </dependentAssembly>
+
+    </assemblyBinding>
+  
+  </runtime>
+  
+</configuration>
\ No newline at end of file

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/pnunit.framework.dll b/trunk/packages/NUnit.2.5.10.11092/tools/pnunit.framework.dll
new file mode 100644 (file)
index 0000000..6c105d7
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/tools/pnunit.framework.dll differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/pnunit.tests.dll b/trunk/packages/NUnit.2.5.10.11092/tools/pnunit.tests.dll
new file mode 100644 (file)
index 0000000..dce018a
Binary files /dev/null and b/trunk/packages/NUnit.2.5.10.11092/tools/pnunit.tests.dll differ

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/runFile.exe.config b/trunk/packages/NUnit.2.5.10.11092/tools/runFile.exe.config
new file mode 100644 (file)
index 0000000..f58f099
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/tools/runFile.exe.config
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+  <startup>
+         <supportedRuntime version="v2.0.50727" />
+         <supportedRuntime version="v2.0.50215" />
+         <supportedRuntime version="v2.0.40607" />
+         <supportedRuntime version="v1.1.4322" />
+         <supportedRuntime version="v1.0.3705" />
+       
+         <requiredRuntime version="v1.0.3705" />
+  </startup>
+
+<!--
+     The following <runtime> section allows running nunit tests under 
+     .NET 1.0 by redirecting assemblies. The appliesTo attribute
+     causes the section to be ignored except under .NET 1.0.
+       -->
+       <runtime>
+               <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1"
+                               appliesTo="v1.0.3705">
+                       <dependentAssembly>
+                               <assemblyIdentity name="System" publicKeyToken="b77a5c561934e089" culture="" />
+                               <bindingRedirect oldVersion="1.0.5000.0" newVersion="1.0.3300.0" />
+                       </dependentAssembly>
+                       <dependentAssembly>
+                               <assemblyIdentity name="System.Data" publicKeyToken="b77a5c561934e089" culture="" />
+                               <bindingRedirect oldVersion="1.0.5000.0" newVersion="1.0.3300.0" />
+                       </dependentAssembly>
+                       <dependentAssembly>
+                               <assemblyIdentity name="System.Drawing" publicKeyToken="b03f5f7f11d50a3a" culture="" />
+                               <bindingRedirect oldVersion="1.0.5000.0" newVersion="1.0.3300.0" />
+                       </dependentAssembly>
+                       <dependentAssembly>
+                               <assemblyIdentity name="System.Windows.Forms" publicKeyToken="b77a5c561934e089" culture="" />
+                               <bindingRedirect oldVersion="1.0.5000.0" newVersion="1.0.3300.0" />
+                       </dependentAssembly>
+                       <dependentAssembly>
+                               <assemblyIdentity name="System.Xml" publicKeyToken="b77a5c561934e089" culture="" />
+                               <bindingRedirect oldVersion="1.0.5000.0" newVersion="1.0.3300.0" />
+                       </dependentAssembly>
+               </assemblyBinding>
+       </runtime>
+</configuration>

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/runpnunit.bat b/trunk/packages/NUnit.2.5.10.11092/tools/runpnunit.bat
new file mode 100644 (file)
index 0000000..a05cbb7
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/tools/runpnunit.bat
@@ -0,0 +1,2 @@
+start pnunit-agent agent.conf
+pnunit-launcher test.conf
\ No newline at end of file

diff --git a/trunk/packages/NUnit.2.5.10.11092/tools/test.conf b/trunk/packages/NUnit.2.5.10.11092/tools/test.conf
new file mode 100644 (file)
index 0000000..14cd113
--- /dev/null
+++ b/trunk/packages/NUnit.2.5.10.11092/tools/test.conf
@@ -0,0 +1,24 @@
+<TestGroup>
+    <ParallelTests>
+
+        <ParallelTest>
+            <Name>Testing</Name>
+            <Tests>
+                <TestConf>
+                    <Name>Testing</Name>
+                    <Assembly>pnunit.tests.dll</Assembly>
+                    <TestToRun>TestLibraries.Testing.EqualTo19</TestToRun>
+                    <Machine>localhost:8080</Machine>
+                    <TestParams>
+                        <string>..\server</string> <!-- server dir -->
+                       <string></string> <!-- database server -->
+                       <string></string><!-- conn string -->
+                    </TestParams>                                                                                
+                </TestConf>
+
+            </Tests>
+        </ParallelTest>
+
+
+    </ParallelTests>
+</TestGroup>
\ No newline at end of file

diff --git a/trunk/packages/repositories.config b/trunk/packages/repositories.config
index 46c3084..884dcba 100644 (file)
--- a/trunk/packages/repositories.config
+++ b/trunk/packages/repositories.config
@@ -2,4 +2,8 @@
 <repositories>
   <repository path="..\Pithos.Client\packages.config" />
   <repository path="..\Pithos.Network\packages.config" />
+  <repository path="..\Pithos.Core.Test\packages.config" />
+  <repository path="..\Pithos.Network.Test\packages.config" />
+  <repository path="..\Pithos.ShellExtensions.Test\packages.config" />
+  <repository path="..\Pithos.Client.Test\packages.config" />
 </repositories>
\ No newline at end of file