# HG changeset patch
# User cin
# Date 1461319688 -10800
# Node ID 1c2a16d071a75a5d8470a5aae0ec1aa0274a16ad
# Parent  2a8466f0cb8aacae858116af47493d1126bfeecc# Parent  b60643b47078137088a6822efa6321d6caa863b3
Слияние с ref20160224

diff -r 2a8466f0cb8a -r 1c2a16d071a7 .hgignore
--- a/.hgignore	Fri Feb 19 18:07:17 2016 +0300
+++ b/.hgignore	Fri Apr 22 13:08:08 2016 +0300
@@ -15,3 +15,6 @@
 Implab.Diagnostics.Interactive/obj/
 MonoPlay/bin/
 MonoPlay/obj/
+Implab.Test/Implab.Format.Test/bin/
+Implab.Test/Implab.Format.Test/obj/
+*.suo
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab.Test/Implab.Format.Test/Implab.Format.Test.csproj
--- a/Implab.Test/Implab.Format.Test/Implab.Format.Test.csproj	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab.Test/Implab.Format.Test/Implab.Format.Test.csproj	Fri Apr 22 13:08:08 2016 +0300
@@ -10,6 +10,7 @@
     <RootNamespace>Implab.Format.Test</RootNamespace>
     <AssemblyName>Implab.Format.Test</AssemblyName>
     <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <ReleaseVersion>0.2</ReleaseVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -32,7 +33,7 @@
   <ItemGroup>
     <Reference Include="System" />
     <Reference Include="nunit.framework">
-      <HintPath>..\..\packages\NUnit.3.0.1\lib\net45\nunit.framework.dll</HintPath>
+      <HintPath>..\..\packages\NUnit.2.6.4\lib\nunit.framework.dll</HintPath>
     </Reference>
   </ItemGroup>
   <ItemGroup>
@@ -40,6 +41,12 @@
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <ItemGroup>
+    <ProjectReference Include="..\..\Implab\Implab.csproj">
+      <Project>{F550F1F8-8746-4AD0-9614-855F4C4B7F05}</Project>
+      <Name>Implab</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
     <None Include="packages.config" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab.Test/Implab.Format.Test/JsonTests.cs
--- a/Implab.Test/Implab.Format.Test/JsonTests.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab.Test/Implab.Format.Test/JsonTests.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -1,11 +1,87 @@
 using NUnit.Framework;
 using System;
+using Implab.Formats.JSON;
+using Implab.Automaton;
 
 namespace Implab.Format.Test {
-    [TestFixture()]
+    [TestFixture]
     public class JsonTests {
-        [Test()]
-        public void TestCase() {
+        [Test]
+        public void TestScannerValidTokens() {
+            using (var scanner = new JSONScanner(@"9123, -123, 0, 0.1, -0.2, -0.1e3, 1.3E-3, ""some \t\n\u0020 text"", literal []{}:")) {
+
+                Tuple<JsonTokenType,object>[] expexted = {
+                    new Tuple<JsonTokenType,object>(JsonTokenType.Number, 9123d),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.Number, -123d),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.Number, 0d),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.Number, 0.1d),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.Number, -0.2d),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.Number, -0.1e3d),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.Number, 1.3E-3d),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.String, "some \t\n  text"),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, ", "),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.Literal, "literal"),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.BeginArray, " ["),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.EndArray, "]"),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.BeginObject, "{"),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.EndObject, "}"),
+                    new Tuple<JsonTokenType,object>(JsonTokenType.NameSeparator, ":")
+                };
+
+                object value;
+                JsonTokenType tokenType;
+                for (var i = 0; i < expexted.Length; i++) {
+                
+                    Assert.IsTrue(scanner.ReadToken(out value, out tokenType));
+                    Assert.AreEqual(expexted[i].Item1, tokenType);
+                    Assert.AreEqual(expexted[i].Item2, value);
+                }
+
+                Assert.IsFalse(scanner.ReadToken(out value, out tokenType));
+            }
+        }
+
+        [Test]
+        public void TestScannerBadTokens() {
+            var bad = new [] {
+                " 1",
+                " literal",
+                " \"",
+                "\"unclosed string",
+                "1.bad",
+                "001", // should be read as three numbers
+                "--10",
+                "+10",
+                "1.0.0",
+                "1e1.0",
+                "l1teral0",
+                ".123",
+                "-.123"
+            };
+
+            foreach (var json in bad)
+                using (var scanner = new JSONScanner(json)) {
+                    try {
+                        object value;
+                        JsonTokenType token;
+                        scanner.ReadToken(out value, out token);
+                        if (!Object.Equals(value,json)) {
+                            Console.WriteLine("'{0}' is read as {1}", json, value is String ? String.Format("'{0}'", value) : value );
+                            continue;
+                        }
+                        Assert.Fail("Token '{0}' shouldn't pass", json);
+                    } catch (ParserException e) {
+                        Console.WriteLine(e.Message);
+                    }
+                }
+            
         }
     }
 }
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab.Test/Implab.Format.Test/packages.config
--- a/Implab.Test/Implab.Format.Test/packages.config	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab.Test/Implab.Format.Test/packages.config	Fri Apr 22 13:08:08 2016 +0300
@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="NUnit" version="3.0.1" targetFramework="net45" />
+  <package id="NUnit" version="2.6.4" targetFramework="net45" />
 </packages>
\ No newline at end of file
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab.Test/Implab.Test.csproj
--- a/Implab.Test/Implab.Test.csproj	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab.Test/Implab.Test.csproj	Fri Apr 22 13:08:08 2016 +0300
@@ -62,8 +62,10 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="AsyncTests.cs" />
+    <Compile Include="CancelationTests.cs" />
     <Compile Include="PromiseHelper.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="RunnableComponentTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Implab\Implab.csproj">
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab.Test/Implab.Test.mono.csproj
--- a/Implab.Test/Implab.Test.mono.csproj	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab.Test/Implab.Test.mono.csproj	Fri Apr 22 13:08:08 2016 +0300
@@ -58,6 +58,7 @@
     <Compile Include="PromiseHelper.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="CancelationTests.cs" />
+    <Compile Include="RunnableComponentTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Implab\Implab.csproj">
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab.Test/RunnableComponentTests.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab.Test/RunnableComponentTests.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,195 @@
+using System;
+using System.Reflection;
+using System.Threading;
+using Implab.Parallels;
+using Implab.Components;
+
+#if MONO
+
+using NUnit.Framework;
+using TestClassAttribute = NUnit.Framework.TestFixtureAttribute;
+using TestMethodAttribute = NUnit.Framework.TestAttribute;
+using AssertFailedException = NUnit.Framework.AssertionException;
+#else
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+#endif
+
+namespace Implab.Test {
+    [TestClass]
+    public class RunnableComponentTests {
+
+        static void ShouldThrow(Action action) {
+            try {
+                action();
+                Assert.Fail();
+            } catch (AssertFailedException) {
+                throw;
+            } catch {
+            }
+        }
+
+        class Runnable : RunnableComponent {
+            public Runnable(bool initialized) : base(initialized) {
+            }
+                
+            public Action MockInit {
+                get;
+                set;
+            }
+
+            public Func<IPromise> MockStart {
+                get;
+                set;
+            }
+
+            public Func<IPromise> MockStop {
+                get;
+                set;
+            }
+
+            protected override IPromise OnStart() {
+                return MockStart != null ? MockStart() : base.OnStart();
+            }
+
+            protected override IPromise OnStop() {
+                return MockStop != null ? MockStop() : base.OnStart();
+            }
+
+            protected override void OnInitialize() {
+                if (MockInit != null)
+                    MockInit();
+            }
+        }
+
+        [TestMethod]
+        public void NormalFlowTest() {
+            var comp = new Runnable(false);
+
+            Assert.AreEqual(ExecutionState.Created, comp.State);
+
+            comp.Init();
+
+            Assert.AreEqual(ExecutionState.Ready, comp.State);
+
+            comp.Start().Join(1000);
+
+            Assert.AreEqual(ExecutionState.Running, comp.State);
+
+            comp.Stop().Join(1000);
+
+            Assert.AreEqual(ExecutionState.Disposed, comp.State);
+
+        }
+
+        [TestMethod]
+        public void InitFailTest() {
+            var comp = new Runnable(false) {
+                MockInit = () => {
+                    throw new Exception("BAD");
+                }
+            };
+
+            ShouldThrow(() => comp.Start());
+            ShouldThrow(() => comp.Stop());
+            Assert.AreEqual(ExecutionState.Created, comp.State);
+
+            ShouldThrow(comp.Init);
+
+            Assert.AreEqual(ExecutionState.Failed, comp.State);
+
+            ShouldThrow(() => comp.Start());
+            ShouldThrow(() => comp.Stop());
+            Assert.AreEqual(ExecutionState.Failed, comp.State);
+
+            comp.Dispose();
+            Assert.AreEqual(ExecutionState.Disposed, comp.State);
+        }
+
+        [TestMethod]
+        public void DisposedTest() {
+
+            var comp = new Runnable(false);
+            comp.Dispose();
+
+            ShouldThrow(() => comp.Start());
+            ShouldThrow(() => comp.Stop());
+            ShouldThrow(comp.Init);
+
+            Assert.AreEqual(ExecutionState.Disposed, comp.State);
+        }
+
+        [TestMethod]
+        public void StartCancelTest() {
+            var comp = new Runnable(true) {
+                MockStart = () => PromiseHelper.Sleep(100000, 0)
+            };
+
+            var p = comp.Start();
+            Assert.AreEqual(ExecutionState.Starting, comp.State);
+            p.Cancel();
+            ShouldThrow(() => p.Join(1000));
+            Assert.AreEqual(ExecutionState.Failed, comp.State);
+
+            Assert.IsInstanceOfType(comp.LastError, typeof(OperationCanceledException));
+
+            comp.Dispose();
+        }
+
+        [TestMethod]
+        public void StartStopTest() {
+            var stop = new Signal();
+            var comp = new Runnable(true) {
+                MockStart = () => PromiseHelper.Sleep(100000, 0),
+                MockStop = () => AsyncPool.RunThread(stop.Wait)
+            };
+
+            var p1 = comp.Start();
+            var p2 = comp.Stop();
+            // should enter stopping state
+
+            ShouldThrow(p1.Join);
+            Assert.IsTrue(p1.IsCancelled);
+            Assert.AreEqual(ExecutionState.Stopping, comp.State);
+
+            stop.Set();
+            p2.Join(1000);
+            Assert.AreEqual(ExecutionState.Disposed, comp.State);
+        }
+
+        [TestMethod]
+        public void StartStopFailTest() {
+            var comp = new Runnable(true) {
+                MockStart = () => PromiseHelper.Sleep(100000, 0).Then(null,null,x => { throw new Exception("I'm dead"); })
+            };
+
+            comp.Start();
+            var p = comp.Stop();
+            // if Start fails to cancel, should fail to stop
+            ShouldThrow(() => p.Join(1000));
+            Assert.AreEqual(ExecutionState.Failed, comp.State);
+            Assert.IsNotNull(comp.LastError);
+            Assert.AreEqual("I'm dead", comp.LastError.Message);
+        }
+
+        [TestMethod]
+        public void StopCancelTest() {
+            var comp = new Runnable(true) {
+                MockStop = () => PromiseHelper.Sleep(100000, 0)
+            };
+
+            comp.Start();
+            var p = comp.Stop();
+            Assert.AreEqual(ExecutionState.Stopping, comp.State);
+            p.Cancel();
+            ShouldThrow(() => p.Join(1000));
+            Assert.AreEqual(ExecutionState.Failed, comp.State);
+            Assert.IsInstanceOfType(comp.LastError, typeof(OperationCanceledException));
+
+            comp.Dispose();
+        }
+
+    }
+}
+
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/AbstractEvent.cs
--- a/Implab/AbstractEvent.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/AbstractEvent.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -78,13 +78,9 @@
         /// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
         protected void SetError(Exception error) {
             if (BeginTransit()) {
-                if (error is OperationCanceledException) {
-                    m_error = error.InnerException;
-                    CompleteTransit(CANCELLED_STATE);
-                } else {
-                    m_error = error is PromiseTransientException ? error.InnerException : error;
-                    CompleteTransit(REJECTED_STATE);
-                }
+                m_error = error;
+                CompleteTransit(REJECTED_STATE);
+
                 Signal();
             } else {
                 WaitTransition();
@@ -139,11 +135,11 @@
                 case SUCCEEDED_STATE:
                     return;
                 case CANCELLED_STATE:
-                    throw new OperationCanceledException();
+                    throw new OperationCanceledException("The operation has been cancelled", m_error);
                 case REJECTED_STATE:
                     throw new TargetInvocationException(m_error);
                 default:
-                    throw new ApplicationException(String.Format("Invalid promise state {0}", m_state));
+                    throw new ApplicationException(String.Format("The promise state {0} is invalid", m_state));
             }
         }
         #endregion
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/AbstractPromise.cs
--- a/Implab/AbstractPromise.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/AbstractPromise.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -134,8 +134,8 @@
         }
 
         protected void SetResult() {
-            BeginSetResult();
-            EndSetResult();
+            if(BeginSetResult())
+                EndSetResult();
         }
     }
 }
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/AbstractTask.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/AbstractTask.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,45 @@
+using System;
+using System.Threading;
+
+namespace Implab {
+    /// <summary>
+    /// Базовый класс для реализации задачь. Задача представляет собой некторое
+    /// действие, которое можно иницировать и обработать результат его выполнения
+    ///  в виде обещания, для этого оно реализует интерфейс <see cref="IPromise"/>.
+    /// </summary>
+    /// <remarks>
+    /// Данный класс определяет стандартное поведение при обработки результатов, в частности
+    /// обработку <see cref="System.OperationCanceledException"/> и <see cref="PromiseTransientException"/>
+    /// </remarks>
+    public abstract class AbstractTask : AbstractPromise {
+        int m_cancelationLock;
+
+        /// <summary>
+        /// Получает эксклюзивное право отмены задания, используется для отмены задания до начала его выполнения.
+        /// </summary>
+        /// <returns><c>true</c>, if cancelation was locked, <c>false</c> otherwise.</returns>
+        protected bool LockCancelation() {
+            return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
+        }
+
+
+
+        protected void SetErrorInternal(Exception error) {
+            // unwrap 
+            while (error is PromiseTransientException && error.InnerException != null)
+                error = error.InnerException;
+            
+            if (error is OperationCanceledException)
+                SetCancelled(error);
+            else
+                SetError(error);
+        }
+
+        protected void SetCancelledInternal(Exception reason) {
+            SetCancelled(
+                reason == null ? new OperationCanceledException() : reason is OperationCanceledException ? reason : new OperationCanceledException(null, reason)
+            );
+        }
+    }
+}
+
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/AbstractTaskT.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/AbstractTaskT.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,36 @@
+using System;
+using System.Threading;
+
+namespace Implab {
+    public abstract class AbstractTask<T> : AbstractPromise<T> {
+        int m_cancelationLock;
+
+        /// <summary>
+        /// Получает эксклюзивное право отмены задания, используется для отмены задания до начала его выполнения.
+        /// </summary>
+        /// <returns><c>true</c>, if cancelation was locked, <c>false</c> otherwise.</returns>
+        protected bool LockCancelation() {
+            return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
+        }
+
+
+
+        protected void SetErrorInternal(Exception error) {
+            // unwrap 
+            while (error is PromiseTransientException && error.InnerException != null)
+                error = error.InnerException;
+
+            if (error is OperationCanceledException)
+                SetCancelled(error);
+            else
+                SetError(error);
+        }
+
+        protected void SetCancelledInternal(Exception reason) {
+            SetCancelled(
+                reason == null ? new OperationCanceledException() : reason is OperationCanceledException ? reason : new OperationCanceledException(null, reason)
+            );
+        }
+    }
+}
+
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/ActionChainTask.cs
--- a/Implab/ActionChainTask.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/ActionChainTask.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -4,6 +4,15 @@
     public class ActionChainTask : ActionChainTaskBase, IDeferred {
         readonly Func<IPromise> m_task;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Implab.ActionChainTask"/> class.
+        /// </summary>
+        /// <param name="task">The operation which will be performed when the <see cref="Resolve()"/> is called.</param>
+        /// <param name="error">The error handler which will invoke when the <see cref="Reject(Exception)"/> is called or when the task fails with an error.</param>
+        /// <param name="cancel">The cancellation handler.</param>
+        /// <param name="autoCancellable">If set to <c>true</c> will automatically accept
+        ///  all cancel requests before the task is started with <see cref="Resolve()"/>,
+        /// after that all requests are directed to the task.</param>
         public ActionChainTask(Func<IPromise> task, Func<Exception, IPromise> error, Func<Exception, IPromise> cancel, bool autoCancellable) : base(error,cancel, autoCancellable) {
             m_task = task;
         }
@@ -12,8 +21,10 @@
             if (m_task != null && LockCancelation()) {
                 try {
                     var p = m_task();
-                    p.On(SetResult, HandleErrorInternal, SetCancelled);
+                    p.On(SetResult, HandleErrorInternal, HandleCancelInternal);
                     CancellationRequested(p.Cancel);
+                } catch (OperationCanceledException reason){
+                    HandleCancelInternal(reason);
                 } catch(Exception err) {
                     HandleErrorInternal(err);
                 }
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/ActionChainTaskBase.cs
--- a/Implab/ActionChainTaskBase.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/ActionChainTaskBase.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -2,12 +2,10 @@
 using System.Threading;
 
 namespace Implab {
-    public class ActionChainTaskBase : AbstractPromise {
+    public class ActionChainTaskBase : AbstractTask {
         readonly Func<Exception, IPromise> m_error;
         readonly Func<Exception, IPromise> m_cancel;
 
-        int m_cancelationLock;
-
         protected ActionChainTaskBase(Func<Exception, IPromise> error, Func<Exception, IPromise> cancel, bool autoCancellable) {
             m_error = error;
             m_cancel = cancel;
@@ -20,19 +18,28 @@
                 HandleErrorInternal(error);
         }
 
-
+        public override void CancelOperation(Exception reason) {
+            if (LockCancelation())
+                // отмена вызвана до начала выполнения задачи
+                HandleCancelInternal(reason);
+        }
 
-        public override void CancelOperation(Exception reason) {
-            if (LockCancelation()) {
-                if (m_cancel != null) {
-                    try {
-                        m_cancel(reason).On(SetResult, SetError, SetCancelled);
-                    } catch (Exception err) {
-                        HandleErrorInternal(err);
-                    }
-                } else {
-                    SetCancelled(reason);
+        protected void HandleCancelInternal(Exception reason) {
+            if (m_cancel != null) {
+                try {
+                    // вызываем обработчик отмены
+                    var p = m_cancel(reason);
+                    p.On(SetResult, HandleErrorInternal, SetCancelledInternal);
+                    // сообщаем асинхронной операции, что клиент уже не хочет получать результат
+                    // т.е. если он инициировал отмену, задача отменилась, вызвался обрабочик отмены
+                    // отбработчику сообщили, что результат уже не нужен и уже сам обработчик решает
+                    // отдавать ли результат или подтвердить отмену (или вернуть ошибку).
+                    CancellationRequested(p.Cancel);
+                } catch (Exception err) {
+                    HandleErrorInternal(err);
                 }
+            } else {
+                HandleErrorInternal(reason ?? new OperationCanceledException());
             }
         }
 
@@ -40,19 +47,16 @@
             if (m_error != null) {
                 try {
                     var p = m_error(error);
-                    p.On(SetResult,SetError,SetCancelled);
+                    p.On(SetResult, SetErrorInternal, SetCancelledInternal);
                     CancellationRequested(p.Cancel);
                 } catch (Exception err) {
-                    SetError(err);
+                    SetErrorInternal(error);
                 }
             } else {
-                SetError(error);
+                SetErrorInternal(error);
             }
         }
 
-        protected bool LockCancelation() {
-            return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
-        }
     }
 }
 
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/ActionChainTaskT.cs
--- a/Implab/ActionChainTaskT.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/ActionChainTaskT.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -12,8 +12,10 @@
             if (m_task != null && LockCancelation()) {
                 try {
                     var p = m_task(value);
-                    p.On(SetResult, HandleErrorInternal, SetCancelled);
+                    p.On(SetResult, HandleErrorInternal, HandleCancelInternal);
                     CancellationRequested(p.Cancel);
+                } catch (OperationCanceledException reason) {
+                    HandleCancelInternal(reason);
                 } catch(Exception err) {
                     HandleErrorInternal(err);
                 }
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/ActionTask.cs
--- a/Implab/ActionTask.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/ActionTask.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -12,6 +12,8 @@
                 try {
                     m_task();
                     SetResult();
+                } catch(OperationCanceledException reason) {
+                    HandleCancelInternal(reason);
                 } catch(Exception err) {
                     HandleErrorInternal(err);
                 }
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/ActionTaskBase.cs
--- a/Implab/ActionTaskBase.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/ActionTaskBase.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -1,13 +1,10 @@
 using System;
-using System.Threading;
 
 namespace Implab {
-    public class ActionTaskBase : AbstractPromise {
+    public class ActionTaskBase : AbstractTask {
         readonly Action<Exception> m_cancel;
         readonly Action<Exception> m_error;
 
-        int m_cancelationLock;
-
         protected ActionTaskBase( Action<Exception> error, Action<Exception> cancel, bool autoCancellable) {
             m_error = error;
             m_cancel = cancel;
@@ -21,37 +18,36 @@
                 HandleErrorInternal(error);
         }
 
+        public override void CancelOperation(Exception reason) {
+            if (LockCancelation())
+                HandleCancelInternal(reason);
+        }
+
         protected void HandleErrorInternal(Exception error) {
             if (m_error != null) {
                 try {
                     m_error(error);
                     SetResult();
                 } catch(Exception err) {
-                    SetError(err);
+                    SetErrorInternal(err);
                 }
             } else {
-                SetError(error);
+                SetErrorInternal(error);
             }
         }
 
-        public override void CancelOperation(Exception reason) {
-            if (LockCancelation()) {
-                if (m_cancel != null) {
-                    try {
-                        m_cancel(reason);
-                        SetResult();
-                    } catch (Exception err) {
-                        HandleErrorInternal(err);
-                    }
-                } else {
-                    SetCancelled(reason);
+        protected void HandleCancelInternal(Exception error) {
+            if (m_cancel != null) {
+                try {
+                    m_cancel(error);
+                    SetResult();
+                } catch(Exception err) {
+                    HandleErrorInternal(err);
                 }
+            } else {
+                HandleErrorInternal(error ?? new OperationCanceledException());
             }
         }
-
-        protected bool LockCancelation() {
-            return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
-        }
     }
 }
 
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/ActionTaskT.cs
--- a/Implab/ActionTaskT.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/ActionTaskT.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -12,6 +12,8 @@
                 try {
                     m_task(value);
                     SetResult();
+                } catch(OperationCanceledException reason) {
+                    HandleCancelInternal(reason);
                 } catch(Exception err) {
                     HandleErrorInternal(err);
                 }
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/AutomatonConst.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/AutomatonConst.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,9 @@
+
+namespace Implab.Automaton {
+    public static class AutomatonConst {
+        public const int UNREACHABLE_STATE = -1;
+
+        public const int UNCLASSIFIED_INPUT = 0;
+    }
+}
+
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/AutomatonTransition.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/AutomatonTransition.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,33 @@
+using System;
+
+namespace Implab.Automaton {
+    public struct AutomatonTransition : IEquatable<AutomatonTransition> {
+        public readonly int s1;
+        public readonly int s2;
+        public readonly int edge;
+
+        public AutomatonTransition(int s1, int s2, int edge) {
+            this.s1 = s1;
+            this.s2 = s2;
+            this.edge = edge;
+        }
+
+
+        #region IEquatable implementation
+        public bool Equals(AutomatonTransition other) {
+            return other.s1 == s1 && other.s2 == s2 && other.edge == edge ;
+        }
+        #endregion
+
+        public override bool Equals(object obj) {
+            if (obj is AutomatonTransition)
+                return Equals((AutomatonTransition)obj);
+            return base.Equals(obj);
+        }
+
+        public override int GetHashCode() {
+            return s1 + s2 + edge;
+        }
+    }
+}
+
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/DFATable.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/DFATable.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,348 @@
+using Implab;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Diagnostics;
+using System.IO;
+using System.CodeDom.Compiler;
+using System.CodeDom;
+
+namespace Implab.Automaton {
+    public class DFATable : IDFATableBuilder {
+        int m_stateCount;
+        int m_symbolCount;
+        int m_initialState;
+
+        readonly HashSet<int> m_finalStates = new HashSet<int>();
+        readonly HashSet<AutomatonTransition> m_transitions = new HashSet<AutomatonTransition>();
+
+
+        #region IDFADefinition implementation
+
+        public bool IsFinalState(int s) {
+            Safe.ArgumentInRange(s, 0, m_stateCount, "s");
+
+            return m_finalStates.Contains(s);
+        }
+
+        public IEnumerable<int> FinalStates {
+            get {
+                return m_finalStates;
+            }
+        }
+
+        public int StateCount {
+            get { return m_stateCount; }
+        }
+
+        public int AlphabetSize {
+            get { return m_symbolCount; }
+        }
+
+        public int InitialState {
+            get { return m_initialState; }
+        }
+
+        #endregion
+
+        public void SetInitialState(int s) {
+            Safe.ArgumentAssert(s >= 0, "s");
+            m_stateCount = Math.Max(m_stateCount, s + 1);
+            m_initialState = s;
+        }
+
+        public void MarkFinalState(int state) {
+            m_stateCount = Math.Max(m_stateCount, state + 1);
+            m_finalStates.Add(state);
+        }
+
+        public void Add(AutomatonTransition item) {
+            Safe.ArgumentAssert(item.s1 >= 0, "item");
+            Safe.ArgumentAssert(item.s2 >= 0, "item");
+            Safe.ArgumentAssert(item.edge >= 0, "item");
+
+            m_stateCount = Math.Max(m_stateCount, Math.Max(item.s1, item.s2) + 1);
+            m_symbolCount = Math.Max(m_symbolCount, item.edge + 1);
+
+            m_transitions.Add(item);
+        }
+
+        public void Clear() {
+            m_stateCount = 0;
+            m_symbolCount = 0;
+            m_finalStates.Clear();
+            m_transitions.Clear();
+        }
+
+        public bool Contains(AutomatonTransition item) {
+            return m_transitions.Contains(item);
+        }
+
+        public void CopyTo(AutomatonTransition[] array, int arrayIndex) {
+            m_transitions.CopyTo(array, arrayIndex);
+        }
+
+        public bool Remove(AutomatonTransition item) {
+            return m_transitions.Remove(item);
+        }
+
+        public int Count {
+            get {
+                return m_transitions.Count;
+            }
+        }
+
+        public bool IsReadOnly {
+            get {
+                return false;
+            }
+        }
+
+        public IEnumerator<AutomatonTransition> GetEnumerator() {
+            return m_transitions.GetEnumerator();
+        }
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
+            return GetEnumerator();
+        }
+
+        public void AddSymbol(int symbol) {
+            Safe.ArgumentAssert(symbol >= 0, "symbol");
+            m_symbolCount = Math.Max(symbol + 1, m_symbolCount);
+        }
+
+        public int[,] CreateTransitionTable() {
+            var table = new int[StateCount,AlphabetSize];
+
+            for (int i = 0; i < StateCount; i++)
+                for (int j = 0; j < AlphabetSize; j++)
+                    table[i, j] = AutomatonConst.UNREACHABLE_STATE;
+
+            foreach (var t in this)
+                table[t.s1,t.edge] = t.s2;
+
+            return table;
+        }
+
+        public bool[] CreateFinalStateTable() {
+            var table = new bool[StateCount];
+
+            foreach (var s in FinalStates)
+                table[s] = true;
+
+            return table;
+        }
+
+        /// <summary>Формирует множества конечных состояний перед началом работы алгоритма минимизации.</summary>
+        /// <remarks>
+        /// В процессе построения минимального автомата требуется разделить множество состояний,
+        /// на два подмножества - конечные состояния и все остальные, после чего эти подмножества
+        /// будут резделены на более мелкие. Иногда требуется гарантировать различия конечных сосотяний,
+        /// для этого необходимо переопределить даннцю фукнцию, для получения множеств конечных состояний.
+        /// </remarks>
+        /// <returns>The final states.</returns>
+        protected virtual IEnumerable<HashSet<int>> SplitFinalStates(IEnumerable<int> states) {
+            return new [] { new HashSet<int>(states) };
+        }
+
+        protected void Optimize(
+            IDFATableBuilder optimalDFA,
+            IDictionary<int,int> alphabetMap,
+            IDictionary<int,int> stateMap
+        ) {
+            Safe.ArgumentNotNull(optimalDFA, "dfa");
+            Safe.ArgumentNotNull(alphabetMap, "alphabetMap");
+            Safe.ArgumentNotNull(stateMap, "stateMap");
+
+
+            var setComparer = new CustomEqualityComparer<HashSet<int>>(
+                (x, y) => x.SetEquals(y),
+                s => s.Sum(x => x.GetHashCode())
+            );
+
+            var optimalStates = new HashSet<HashSet<int>>(setComparer);
+            var queue = new HashSet<HashSet<int>>(setComparer);
+
+            optimalStates.Add(new HashSet<int>(FinalStates));
+
+            var state = new HashSet<int>(
+                Enumerable
+                .Range(0, m_stateCount)
+                .Where(i => !m_finalStates.Contains(i))
+            );
+
+            optimalStates.Add(state);
+            queue.Add(state);
+
+            var rmap = m_transitions
+                .GroupBy(t => t.s2)
+                .ToDictionary(
+                    g => g.Key, // s2
+                    g => g.ToLookup(t => t.edge, t => t.s1)//.ToDictionary(p => p.Key)
+                );
+
+            while (queue.Count > 0) {
+                var stateA = queue.First();
+                queue.Remove(stateA);
+
+                for (int c = 0; c < m_symbolCount; c++) {
+                    var stateX = new HashSet<int>();
+                    foreach(var a in stateA.Where(rmap.ContainsKey))
+                        stateX.UnionWith(rmap[a][c]); // all states from wich the symbol 'c' leads to the state 'a'
+
+                    var tmp = optimalStates.ToArray();
+                    foreach (var stateY in tmp) {
+                        var stateR1 = new HashSet<int>(stateY);
+                        var stateR2 = new HashSet<int>(stateY);
+
+                        stateR1.IntersectWith(stateX);
+                        stateR2.ExceptWith(stateX);
+
+                        if (stateR1.Count > 0 && stateR2.Count > 0) {
+                            
+
+                            optimalStates.Remove(stateY);
+                            optimalStates.Add(stateR1);
+                            optimalStates.Add(stateR2);
+
+                            if (queue.Contains(stateY)) {
+                                queue.Remove(stateY);
+                                queue.Add(stateR1);
+                                queue.Add(stateR2);
+                            } else {
+                                queue.Add(stateR1.Count <= stateR2.Count ? stateR1 : stateR2);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // дополнительно разбиваем конечные состояния
+            foreach (var final in optimalStates.Where(s => s.Overlaps(m_finalStates)).ToArray()) {
+                optimalStates.Remove(final);
+                foreach (var split in SplitFinalStates(final))
+                    optimalStates.Add(split);
+            }
+                
+
+            // карта получения оптимального состояния по соотвествующему ему простому состоянию
+            var nextState = 0;
+            foreach (var item in optimalStates) {
+                var id = nextState++;
+                foreach (var s in item)
+                    stateMap[s] = id;
+            }
+
+            // получаем минимальный алфавит
+            // входные символы не различимы, если Move(s,a1) == Move(s,a2), для любого s
+            // для этого используем алгоритм кластеризации, сначала 
+            // считаем, что все символы не различимы
+
+            var minClasses = new HashSet<HashSet<int>>(setComparer);
+            var alphaQueue = new Queue<HashSet<int>>();
+            alphaQueue.Enqueue(new HashSet<int>(Enumerable.Range(0,AlphabetSize)));
+
+            // для всех состояний, будем проверять каждый класс на различимость,
+            // т.е. символы различимы, если они приводят к разным состояниям
+            for (int s = 0 ; s < optimalStates.Count; s++) {
+                var newQueue = new Queue<HashSet<int>>();
+
+                foreach (var A in alphaQueue) {
+                    // классы из одного символа делить бесполезно, переводим их сразу в
+                    // результирующий алфавит
+                    if (A.Count == 1) {
+                        minClasses.Add(A);
+                        continue;
+                    }
+
+                    // различаем классы символов, которые переводят в различные оптимальные состояния
+                    // optimalState -> alphaClass
+                    var classes = new Dictionary<int, HashSet<int>>();
+
+                    foreach (var term in A) {
+                        // ищем все переходы класса по символу term
+                        var s2 = m_transitions.Where(t => stateMap[t.s1] == s && t.edge == term).Select(t => stateMap[t.s2]).DefaultIfEmpty(-1).First();
+
+                        HashSet<int> a2;
+                        if (!classes.TryGetValue(s2, out a2)) {
+                            a2 = new HashSet<int>();
+                            newQueue.Enqueue(a2);
+                            classes[s2] = a2;
+                        }
+                        a2.Add(term);
+                    }
+                }
+
+                if (newQueue.Count == 0)
+                    break;
+                alphaQueue = newQueue;
+            }
+
+            // после окончания работы алгоритма в очереди останутся минимальные различимые классы
+            // входных символов
+            foreach (var A in alphaQueue)
+                minClasses.Add(A);
+
+            // построение отображения алфавитов входных символов.
+            // поскольку символ DFAConst.UNCLASSIFIED_INPUT может иметь
+            // специальное значение, тогда сохраним минимальный класс,
+            // содержащий этот символ на томже месте.
+
+            var nextCls = 0;
+            foreach (var item in minClasses) {
+                if (nextCls == AutomatonConst.UNCLASSIFIED_INPUT)
+                    nextCls++;
+
+                // сохраняем DFAConst.UNCLASSIFIED_INPUT
+                var cls = item.Contains(AutomatonConst.UNCLASSIFIED_INPUT) ? AutomatonConst.UNCLASSIFIED_INPUT : nextCls++;
+                optimalDFA.AddSymbol(cls);
+
+                foreach (var a in item)
+                    alphabetMap[a] = cls;
+            }
+
+            // построение автомата
+            optimalDFA.SetInitialState(stateMap[m_initialState]);
+
+            foreach (var sf in m_finalStates.Select(s => stateMap[s]).Distinct())
+                optimalDFA.MarkFinalState(sf);
+
+            foreach (var t in m_transitions.Select(t => new AutomatonTransition(stateMap[t.s1],stateMap[t.s2],alphabetMap[t.edge])).Distinct())
+                optimalDFA.Add(t);
+        }
+
+        protected string PrintDFA<TInput, TState>(IAlphabet<TInput> inputAlphabet, IAlphabet<TState> stateAlphabet) {
+            Safe.ArgumentNotNull(inputAlphabet, "inputAlphabet");
+            Safe.ArgumentNotNull(stateAlphabet, "stateAlphabet");
+
+            var data = new List<string>();
+
+            data.Add("digraph dfa {");
+
+            foreach (var final in m_finalStates)
+                data.Add(String.Format("{0} [shape=box];",String.Join("", stateAlphabet.GetSymbols(final))));
+
+            foreach (var t in m_transitions)
+                data.Add(String.Format(
+                    "{0} -> {2} [label={1}];",
+                    String.Join("", stateAlphabet.GetSymbols(t.s1)),
+                    ToLiteral(ToLiteral(String.Join("", t.edge == AutomatonConst.UNCLASSIFIED_INPUT ? new [] { "@" } : inputAlphabet.GetSymbols(t.edge).Select(x => x.ToString())))),
+                    String.Join("", stateAlphabet.GetSymbols(t.s2))
+                ));
+            data.Add("}");
+            return String.Join("\n", data);
+        }
+
+        static string ToLiteral(string input)
+        {
+            using (var writer = new StringWriter())
+            {
+                using (var provider = CodeDomProvider.CreateProvider("CSharp"))
+                {
+                    provider.GenerateCodeFromExpression(new CodePrimitiveExpression(input), writer, null);
+                    return writer.ToString();
+                }
+            }
+        }
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/EnumAlphabet.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/EnumAlphabet.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.Linq;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Implab.Automaton {
+    /// <summary>
+    /// Алфавит символами которого являются элементы перечислений.
+    /// </summary>
+    /// <typeparam name="T">Тип перечислений</typeparam>
+    public class EnumAlphabet<T> : IndexedAlphabetBase<T> where T : struct, IConvertible {
+        [SuppressMessage("Microsoft.Design", "CA1000:DoNotDeclareStaticMembersOnGenericTypes")]
+        static readonly Lazy<T[]> _symbols = new Lazy<T[]>(GetSymbols);
+
+        [SuppressMessage("Microsoft.Design", "CA1000:DoNotDeclareStaticMembersOnGenericTypes")]
+        static readonly Lazy<EnumAlphabet<T>> _fullAlphabet = new Lazy<EnumAlphabet<T>>(CreateEnumAlphabet);
+
+        static EnumAlphabet<T> CreateEnumAlphabet() {
+            var symbols = _symbols.Value;
+
+            if (
+                symbols[symbols.Length - 1].ToInt32(CultureInfo.InvariantCulture) >= symbols.Length
+                || symbols[0].ToInt32(CultureInfo.InvariantCulture) != 0
+            )
+                throw new InvalidOperationException("The specified enumeration must be zero-based and continuously numbered");
+
+            return new EnumAlphabet<T>(symbols.Select(x => x.ToInt32(CultureInfo.InvariantCulture)).ToArray());
+        }
+
+        static T[] GetSymbols() {
+            if (!typeof(T).IsEnum)
+                throw new InvalidOperationException("Invalid generic parameter, enumeration is required");
+
+            if (Enum.GetUnderlyingType(typeof(T)) != typeof(Int32))
+                throw new InvalidOperationException("Only enums based on Int32 are supported");
+            
+            return ((T[])Enum.GetValues(typeof(T)))
+                .OrderBy(x => x.ToInt32(CultureInfo.InvariantCulture))
+                .ToArray();
+        }
+
+        public static EnumAlphabet<T> FullAlphabet {
+            get {
+                return _fullAlphabet.Value;
+            }
+        }
+
+
+        public EnumAlphabet()
+            : base(_symbols.Value.Length) {
+        }
+
+        public EnumAlphabet(int[] map)
+            : base(map) {
+            Debug.Assert(map.Length == _symbols.Value.Length);
+        }
+
+
+        public override int GetSymbolIndex(T symbol) {
+            return symbol.ToInt32(CultureInfo.InvariantCulture);
+        }
+
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/IAlphabet.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/IAlphabet.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Implab.Automaton {
+    /// <summary>
+    /// Алфавит. Множество символов, которые разбиты на классы, при этом классы имеют непрерывную нумерацию,
+    /// что позволяет использовать их в качестве индексов массивов.
+    /// </summary>
+    /// <remarks>
+    /// <para>Алфавит является сюрьективным отображением множества символов в множество индексов, это позволяет сократить размер таблицы переходов автомата
+    /// для входных символов, которые для него не различимы.</para>
+    /// </remarks>
+    /// <typeparam name="TSymbol">Тип символов.</typeparam>
+    public interface IAlphabet<TSymbol> {
+        /// <summary>
+        /// Количество классов символов в алфавите.
+        /// </summary>
+        int Count { get; }
+
+        /// <summary>
+        /// Преобразует входной символ в индекс символа из алфавита.
+        /// </summary>
+        /// <param name="symobl">Исходный символ</param>
+        /// <returns>Индекс в алфавите</returns>
+        int Translate(TSymbol symobl);
+
+        bool Contains(TSymbol symbol);
+
+        IEnumerable<TSymbol> GetSymbols(int cls);
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/IAlphabetBuilder.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/IAlphabetBuilder.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,26 @@
+
+using System.Collections.Generic;
+
+namespace Implab.Automaton {
+    public interface IAlphabetBuilder<TSymbol> : IAlphabet<TSymbol> {
+        /// <summary>
+        /// Добавляет новый символ в алфавит, если символ уже был добавлен, то
+        /// возвращается ранее сопоставленный с символом класс.
+        /// </summary>
+        /// <param name="symbol">Символ для добавления.</param>
+        /// <returns>Индекс класса, который попоставлен с символом.</returns>
+        int DefineSymbol(TSymbol symbol);
+
+        int DefineSymbol(TSymbol symbol, int cls);
+        /// <summary>
+        /// Доабвляем класс символов. Множеству указанных исходных символов 
+        /// будет сопоставлен символ в алфавите.
+        /// </summary>
+        /// <param name="symbols">Множестов исходных символов</param>
+        /// <returns>Идентификатор символа алфавита.</returns>
+        int DefineClass(IEnumerable<TSymbol> symbols);
+
+        int DefineClass(IEnumerable<TSymbol> symbols, int cls);
+    }
+}
+
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/IDFATable.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/IDFATable.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+
+
+namespace Implab.Automaton {
+    /// <summary>
+    /// Полностью описывает DFA автомат, его поведение, состояние и входные символы.
+    /// </summary>
+    /// <example>
+    /// class MyAutomaton {
+    ///     int m_current;
+    ///     readonly DFAStateDescriptor<string>[] m_automaton;
+    ///     readonly IAlphabet<MyCommands> m_commands;
+    /// 
+    ///     public MyAutomaton(IDFADefinition&lt;MyCommands,MyStates,string&gt; definition) {
+    ///         m_current = definition.StateAlphabet.Translate(MyStates.Initial);
+    ///         m_automaton = definition.GetTransitionTable();
+    ///         m_commands = definition.InputAlphabet;
+    ///     }
+    /// 
+    ///     // defined a method which will move the automaton to the next state
+    ///     public void Move(MyCommands cmd) {
+    ///         // use transition map to determine the next state
+    ///         var next = m_automaton[m_current].transitions[m_commands.Translate(cmd)];
+    /// 
+    ///         // validate that we aren't in the unreachable state
+    ///         if (next == DFAConst.UNREACHABLE_STATE)
+    ///             throw new InvalidOperationException("The specified command is invalid");
+    /// 
+    ///         // if everything is ok
+    ///         m_current = next;
+    ///     }
+    /// }
+    /// </example>
+    public interface IDFATable : IEnumerable<AutomatonTransition> {
+        int StateCount {
+            get;
+        }
+
+        int AlphabetSize {
+            get;
+        }
+
+        int InitialState {
+            get;
+        }
+
+        bool IsFinalState(int s);
+
+        IEnumerable<int> FinalStates {
+            get;
+        }
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/IDFATableBuilder.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/IDFATableBuilder.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+
+namespace Implab.Automaton {
+    public interface IDFATableBuilder : IDFATable, ICollection<AutomatonTransition> {
+        /// <summary>
+        /// Marks the state as final.
+        /// </summary>
+        /// <param name="state">State.</param>
+        void MarkFinalState(int state);
+
+        void SetInitialState(int s);
+
+        /// <summary>
+        /// Increases if needed the input alphabet size to hold the specified symbol.
+        /// </summary>
+        /// <remarks>
+        /// <code>
+        /// AlphabetSize = Math.Max(AlphabetSize, symbol + 1)
+        /// </code>
+        /// </remarks>
+        /// <param name="symbol">Symbol.</param>
+        void AddSymbol(int symbol);
+    }
+}
+
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/IndexedAlphabetBase.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/IndexedAlphabetBase.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,50 @@
+using Implab;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+
+namespace Implab.Automaton {
+    /// <summary>
+    /// Indexed alphabet is the finite set of symbols where each symbol has a zero-based unique index.
+    /// </summary>
+    /// <remarks>
+    /// Indexed alphabets are usefull in bulting efficient translations from source alphabet
+    /// to the input alphabet of the automaton. It's assumed that the index to the symbol match
+    /// is well known and documented.
+    /// </remarks>
+    public abstract class IndexedAlphabetBase<T> : MapAlphabet<T> {
+
+        protected IndexedAlphabetBase() :base(true, null) {
+        }
+
+        public abstract int GetSymbolIndex(T symbol);
+
+        /// <summary>
+        /// Gets the translation map from the index of the symbol to it's class this is usefull for the optimized input symbols transtaion.
+        /// </summary>
+        /// <remarks>
+        /// The map is continous and start from the symbol with zero code. The last symbol
+        /// in the map is the last classified symbol in the alphabet, i.e. the map can be
+        /// shorter then the whole alphabet.
+        /// </remarks>
+        /// <returns>The translation map.</returns>
+        public int[] GetTranslationMap() {
+            var map = new Dictionary<int, int>();
+
+            int max = 0;
+            foreach (var p in Mappings) {
+                var index = GetSymbolIndex(p.Key);
+                max = Math.Max(max, index);
+                map[index] = p.Value;
+            }
+
+            var result = new int[max + 1];
+
+            for (int i = 0; i < result.Length; i++)
+                map.TryGetValue(i, out result[i]);
+
+            return result;
+        }
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/MapAlphabet.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/MapAlphabet.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Implab.Automaton {
+    public class MapAlphabet<T> : IAlphabetBuilder<T> {
+        readonly Dictionary<T,int> m_map;
+        int m_nextCls;
+        readonly bool m_supportUnclassified;
+
+        public MapAlphabet(bool supportUnclassified, IEqualityComparer<T> comparer) {
+            m_map = comparer != null ? new Dictionary<T, int>(comparer) : new Dictionary<T,int>();
+            m_supportUnclassified = supportUnclassified;
+            m_nextCls = supportUnclassified ? 1 : 0;
+        }
+
+        #region IAlphabetBuilder implementation
+
+        public int DefineSymbol(T symbol) {
+            int cls;
+            return m_map.TryGetValue(symbol, out cls) ? cls : DefineSymbol(symbol, m_nextCls);
+        }
+
+        public int DefineSymbol(T symbol, int cls) {
+            Safe.ArgumentAssert(cls >= 0, "cls");
+
+            m_nextCls = Math.Max(cls + 1, m_nextCls);
+            m_map.Add(symbol, cls);
+            return cls;
+        }
+
+        public int DefineClass(IEnumerable<T> symbols) {
+            return DefineClass(symbols, m_nextCls);
+        }
+
+        public int DefineClass(IEnumerable<T> symbols, int cls) {
+            Safe.ArgumentAssert(cls >= 0, "cls");
+            Safe.ArgumentNotNull(symbols, "symbols");
+
+            m_nextCls = Math.Max(cls + 1, m_nextCls);
+
+            foreach (var symbol in symbols)
+                m_map[symbol] = cls;
+            return cls;
+        }
+
+        #endregion
+
+        #region IAlphabet implementation
+
+        public int Translate(T symbol) {
+            int cls;
+            if (m_map.TryGetValue(symbol, out cls))
+                return cls;
+            if (!m_supportUnclassified)
+                throw new ArgumentOutOfRangeException("symbol", "The specified symbol isn't in the alphabet");
+            return AutomatonConst.UNCLASSIFIED_INPUT;
+        }
+
+        public int Count {
+            get {
+                return m_nextCls;
+            }
+        }
+
+        public bool Contains(T symbol) {
+            return m_supportUnclassified || m_map.ContainsKey(symbol);
+        }
+
+
+        public IEnumerable<T> GetSymbols(int cls) {
+            Safe.ArgumentAssert(!m_supportUnclassified || cls > 0, "cls");
+            return m_map.Where(p => p.Value == cls).Select(p => p.Key);
+        }
+        #endregion
+
+        public IEnumerable<KeyValuePair<T,int>> Mappings {
+            get {
+                return m_map;
+            }
+        }
+    }
+}
+
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/ParserException.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/ParserException.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Implab.Automaton {
+    [Serializable]
+    public class ParserException : Exception {
+        public ParserException() { }
+        public ParserException(string message) : base(message) { }
+        public ParserException(string message, Exception inner) : base(message, inner) { }
+        protected ParserException(
+          System.Runtime.Serialization.SerializationInfo info,
+          System.Runtime.Serialization.StreamingContext context)
+            : base(info, context) { }
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/RegularExpressions/AltToken.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/RegularExpressions/AltToken.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,17 @@
+using System;
+
+namespace Implab.Automaton.RegularExpressions {
+    public class AltToken: BinaryToken {
+        public AltToken(Token left, Token right)
+            : base(left, right) {
+        }
+
+        public override void Accept(IVisitor visitor) {
+            Safe.ArgumentNotNull(visitor, "visitor");
+            visitor.Visit(this);
+        }
+        public override string ToString() {
+            return String.Format(Right is BinaryToken ? "{0}|({1})" : "{0}|{1}", Left, Right);
+        }
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/RegularExpressions/BinaryToken.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/RegularExpressions/BinaryToken.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,21 @@
+using Implab;
+
+namespace Implab.Automaton.RegularExpressions {
+    public abstract class BinaryToken: Token {
+        readonly Token m_left;
+        readonly Token m_right;
+
+        public Token Left {
+            get { return m_left; }
+        }
+
+        public Token Right {
+            get { return m_right; }
+        }
+
+        protected BinaryToken(Token left, Token right) {
+            Safe.ArgumentNotNull(m_left = left, "left");
+            Safe.ArgumentNotNull(m_right = right, "right");
+        }
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/RegularExpressions/CatToken.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/RegularExpressions/CatToken.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,22 @@
+using System;
+
+namespace Implab.Automaton.RegularExpressions {
+    public class CatToken : BinaryToken {
+        public CatToken(Token left, Token right)
+            : base(left, right) {
+        }
+
+        public override void Accept(IVisitor visitor) {
+            Safe.ArgumentNotNull(visitor, "visitor");
+            visitor.Visit(this);
+        }
+
+        public override string ToString() {
+            return String.Format("{0}{1}", FormatToken(Left), FormatToken(Right));
+        }
+
+        static string FormatToken(Token token) {
+            return String.Format(token is AltToken ? "({0})" : "{0}", token);
+        }
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/RegularExpressions/EmptyToken.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/RegularExpressions/EmptyToken.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,13 @@
+using Implab;
+
+namespace Implab.Automaton.RegularExpressions {
+    public class EmptyToken: Token {
+        public override void Accept(IVisitor visitor) {
+            Safe.ArgumentNotNull(visitor, "visitor");
+            visitor.Visit(this);
+        }
+        public override string ToString() {
+            return "$";
+        }
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/RegularExpressions/EndToken.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/RegularExpressions/EndToken.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,18 @@
+using Implab;
+
+namespace Implab.Automaton.RegularExpressions {
+    /// <summary>
+    /// Конечный символ расширенного регулярного выражения, при построении ДКА
+    /// используется для определения конечных состояний.
+    /// </summary>
+    public class EndToken: Token {
+
+        public override void Accept(IVisitor visitor) {
+            Safe.ArgumentNotNull(visitor, "visitor");
+            visitor.Visit(this);
+        }
+        public override string ToString() {
+            return "#";
+        }
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/RegularExpressions/EndTokenT.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/RegularExpressions/EndTokenT.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,23 @@
+namespace Implab.Automaton.RegularExpressions {
+    /// <summary>
+    /// Конечный символ расширенного регулярного выражения, при построении ДКА
+    /// используется для определения конечных состояний.
+    /// </summary>
+    public class EndToken<TTag>: EndToken {
+
+        readonly TTag m_tag;
+
+        public EndToken(TTag tag) {
+            m_tag = tag;
+        }
+
+        public EndToken()
+            : this(default(TTag)) {
+        }
+
+        public TTag Tag {
+            get { return m_tag; }
+        }
+
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/RegularExpressions/ITaggedDFABuilder.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/RegularExpressions/ITaggedDFABuilder.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,7 @@
+
+namespace Implab.Automaton.RegularExpressions {
+    public interface ITaggedDFABuilder<TTag> : IDFATableBuilder {
+        void SetStateTag(int s, TTag[] tags);
+    }
+}
+
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/RegularExpressions/IVisitor.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/RegularExpressions/IVisitor.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,13 @@
+namespace Implab.Automaton.RegularExpressions {
+    /// <summary>
+    /// Интерфейс обходчика синтаксического дерева регулярного выражения
+    /// </summary>
+    public interface IVisitor {
+        void Visit(AltToken token);
+        void Visit(StarToken token);
+        void Visit(CatToken token);
+        void Visit(EmptyToken token);
+        void Visit(EndToken token);
+        void Visit(SymbolToken token);
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/RegularExpressions/RegularDFA.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/RegularExpressions/RegularDFA.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,91 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Implab.Automaton.RegularExpressions {
+    public class RegularDFA<TInput, TTag> : DFATable, ITaggedDFABuilder<TTag> {
+
+        readonly Dictionary<int,TTag[]> m_tags = new Dictionary<int, TTag[]>();
+        readonly IAlphabet<TInput> m_alphabet;
+
+        public RegularDFA(IAlphabet<TInput> alphabet) {
+            Safe.ArgumentNotNull(alphabet, "aplhabet");
+
+            m_alphabet = alphabet;
+        }
+
+
+        public IAlphabet<TInput> InputAlphabet {
+            get {
+                return m_alphabet;
+            }
+        }
+
+        public void MarkFinalState(int s, TTag[] tags) {
+            MarkFinalState(s);
+            SetStateTag(s, tags);
+        }
+
+        public void SetStateTag(int s, TTag[] tags) {
+            Safe.ArgumentNotNull(tags, "tags");
+            m_tags[s] = tags;
+        }
+
+        public TTag[] GetStateTag(int s) {
+            TTag[] tags;
+            return m_tags.TryGetValue(s, out tags) ? tags : new TTag[0];
+        }
+
+        public TTag[][] CreateTagTable() {
+            var table = new TTag[StateCount][];
+
+            foreach (var pair in m_tags)
+                table[pair.Key] = pair.Value;
+
+            return table;
+        }
+
+        /// <summary>
+        /// Optimize the specified alphabet.
+        /// </summary>
+        /// <param name="alphabet">Пустой алфавит, который будет зполнен в процессе оптимизации.</param>
+        public RegularDFA<TInput,TTag> Optimize(IAlphabetBuilder<TInput> alphabet) {
+            Safe.ArgumentNotNull(alphabet, "alphabet");
+
+            var dfa = new RegularDFA<TInput, TTag>(alphabet);
+
+            var alphaMap = new Dictionary<int,int>();
+            var stateMap = new Dictionary<int,int>();
+
+            Optimize(dfa, alphaMap, stateMap); 
+
+            // mark tags in the new DFA
+            foreach (var g in m_tags.Where(x => x.Key < StateCount).GroupBy(x => stateMap[x.Key], x => x.Value ))
+                dfa.SetStateTag(g.Key, g.SelectMany(x => x).ToArray());
+
+            // make the alphabet for the new DFA
+            // skip all unclassified symbols
+            foreach (var pair in alphaMap.Where(x => x.Value != 0))
+                alphabet.DefineClass(m_alphabet.GetSymbols(pair.Key), pair.Value);
+            return dfa;
+        }
+
+        protected override IEnumerable<HashSet<int>> SplitFinalStates(IEnumerable<int> states) {
+            var arrayComparer = new CustomEqualityComparer<TTag[]>(
+                (x,y) => x.Length == y.Length && x.All(it => y.Contains(it)),
+                x => x.Sum(it => x.GetHashCode())
+            );
+            return states.GroupBy(x => m_tags[x] ?? new TTag[0], arrayComparer).Select(g => new HashSet<int>(g));
+        }
+
+        public override string ToString() {
+            var states = new MapAlphabet<string>(false, null);
+
+            for (int i = 0; i < StateCount; i++)
+                states.DefineSymbol(string.Format("s{0}", i), i);
+
+            return string.Format("//[RegularDFA {1} x {2}]\n{0}", PrintDFA(InputAlphabet, states),StateCount, AlphabetSize);
+        }
+
+    }
+}
+
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/RegularExpressions/RegularExpressionVisitor.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/RegularExpressions/RegularExpressionVisitor.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,212 @@
+using Implab;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+
+namespace Implab.Automaton.RegularExpressions {
+    /// <summary>
+    /// Используется для построения ДКА по регулярному выражению, сначала обходит
+    /// регулярное выражение и вычисляет followpos, затем используется метод
+    /// <see cref="BuildDFA(IDFADefinition)"/> для построения автомата.
+    /// </summary>
+    public class RegularExpressionVisitor : IVisitor {
+        int m_idx;
+        Token m_root;
+        HashSet<int> m_firstpos;
+        HashSet<int> m_lastpos;
+
+        readonly Dictionary<int, HashSet<int>> m_followpos = new Dictionary<int, HashSet<int>>();
+        readonly Dictionary<int, int> m_indexes = new Dictionary<int, int>();
+        readonly HashSet<int> m_ends = new HashSet<int>();
+
+        readonly IDFATableBuilder m_builder;
+        readonly IAlphabetBuilder<HashSet<int>> m_states = new MapAlphabet<HashSet<int>>(
+            false,
+            new CustomEqualityComparer<HashSet<int>>(
+                (x, y) => x.SetEquals(y),
+                x => x.Sum(n => n.GetHashCode())
+            )
+        );
+
+        public RegularExpressionVisitor(IDFATableBuilder builder) {
+            Safe.ArgumentNotNull(builder, "builder");
+
+            m_builder = builder;
+        }
+
+        HashSet<int> Followpos(int pos) {
+            HashSet<int> set;
+            return m_followpos.TryGetValue(pos, out set) ? set : m_followpos[pos] = new HashSet<int>();
+        }
+
+        bool Nullable(object n) {
+            if (n is EmptyToken || n is StarToken)
+                return true;
+            var altToken = n as AltToken;
+            if (altToken != null)
+                return Nullable(altToken.Left) || Nullable(altToken.Right);
+            var catToken = n as CatToken;
+            if (catToken != null)
+                return Nullable(catToken.Left) && Nullable(catToken.Right);
+            return false;
+        }
+
+        protected int Index {
+            get { return m_idx; }
+        }
+
+        public void Visit(AltToken token) {
+            if (m_root == null)
+                m_root = token;
+            var firtspos = new HashSet<int>();
+            var lastpos = new HashSet<int>();
+
+            token.Left.Accept(this);
+            firtspos.UnionWith(m_firstpos);
+            lastpos.UnionWith(m_lastpos);
+
+            token.Right.Accept(this);
+            firtspos.UnionWith(m_firstpos);
+            lastpos.UnionWith(m_lastpos);
+
+            m_firstpos = firtspos;
+            m_lastpos = lastpos;
+        }
+
+        public void Visit(StarToken token) {
+            if (m_root == null)
+                m_root = token;
+            token.Token.Accept(this);
+
+            foreach (var i in m_lastpos)
+                Followpos(i).UnionWith(m_firstpos);
+        }
+
+        public void Visit(CatToken token) {
+            if (m_root == null)
+                m_root = token;
+
+            var firtspos = new HashSet<int>();
+            var lastpos = new HashSet<int>();
+            token.Left.Accept(this);
+            firtspos.UnionWith(m_firstpos);
+            var leftLastpos = m_lastpos;
+
+            token.Right.Accept(this);
+            lastpos.UnionWith(m_lastpos);
+            var rightFirstpos = m_firstpos;
+
+            if (Nullable(token.Left))
+                firtspos.UnionWith(rightFirstpos);
+
+            if (Nullable(token.Right))
+                lastpos.UnionWith(leftLastpos);
+
+            m_firstpos = firtspos;
+            m_lastpos = lastpos;
+
+            foreach (var i in leftLastpos)
+                Followpos(i).UnionWith(rightFirstpos);
+
+        }
+
+        public void Visit(EmptyToken token) {
+            if (m_root == null)
+                m_root = token;
+        }
+
+        public void Visit(SymbolToken token) {
+            if (m_root == null)
+                m_root = token;
+            m_idx++;
+            m_indexes[m_idx] = token.Value;
+            m_firstpos = new HashSet<int>(new[] { m_idx });
+            m_lastpos = new HashSet<int>(new[] { m_idx });
+        }
+
+        public virtual void Visit(EndToken token) {
+            if (m_root == null)
+                m_root = token;
+            m_idx++;
+            m_indexes[m_idx] = AutomatonConst.UNCLASSIFIED_INPUT;
+            m_firstpos = new HashSet<int>(new[] { m_idx });
+            m_lastpos = new HashSet<int>(new[] { m_idx });
+            Followpos(m_idx);
+            m_ends.Add(m_idx);
+        }
+
+        public void BuildDFA() {
+            AddState(m_firstpos);
+            SetInitialState(m_firstpos);
+
+            if(IsFinal(m_firstpos))
+                MarkFinalState(m_firstpos);
+
+            var inputMax = m_indexes.Values.Max();
+            var queue = new Queue<HashSet<int>>();
+
+            queue.Enqueue(m_firstpos);
+
+            while (queue.Count > 0) {
+                var s1 = queue.Dequeue();
+
+                for (int a = 0; a <= inputMax; a++) {
+                    var s2 = new HashSet<int>();
+                    foreach (var p in s1) {
+                        if (m_indexes[p] == a) {
+                            s2.UnionWith(Followpos(p));
+                        }
+                    }
+                    if (s2.Count > 0) {
+                        if (!HasState(s2)) {
+                            AddState(s2);
+                            if (IsFinal(s2))
+                                MarkFinalState(s2);
+                            
+                            queue.Enqueue(s2);
+                        }
+
+                        DefineTransition(s1, s2, a);
+                    }
+
+                }
+            }
+        }
+
+        protected bool HasState(HashSet<int> state) {
+            return m_states.Contains(state);
+        }
+
+        protected void AddState(HashSet<int> state) {
+            Debug.Assert(!HasState(state));
+
+            m_states.DefineSymbol(state);
+        }
+
+        protected int Translate(HashSet<int> state) {
+            Debug.Assert(HasState(state));
+
+            return m_states.Translate(state);
+        }
+
+        protected virtual void SetInitialState(HashSet<int> state) {
+            m_builder.SetInitialState(Translate(state));
+        }
+
+        protected virtual void MarkFinalState(HashSet<int> state) {
+            m_builder.MarkFinalState(Translate(state));
+        }
+
+        protected virtual void DefineTransition(HashSet<int> s1, HashSet<int> s2, int ch) {
+            
+            m_builder.Add(new AutomatonTransition(Translate(s1), Translate(s2), ch));
+        }
+
+        bool IsFinal(IEnumerable<int> state) {
+            Debug.Assert(state != null);
+            return state.Any(m_ends.Contains);
+        }
+
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/RegularExpressions/RegularExpressionVisitorT.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/RegularExpressions/RegularExpressionVisitorT.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,37 @@
+using Implab;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+
+namespace Implab.Automaton.RegularExpressions {
+    /// <summary>
+    /// </summary>
+    public class RegularExpressionVisitor<TTag> : RegularExpressionVisitor {
+        readonly Dictionary<int, TTag> m_tags = new Dictionary<int, TTag>();
+
+        readonly ITaggedDFABuilder<TTag> m_builder;
+
+        public RegularExpressionVisitor(ITaggedDFABuilder<TTag> builder) : base(builder) {
+            m_builder = builder;
+        }
+
+        public override void Visit(EndToken token) {
+            base.Visit(token);
+            var tagged = token as EndToken<TTag>;
+            if (tagged != null)
+                m_tags.Add(Index, tagged.Tag);
+        }
+
+        protected override void MarkFinalState(HashSet<int> state) {
+            base.MarkFinalState(state);
+            m_builder.SetStateTag(Translate(state), GetStateTags(state));
+        }
+
+        TTag[] GetStateTags(IEnumerable<int> state) {
+            Debug.Assert(state != null);
+            return state.Where(m_tags.ContainsKey).Select(pos => m_tags[pos]).ToArray();
+        }
+
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/RegularExpressions/StarToken.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/RegularExpressions/StarToken.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,31 @@
+using Implab;
+using System;
+
+
+namespace Implab.Automaton.RegularExpressions {
+    /// <summary>
+    /// Замыкание выражения с 0 и более повторов.
+    /// </summary>
+    public class StarToken: Token {
+
+        Token m_token;
+
+        public Token Token {
+            get { return m_token; }
+        }
+
+        public StarToken(Token token) {
+            Safe.ArgumentNotNull(token, "token");
+            m_token = token;
+        }
+
+        public override void Accept(IVisitor visitor) {
+            Safe.ArgumentNotNull(visitor, "visitor");
+            visitor.Visit(this);
+        }
+
+        public override string ToString() {
+            return String.Format("({0})*", Token);
+        }
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/RegularExpressions/SymbolToken.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/RegularExpressions/SymbolToken.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,27 @@
+using Implab;
+
+namespace Implab.Automaton.RegularExpressions {
+    /// <summary>
+    /// Выражение, соответсвующее одному символу.
+    /// </summary>
+    public class SymbolToken: Token {
+        int m_value;
+
+        public int Value {
+            get { return m_value; }
+        }
+
+        public SymbolToken(int value) {
+            m_value = value;
+        }
+        public override void Accept(IVisitor visitor) {
+            Safe.ArgumentNotNull(visitor, "visitor");
+
+            visitor.Visit(this);
+        }
+
+        public override string ToString() {
+            return Value.ToString();
+        }
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Automaton/RegularExpressions/Token.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Automaton/RegularExpressions/Token.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,63 @@
+using Implab;
+using System;
+using System.Linq;
+
+namespace Implab.Automaton.RegularExpressions {
+    public abstract class Token {
+        public abstract void Accept(IVisitor visitor);
+
+        public Token End() {
+            return Cat(new EndToken());
+        }
+
+        public Token Tag<TTag>(TTag tag) {
+            return Cat(new EndToken<TTag>(tag));
+        }
+
+        public Token Cat(Token right) {
+            return new CatToken(this, right);
+        }
+
+        public Token Or(Token right) {
+            return new AltToken(this, right);
+        }
+
+        public Token Optional() {
+            return Or(new EmptyToken());
+        }
+
+        public Token EClosure() {
+            return new StarToken(this);
+        }
+
+        public Token Closure() {
+            return Cat(new StarToken(this));
+        }
+
+        public Token Repeat(int count) {
+            Token token = null;
+
+            for (int i = 0; i < count; i++)
+                token = token != null ? token.Cat(this) : this;
+            return token ?? new EmptyToken();
+        }
+
+        public Token Repeat(int min, int max) {
+            if (min > max || min < 1)
+                throw new ArgumentOutOfRangeException();
+            var token = Repeat(min);
+
+            for (int i = min; i < max; i++)
+                token = token.Cat( Optional() );
+            return token;
+        }
+
+        public static Token New(params int[] set) {
+            Safe.ArgumentNotNull(set, "set");
+            Token token = null;
+            foreach(var c in set.Distinct())
+                token = token == null ? new SymbolToken(c) : token.Or(new SymbolToken(c));
+            return token;
+        }
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Components/ExecutionState.cs
--- a/Implab/Components/ExecutionState.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/Components/ExecutionState.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -1,14 +1,24 @@
 namespace Implab.Components {
     
     public enum ExecutionState {
-        Reserved = 0,
-        Uninitialized,
+        Undefined = 0,
+
+        Created,
+
+        Initializing,
+
         Ready,
+
         Starting,
+
         Running,
+
         Stopping,
-        Stopped,
+
+        Failed,
+
         Disposed,
-        Failed
+
+        Last = Disposed
     }
 }
\ No newline at end of file
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Components/IInitializable.cs
--- a/Implab/Components/IInitializable.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/Components/IInitializable.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -11,7 +11,7 @@
         /// Completes initialization.
         /// </summary>
         /// <remarks>
-        /// Normally virtual shouldn't be called from the constructor, due to the incomplete object state, but
+        /// Normally virtual methods shouldn't be called from the constructor, due to the incomplete object state, but
         /// they can be called from this method. This method is also usefull when we constructing a complex grpah
         /// of components where cyclic references may take place.
         /// </remarks>
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Components/LazyAndWeak.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Components/LazyAndWeak.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,64 @@
+using System;
+using System.Threading;
+
+namespace Implab.Components {
+    /// <summary>
+    /// Creates an instace on-demand and allows it to be garbage collected.
+    /// </summary>
+    /// <remarks>
+    /// Usefull when dealing with memory-intensive objects which are frequently used.
+    /// This class is similar to <see cref="ObjectPool{T}"/> except it is a singleton.
+    /// </remarks>
+    public class LazyAndWeak<T> where T : class {
+
+        readonly Func<T> m_factory;
+        readonly object m_lock;
+        WeakReference m_reference;
+
+
+        public LazyAndWeak(Func<T> factory, bool useLock) {
+            Safe.ArgumentNotNull(factory, "factory");
+            m_factory = factory;
+            m_lock = useLock ? new object() : null;
+        }
+
+        public LazyAndWeak(Func<T> factory) : this(factory, false) {
+        }
+
+        public T Value {
+            get {
+                while (true) {
+                    var weak = m_reference;
+                    T value;
+                    if (weak != null) {
+                        value = weak.Target as T;
+                        if (value != null)
+                            return value;
+                    }
+
+                    if (m_lock == null) {
+                        value = m_factory();
+
+                        if (Interlocked.CompareExchange(ref m_reference, new WeakReference(value), weak) == weak)
+                            return value;
+                    } else {
+                        lock (m_lock) {
+                            // double check
+                            weak = m_reference;
+                            if (weak != null) {
+                                value = weak.Target as T;
+                                if (value != null)
+                                    return value;
+                            }
+                            // we are safe to write
+                            value = m_factory();
+                            m_reference = new WeakReference(value);
+                            return value;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Components/RunnableComponent.cs
--- a/Implab/Components/RunnableComponent.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/Components/RunnableComponent.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -1,24 +1,164 @@
 using System;
-using Implab.Parsing;
 
 namespace Implab.Components {
-    public class RunnableComponent : Disposable, IRunnable, IInitializable {
-        
+    public abstract class RunnableComponent : IDisposable, IRunnable, IInitializable {
+        enum Commands {
+            Ok = 0,
+            Fail,
+            Init,
+            Start,
+            Stop,
+            Dispose,
+            Last = Dispose
+        }
+
+        class StateMachine {
+            static readonly ExecutionState[,] _transitions;
+
+            static StateMachine() {
+                _transitions = new ExecutionState[(int)ExecutionState.Last + 1, (int)Commands.Last + 1];
+
+                Edge(ExecutionState.Created, ExecutionState.Initializing, Commands.Init);
+                Edge(ExecutionState.Created, ExecutionState.Disposed, Commands.Dispose);
+
+                Edge(ExecutionState.Initializing, ExecutionState.Ready, Commands.Ok);
+                Edge(ExecutionState.Initializing, ExecutionState.Failed, Commands.Fail);
+
+                Edge(ExecutionState.Ready, ExecutionState.Starting, Commands.Start);
+                Edge(ExecutionState.Ready, ExecutionState.Disposed, Commands.Dispose);
+
+                Edge(ExecutionState.Starting, ExecutionState.Running, Commands.Ok);
+                Edge(ExecutionState.Starting, ExecutionState.Failed, Commands.Fail);
+                Edge(ExecutionState.Starting, ExecutionState.Stopping, Commands.Stop);
+                Edge(ExecutionState.Starting, ExecutionState.Disposed, Commands.Dispose);
 
+                Edge(ExecutionState.Running, ExecutionState.Failed, Commands.Fail);
+                Edge(ExecutionState.Running, ExecutionState.Stopping, Commands.Stop);
+                Edge(ExecutionState.Running, ExecutionState.Disposed, Commands.Dispose);
 
+                Edge(ExecutionState.Stopping, ExecutionState.Failed, Commands.Fail);
+                Edge(ExecutionState.Stopping, ExecutionState.Disposed, Commands.Ok);
+
+                Edge(ExecutionState.Failed, ExecutionState.Disposed, Commands.Dispose);
+            }
+
+            static void Edge(ExecutionState s1, ExecutionState s2, Commands cmd) {
+                _transitions[(int)s1, (int)cmd] = s2;
+            }
 
-            
+            public ExecutionState State {
+                get;
+                private set;
+            }
+
+            public StateMachine(ExecutionState initial) {
+                State = initial;
+            }
+
+            public bool Move(Commands cmd) {
+                var next = _transitions[(int)State, (int)cmd];
+                if (next == ExecutionState.Undefined)
+                    return false;
+                State = next;
+                return true;
+            }
+        }
+
         IPromise m_pending;
         Exception m_lastError;
 
+        readonly StateMachine m_stateMachine;
+
         protected RunnableComponent(bool initialized) {
+            m_stateMachine = new StateMachine(initialized ? ExecutionState.Ready : ExecutionState.Created);
+        }
+
+        protected virtual int DisposeTimeout {
+            get {
+                return 10000;
+            }
+        }
+
+        void ThrowInvalidCommand(Commands cmd) {
+            if (m_stateMachine.State == ExecutionState.Disposed)
+                throw new ObjectDisposedException(ToString());
+            
+            throw new InvalidOperationException(String.Format("Commnd {0} is not allowed in the state {1}", cmd, m_stateMachine.State));
+        }
+
+        void Move(Commands cmd) {
+            if (!m_stateMachine.Move(cmd))
+                ThrowInvalidCommand(cmd);
+        }
+
+        void Invoke(Commands cmd, Action action) {
+            lock (m_stateMachine) 
+                Move(cmd);
             
+            try {
+                action();
+                lock(m_stateMachine)
+                    Move(Commands.Ok);
+
+            } catch (Exception err) {
+                lock (m_stateMachine) {
+                    Move(Commands.Fail);
+                    m_lastError = err;
+                }
+                throw;
+            }
         }
 
+        IPromise InvokeAsync(Commands cmd, Func<IPromise> action, Action<IPromise, IDeferred> chain) {
+            IPromise promise = null;
+            IPromise prev;
+
+            var task = new ActionChainTask(action, null, null, true);
+
+            lock (m_stateMachine) {
+                Move(cmd);
+            
+                prev = m_pending;
+
+                promise = task.Then(
+                    () => {
+                        lock(m_stateMachine) {
+                            if (m_pending == promise) {
+                                Move(Commands.Ok);
+                                m_pending = null;
+                            }
+                        }
+                    }, e => {
+                        lock(m_stateMachine) {
+                            if (m_pending == promise) {
+                                Move(Commands.Fail);
+                                m_pending = null;
+                                m_lastError = e;
+                            }
+                        }
+                        throw new PromiseTransientException(e);
+                    }
+                );
+
+                m_pending = promise;
+            }
+
+            if (prev == null)
+                task.Resolve();
+            else
+                chain(prev, task);
+
+            return promise;
+        }
+
+
         #region IInitializable implementation
 
         public void Init() {
-            
+            Invoke(Commands.Init, OnInitialize);
+        }
+
+        protected virtual void OnInitialize() {
         }
 
         #endregion
@@ -26,33 +166,92 @@
         #region IRunnable implementation
 
         public IPromise Start() {
-            throw new NotImplementedException();
+            return InvokeAsync(Commands.Start, OnStart, null);
         }
 
         protected virtual IPromise OnStart() {
             return Promise.SUCCESS;
         }
 
-        protected virtual void Run() {
+        public IPromise Stop() {
+            return InvokeAsync(Commands.Stop, OnStop, StopPending).Then(Dispose);
+        }
+
+        protected virtual IPromise OnStop() {
+            return Promise.SUCCESS;
         }
 
-        public IPromise Stop() {
-            throw new NotImplementedException();
+        /// <summary>
+        /// Stops the current operation if one exists.
+        /// </summary>
+        /// <param name="current">Current.</param>
+        /// <param name="stop">Stop.</param>
+        protected virtual void StopPending(IPromise current, IDeferred stop) {
+            if (current == null) {
+                stop.Resolve();
+            } else {
+                // связваем текущую операцию с операцией остановки
+                current.On(
+                    stop.Resolve, // если текущая операция заверщилась, то можно начинать остановку
+                    stop.Reject, // если текущая операция дала ошибку - то все плохо, нельзя продолжать
+                    e => stop.Resolve() // если текущая отменилась, то можно начинать остановку
+                );
+                // посылаем текущей операции сигнал остановки
+                current.Cancel();
+            }
         }
 
         public ExecutionState State {
             get {
-                throw new NotImplementedException();
+                return m_stateMachine.State;
             }
         }
 
         public Exception LastError {
             get {
-                throw new NotImplementedException();
+                return m_lastError;
             }
         }
 
         #endregion
+
+        #region IDisposable implementation
+
+        public void Dispose() {
+            IPromise pending;
+            lock (m_stateMachine) {
+                if (m_stateMachine.State == ExecutionState.Disposed)
+                    return;
+
+                Move(Commands.Dispose);
+
+                GC.SuppressFinalize(this);
+
+                pending = m_pending;
+                m_pending = null;
+            }
+            if (pending != null) {
+                pending.Cancel();
+                pending.Timeout(DisposeTimeout).On(
+                    () => Dispose(true, null),
+                    err => Dispose(true, err),
+                    reason => Dispose(true, new OperationCanceledException("The operation is cancelled", reason))
+                );
+            } else {
+                Dispose(true, m_lastError);
+            }
+        }
+
+        ~RunnableComponent() {
+            Dispose(false, null);
+        }
+
+        #endregion
+
+        protected virtual void Dispose(bool disposing, Exception lastError) {
+
+        }
+
     }
 }
 
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Formats/ByteAlphabet.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Formats/ByteAlphabet.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+using System.Linq;
+using Implab.Automaton;
+
+namespace Implab.Formats {
+    public class ByteAlphabet : IndexedAlphabetBase<byte> {
+
+        #region implemented abstract members of IndexedAlphabetBase
+
+        public override int GetSymbolIndex(byte symbol) {
+            return (int)symbol;
+        }
+
+        public IEnumerable<byte> InputSymbols {
+            get {
+                return Enumerable.Range(byte.MinValue, byte.MaxValue).Cast<byte>();
+            }
+        }
+
+        #endregion
+    }
+}
+
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Formats/CharAlphabet.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Formats/CharAlphabet.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+using System.Linq;
+using Implab.Automaton;
+
+namespace Implab.Formats {
+    public class CharAlphabet: IndexedAlphabetBase<char> {
+
+        public override int GetSymbolIndex(char symbol) {
+            return symbol;
+        }
+
+        public IEnumerable<char> InputSymbols {
+            get { return Enumerable.Range(char.MinValue, char.MaxValue).Cast<char>(); }
+        }
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Formats/Grammar.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Formats/Grammar.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,99 @@
+using Implab;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Implab.Automaton;
+using Implab.Automaton.RegularExpressions;
+
+namespace Implab.Formats {
+    /// <summary>
+    /// Базовый абстрактный класс. Грамматика, позволяет формулировать выражения над алфавитом типа <c>char</c>.
+    /// </summary>
+    public abstract class Grammar<TSymbol> {
+        
+        protected abstract IAlphabetBuilder<TSymbol> AlphabetBuilder {
+            get;
+        }
+
+        protected SymbolToken UnclassifiedToken() {
+            return new SymbolToken(AutomatonConst.UNCLASSIFIED_INPUT);
+        }
+
+        protected void DefineAlphabet(IEnumerable<TSymbol> alphabet) {
+            Safe.ArgumentNotNull(alphabet, "alphabet");
+
+            foreach (var ch in alphabet)
+                AlphabetBuilder.DefineSymbol(ch);
+        }
+
+        protected Token SymbolToken(TSymbol symbol) {
+            return Token.New(TranslateOrAdd(symbol));
+        }
+
+        protected Token SymbolToken(IEnumerable<TSymbol> symbols) {
+            Safe.ArgumentNotNull(symbols, "symbols");
+
+            return Token.New(TranslateOrAdd(symbols).ToArray());
+        }
+
+        protected Token SymbolSetToken(params TSymbol[] set) {
+            return SymbolToken(set);
+        }
+
+        int TranslateOrAdd(TSymbol ch) {
+            var t = AlphabetBuilder.Translate(ch);
+            if (t == AutomatonConst.UNCLASSIFIED_INPUT)
+                t = AlphabetBuilder.DefineSymbol(ch);
+            return t;
+        }
+
+        IEnumerable<int> TranslateOrAdd(IEnumerable<TSymbol> symbols) {
+            return symbols.Distinct().Select(TranslateOrAdd);
+        }
+
+        int TranslateOrDie(TSymbol ch) {
+            var t = AlphabetBuilder.Translate(ch);
+            if (t == AutomatonConst.UNCLASSIFIED_INPUT)
+                    throw new ApplicationException(String.Format("Symbol '{0}' is UNCLASSIFIED", ch));
+            return t;
+        }
+
+        IEnumerable<int> TranslateOrDie(IEnumerable<TSymbol> symbols) {
+            return symbols.Distinct().Select(TranslateOrDie);
+        }
+
+        protected Token SymbolTokenExcept(IEnumerable<TSymbol> symbols) {
+            Safe.ArgumentNotNull(symbols, "symbols");
+
+            return Token.New( Enumerable.Range(0, AlphabetBuilder.Count).Except(TranslateOrDie(symbols)).ToArray() );
+        }
+
+        protected abstract IndexedAlphabetBase<TSymbol> CreateAlphabet();
+
+        protected ScannerContext<TTag> BuildScannerContext<TTag>(Token regexp) {
+            
+            var dfa = new RegularDFA<TSymbol, TTag>(AlphabetBuilder);
+
+            var visitor = new RegularExpressionVisitor<TTag>(dfa);
+            regexp.Accept(visitor);
+            visitor.BuildDFA();
+
+            if (dfa.IsFinalState(dfa.InitialState))
+                throw new ApplicationException("The specified language contains empty token");
+
+            var ab = CreateAlphabet();
+            var optimal = dfa.Optimize(ab);
+
+            return new ScannerContext<TTag>(
+                optimal.CreateTransitionTable(),
+                optimal.CreateFinalStateTable(),
+                optimal.CreateTagTable(),
+                optimal.InitialState,
+                ab.GetTranslationMap()
+            );
+        }
+
+    }
+
+
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Formats/JSON/JSONElementContext.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Formats/JSON/JSONElementContext.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,11 @@
+namespace Implab.Formats.JSON {
+    /// <summary>
+    /// internal
+    /// </summary>
+    enum JSONElementContext {
+        None,
+        Object,
+        Array,
+        Closed
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Formats/JSON/JSONElementType.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Formats/JSON/JSONElementType.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,28 @@
+namespace Implab.Formats.JSON {
+    /// <summary>
+    /// Тип элемента на котором находится парсер
+    /// </summary>
+    public enum JSONElementType {
+        None,
+        /// <summary>
+        /// Начало объекта
+        /// </summary>
+        BeginObject,
+        /// <summary>
+        /// Конец объекта
+        /// </summary>
+        EndObject,
+        /// <summary>
+        /// Начало массива
+        /// </summary>
+        BeginArray,
+        /// <summary>
+        /// Конец массива
+        /// </summary>
+        EndArray,
+        /// <summary>
+        /// Простое значение
+        /// </summary>
+        Value
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Formats/JSON/JSONGrammar.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Formats/JSON/JSONGrammar.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,121 @@
+using System.Linq;
+using Implab.Automaton.RegularExpressions;
+using System;
+using Implab.Automaton;
+using Implab.Components;
+
+namespace Implab.Formats.JSON {
+    class JSONGrammar : Grammar<char> {
+        public enum TokenType {
+            None,
+            BeginObject,
+            EndObject,
+            BeginArray,
+            EndArray,
+            String,
+            Number,
+            Literal,
+            NameSeparator,
+            ValueSeparator,
+            Whitespace,
+
+            StringBound,
+            EscapedChar,
+            UnescapedChar,
+            EscapedUnicode
+        }
+
+        static LazyAndWeak<JSONGrammar> _instance = new LazyAndWeak<JSONGrammar>(() => new JSONGrammar());
+
+        public static JSONGrammar Instance {
+            get { return _instance.Value; }
+        }
+
+        readonly ScannerContext<TokenType> m_jsonExpression;
+        readonly ScannerContext<TokenType> m_stringExpression;
+        readonly CharAlphabet m_defaultAlphabet = new CharAlphabet();
+
+        public JSONGrammar() {
+            DefineAlphabet(Enumerable.Range(0, 0x20).Select(x => (char)x));
+            var hexDigit = SymbolRangeToken('a','f').Or(SymbolRangeToken('A','F')).Or(SymbolRangeToken('0','9'));
+            var digit9 = SymbolRangeToken('1', '9');
+            var zero = SymbolToken('0');
+            var digit = zero.Or(digit9);
+            var dot = SymbolToken('.');
+            var minus = SymbolToken('-');
+            var sign = SymbolSetToken('-', '+');
+            var expSign = SymbolSetToken('e', 'E');
+            var letters = SymbolRangeToken('a', 'z');
+            var integer = zero.Or(digit9.Cat(digit.EClosure()));
+            var frac = dot.Cat(digit.Closure());
+            var exp = expSign.Cat(sign.Optional()).Cat(digit.Closure());
+            var quote = SymbolToken('"');
+            var backSlash = SymbolToken('\\');
+            var specialEscapeChars = SymbolSetToken('\\', '"', '/', 'b', 'f', 't', 'n', 'r');
+            var unicodeEspace = SymbolToken('u').Cat(hexDigit.Repeat(4));
+            var whitespace = SymbolSetToken('\n', '\r', '\t', ' ').EClosure();
+            var beginObject = whitespace.Cat(SymbolToken('{')).Cat(whitespace);
+            var endObject = whitespace.Cat(SymbolToken('}')).Cat(whitespace);
+            var beginArray = whitespace.Cat(SymbolToken('[')).Cat(whitespace);
+            var endArray = whitespace.Cat(SymbolToken(']')).Cat(whitespace);
+            var nameSep = whitespace.Cat(SymbolToken(':')).Cat(whitespace);
+            var valueSep = whitespace.Cat(SymbolToken(',')).Cat(whitespace);
+            
+            var number = minus.Optional().Cat(integer).Cat(frac.Optional()).Cat(exp.Optional());
+            var literal = letters.Closure();
+            var unescaped = SymbolTokenExcept(Enumerable.Range(0, 0x20).Union(new int[] { '\\', '"' }).Select(x => (char)x));
+
+            var jsonExpression =
+                number.Tag(TokenType.Number)
+                .Or(literal.Tag(TokenType.Literal))
+                .Or(quote.Tag(TokenType.StringBound))
+                .Or(beginObject.Tag(TokenType.BeginObject))
+                .Or(endObject.Tag(TokenType.EndObject))
+                .Or(beginArray.Tag(TokenType.BeginArray))
+                .Or(endArray.Tag(TokenType.EndArray))
+                .Or(nameSep.Tag(TokenType.NameSeparator))
+                .Or(valueSep.Tag(TokenType.ValueSeparator))
+                .Or(SymbolSetToken('\n', '\r', '\t', ' ').Closure().Tag(TokenType.Whitespace));
+
+
+            var jsonStringExpression =
+                quote.Tag(TokenType.StringBound)
+                .Or(backSlash.Cat(specialEscapeChars).Tag(TokenType.EscapedChar))
+                .Or(backSlash.Cat(unicodeEspace).Tag(TokenType.EscapedUnicode))
+                .Or(unescaped.Closure().Tag(TokenType.UnescapedChar));
+                    
+
+            m_jsonExpression = BuildScannerContext<TokenType>(jsonExpression);
+            m_stringExpression = BuildScannerContext<TokenType>(jsonStringExpression);
+
+
+        }
+
+        protected override IAlphabetBuilder<char> AlphabetBuilder {
+            get {
+                return m_defaultAlphabet;
+            }
+        }
+
+        public ScannerContext<TokenType> JsonExpression {
+            get {
+                return m_jsonExpression;
+            }
+        }
+
+        public ScannerContext<TokenType> JsonStringExpression {
+            get {
+                return m_stringExpression;
+            }
+        }
+
+        Token SymbolRangeToken(char start, char stop) {
+            return SymbolToken(Enumerable.Range(start, stop - start + 1).Select(x => (char)x));
+        }
+
+        protected override IndexedAlphabetBase<char> CreateAlphabet() {
+            return new CharAlphabet();
+        }
+                
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Formats/JSON/JSONParser.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Formats/JSON/JSONParser.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,293 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using Implab.Automaton;
+using Implab.Automaton.RegularExpressions;
+using System.Linq;
+using Implab.Components;
+using System.Collections.Generic;
+
+namespace Implab.Formats.JSON {
+    /// <summary>
+    /// Pull парсер JSON данных.
+    /// </summary>
+    /// <remarks>
+    /// Следует отметить отдельную интерпретацию свойства <see cref="Level"/>,
+    /// оно означает текущий уровень вложенности объектов, однако закрывающий
+    /// элемент объекта и массива имеет уровень меньше, чем сам объект.
+    /// <code>
+    /// { // Level = 1
+    ///     "name" : "Peter", // Level = 1
+    ///     "address" : { // Level = 2
+    ///         city : "Stern" // Level = 2
+    ///     } // Level = 1
+    /// } // Level = 0
+    /// </code>
+    /// </remarks>
+    public class JSONParser : Disposable {
+
+        enum MemberContext {
+            MemberName,
+            MemberValue
+        }
+
+        #region Parser rules
+        struct ParserContext {
+            readonly int[,] m_dfa;
+            int m_state;
+
+            readonly JSONElementContext m_elementContext;
+
+            public ParserContext(int[,] dfa, int state, JSONElementContext context) {
+                m_dfa = dfa;
+                m_state = state;
+                m_elementContext = context;
+            }
+
+            public bool Move(JsonTokenType token) {
+                var next = m_dfa[m_state, (int)token];
+                if (next == AutomatonConst.UNREACHABLE_STATE)
+                    return false;
+                m_state = next;
+                return true;
+            }
+
+            public JSONElementContext ElementContext {
+                get { return m_elementContext; }
+            }
+        }
+
+        static readonly ParserContext _jsonContext;
+        static readonly ParserContext _objectContext;
+        static readonly ParserContext _arrayContext;
+
+        static JSONParser() {
+
+            var valueExpression = MakeToken(JsonTokenType.BeginArray, JsonTokenType.BeginObject, JsonTokenType.Literal, JsonTokenType.Number, JsonTokenType.String);
+            var memberExpression = MakeToken(JsonTokenType.String).Cat(MakeToken(JsonTokenType.NameSeparator)).Cat(valueExpression);
+
+            var objectExpression = memberExpression
+                .Cat(
+                    MakeToken(JsonTokenType.ValueSeparator)
+                    .Cat(memberExpression)
+                    .EClosure()
+                )
+                .Optional()
+                .Cat(MakeToken(JsonTokenType.EndObject))
+                .End();
+            
+            var arrayExpression = valueExpression
+                .Cat(
+                    MakeToken(JsonTokenType.ValueSeparator)
+                    .Cat(valueExpression)
+                    .EClosure()
+                )
+                .Optional()
+                .Cat(MakeToken(JsonTokenType.EndArray))
+                .End();
+
+            var jsonExpression = valueExpression.End();
+
+            _jsonContext = CreateParserContext(jsonExpression, JSONElementContext.None);
+            _objectContext = CreateParserContext(objectExpression, JSONElementContext.Object);
+            _arrayContext = CreateParserContext(arrayExpression, JSONElementContext.Array);
+        }
+
+        static Token MakeToken(params JsonTokenType[] input) {
+            return Token.New( input.Select(t => (int)t).ToArray() );
+        }
+
+        static ParserContext CreateParserContext(Token expr, JSONElementContext context) {
+            
+            var dfa = new DFATable();
+            var builder = new RegularExpressionVisitor(dfa);
+            expr.Accept(builder);
+            builder.BuildDFA();
+
+            return new ParserContext(dfa.CreateTransitionTable(), dfa.InitialState, context);
+        }
+
+        #endregion
+
+        readonly JSONScanner m_scanner;
+        MemberContext m_memberContext;
+
+        JSONElementType m_elementType;
+        object m_elementValue;
+        string m_memberName = String.Empty;
+
+        Stack<ParserContext> m_stack = new Stack<ParserContext>();
+        ParserContext m_context = _jsonContext;
+
+        /// <summary>
+        /// Создает новый парсер на основе строки, содержащей JSON
+        /// </summary>
+        /// <param name="text"></param>
+        public JSONParser(string text) {
+            Safe.ArgumentNotEmpty(text, "text");
+            m_scanner = new JSONScanner(text);
+        }
+
+        /// <summary>
+        /// Создает новый экземпляр парсера, на основе текстового потока.
+        /// </summary>
+        /// <param name="reader">Текстовый поток.</param>
+        public JSONParser(TextReader reader) {
+            Safe.ArgumentNotNull(reader, "reader");
+            m_scanner = new JSONScanner(reader);
+        }
+
+        public int Level {
+            get { return m_stack.Count; }
+        }
+
+        /// <summary>
+        /// Тип текущего элемента на котором стоит парсер.
+        /// </summary>
+        public JSONElementType ElementType {
+            get { return m_elementType; }
+        }
+
+        /// <summary>
+        /// Имя элемента - имя свойства родительского контейнера. Для элементов массивов и корневого всегда
+        /// пустая строка.
+        /// </summary>
+        public string ElementName {
+            get { return m_memberName; }
+        }
+
+        /// <summary>
+        /// Значение элемента. Только для элементов типа <see cref="JSONElementType.Value"/>, для остальных <c>null</c>
+        /// </summary>
+        public object ElementValue {
+            get { return m_elementValue; }
+        }
+
+        /// <summary>
+        /// Читает слеюудущий объект из потока
+        /// </summary>
+        /// <returns><c>true</c> - операция чтения прошла успешно, <c>false</c> - конец данных</returns>
+        public bool Read() {
+            object tokenValue;
+            JsonTokenType tokenType;
+
+            m_memberName = String.Empty;
+
+            while (m_scanner.ReadToken(out tokenValue, out tokenType)) {
+                if(!m_context.Move(tokenType))
+                    UnexpectedToken(tokenValue, tokenType);
+
+                switch (tokenType) {
+                    case JsonTokenType.BeginObject:
+                        m_stack.Push(m_context);
+                        m_context = _objectContext;
+
+                        m_elementValue = null;
+                        m_memberContext = MemberContext.MemberName;
+                        m_elementType = JSONElementType.BeginObject;
+                        return true;
+                    case JsonTokenType.EndObject:
+                        if (m_stack.Count == 0)
+                            UnexpectedToken(tokenValue, tokenType);
+                        m_context = m_stack.Pop();
+
+                        m_elementValue = null;
+                        m_elementType = JSONElementType.EndObject;
+                        return true;
+                    case JsonTokenType.BeginArray:
+                        m_stack.Push(m_context);
+                        m_context = _arrayContext;
+
+                        m_elementValue = null;
+                        m_memberContext = MemberContext.MemberValue;
+                        m_elementType = JSONElementType.BeginArray;
+                        return true;
+                    case JsonTokenType.EndArray:
+                        if (m_stack.Count == 0)
+                            UnexpectedToken(tokenValue, tokenType);
+                        m_context = m_stack.Pop();
+
+                        m_elementValue = null;
+                        m_elementType = JSONElementType.EndArray;
+                        return true;
+                    case JsonTokenType.String:
+                        if (m_memberContext == MemberContext.MemberName) {
+                            m_memberName = (string)tokenValue;
+                            break;
+                        }
+                        m_elementType = JSONElementType.Value;
+                        m_elementValue = tokenValue;
+                        return true;
+                    case JsonTokenType.Number:
+                        m_elementType = JSONElementType.Value;
+                        m_elementValue = tokenValue;
+                        return true;
+                    case JsonTokenType.Literal:
+                        m_elementType = JSONElementType.Value;
+                        m_elementValue = ParseLiteral((string)tokenValue);
+                        return true;
+                    case JsonTokenType.NameSeparator:
+                        m_memberContext = MemberContext.MemberValue;
+                        break;
+                    case JsonTokenType.ValueSeparator:
+                        m_memberContext = m_context.ElementContext == JSONElementContext.Object ? MemberContext.MemberName : MemberContext.MemberValue;
+                        break;
+                    default:
+                        UnexpectedToken(tokenValue, tokenType);
+                        break;
+                }
+            }
+            if (m_context.ElementContext != JSONElementContext.None)
+                throw new ParserException("Unexpedted end of data");
+
+            EOF = true;
+
+            return false;
+        }
+
+        object ParseLiteral(string literal) {
+            switch (literal) {
+                case "null":
+                    return null;
+                case "false":
+                    return false;
+                case "true":
+                    return true;
+                default:
+                    UnexpectedToken(literal, JsonTokenType.Literal);
+                    return null; // avoid compliler error
+            }
+        }
+
+        void UnexpectedToken(object value, JsonTokenType tokenType) {
+            throw new ParserException(String.Format("Unexpected token {0}: '{1}'", tokenType, value));
+        }
+
+
+        /// <summary>
+        /// Признак конца потока
+        /// </summary>
+        public bool EOF {
+            get;
+            private set;
+        }
+
+        protected override void Dispose(bool disposing) {
+            if (disposing)
+                Safe.Dispose(m_scanner);
+        }
+
+        /// <summary>
+        /// Переходит в конец текущего объекта.
+        /// </summary>
+        public void SeekElementEnd() {
+            var level = Level - 1;
+
+            Debug.Assert(level >= 0);
+
+            while (Level != level)
+                Read();
+        }
+    }
+
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Formats/JSON/JSONScanner.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Formats/JSON/JSONScanner.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,109 @@
+using System;
+using System.Globalization;
+using Implab.Automaton;
+using System.Text;
+using Implab.Components;
+using System.IO;
+
+namespace Implab.Formats.JSON {
+    /// <summary>
+    /// Сканнер (лексер), разбивающий поток символов на токены JSON.
+    /// </summary>
+    public class JSONScanner : Disposable {
+        readonly StringBuilder m_builder = new StringBuilder();
+
+        readonly ScannerContext<JSONGrammar.TokenType> m_jsonContext = JSONGrammar.Instance.JsonExpression;
+        readonly ScannerContext<JSONGrammar.TokenType> m_stringContext = JSONGrammar.Instance.JsonStringExpression;
+
+
+        readonly TextScanner m_scanner;
+
+        /// <summary>
+        /// Создает новый экземпляр сканнера
+        /// </summary>
+        public JSONScanner(string text) {
+            Safe.ArgumentNotEmpty(text, "text");
+
+            m_scanner = new StringScanner(text);
+        }
+
+        public JSONScanner(TextReader reader, int bufferMax, int chunkSize) {
+            Safe.ArgumentNotNull(reader, "reader");
+
+            m_scanner = new ReaderScanner(reader, bufferMax, chunkSize);
+        }
+
+        public JSONScanner(TextReader reader) : this(reader, 1024*1024, 1024){
+        }
+
+        /// <summary>
+        /// Читает следующий лексический элемент из входных данных.
+        /// </summary>
+        /// <param name="tokenValue">Возвращает значение прочитанного токена.</param>
+        /// <param name="tokenType">Возвращает тип прочитанного токена.</param>
+        /// <returns><c>true</c> - чтение произведено успешно. <c>false</c> - достигнут конец входных данных</returns>
+        /// <remarks>В случе если токен не распознается, возникает исключение. Значения токенов обрабатываются, т.е.
+        /// в строках обрабатываются экранированные символы, числа становтся типа double.</remarks>
+        public bool ReadToken(out object tokenValue, out JsonTokenType tokenType) {
+            JSONGrammar.TokenType[] tag;
+            while (m_jsonContext.Execute(m_scanner, out tag)) {
+                switch (tag[0]) {
+                    case JSONGrammar.TokenType.StringBound:
+                        tokenValue = ReadString();
+                        tokenType = JsonTokenType.String;
+                        break;
+                    case JSONGrammar.TokenType.Number:
+                        tokenValue = Double.Parse(m_scanner.GetTokenValue(), CultureInfo.InvariantCulture);
+                        tokenType = JsonTokenType.Number;
+                        break;
+                    case JSONGrammar.TokenType.Whitespace:
+                        continue;
+                    default:
+                        tokenType = (JsonTokenType)tag[0];
+                        tokenValue = m_scanner.GetTokenValue();
+                        break;
+                }
+                return true;
+            }
+            tokenValue = null;
+            tokenType = JsonTokenType.None;
+            return false;
+        }
+
+        string ReadString() {
+            int pos = 0;
+            var buf = new char[6]; // the buffer for unescaping chars
+
+            JSONGrammar.TokenType[] tag;
+            m_builder.Clear();
+
+            while (m_stringContext.Execute(m_scanner, out tag)) {
+                switch (tag[0]) {
+                    case JSONGrammar.TokenType.StringBound:
+                        return m_builder.ToString();
+                    case JSONGrammar.TokenType.UnescapedChar:
+                        m_scanner.CopyTokenTo(m_builder);
+                        break;
+                    case JSONGrammar.TokenType.EscapedUnicode: // \xXXXX - unicode escape sequence
+                        m_scanner.CopyTokenTo(buf, 0); 
+                        m_builder.Append(StringTranslator.TranslateHexUnicode(buf, 2));
+                        pos++;
+                        break;
+                    case JSONGrammar.TokenType.EscapedChar:  // \t - escape sequence
+                        m_scanner.CopyTokenTo(buf, 0);
+                        m_builder.Append(StringTranslator.TranslateEscapedChar(buf[1]));
+                        break;
+                }
+
+            }
+
+            throw new ParserException("Unexpected end of data");
+        }
+
+        protected override void Dispose(bool disposing) {
+            if (disposing)
+                Safe.Dispose(m_scanner);
+            base.Dispose(disposing);
+        }
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Formats/JSON/JSONWriter.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Formats/JSON/JSONWriter.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,319 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Globalization;
+using System.Diagnostics;
+
+namespace Implab.Formats.JSON {
+    public class JSONWriter {
+        struct Context {
+            public bool needComma;
+            public JSONElementContext element;
+        }
+        Stack<Context> m_contextStack = new Stack<Context>();
+        Context m_context;
+
+        const int BUFFER_SIZE = 64;
+
+        TextWriter m_writer;
+        readonly bool m_indent = true;
+        readonly int m_indentSize = 4;
+        readonly char[] m_buffer = new char[BUFFER_SIZE];
+        int m_bufferPos;
+
+        static readonly char [] _hex = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
+        static readonly char [] _escapeBKS,
+            _escapeFWD,
+            _escapeCR,
+            _escapeNL,
+            _escapeTAB,
+            _escapeBSLASH,
+            _escapeQ;
+
+        static JSONWriter() {
+            _escapeBKS = "\\b".ToCharArray();
+            _escapeFWD = "\\f".ToCharArray();
+            _escapeCR = "\\r".ToCharArray();
+            _escapeNL = "\\n".ToCharArray();
+            _escapeTAB = "\\t".ToCharArray();
+            _escapeBSLASH = "\\\\".ToCharArray();
+            _escapeQ = "\\\"".ToCharArray();
+        }
+
+        public JSONWriter(TextWriter writer) {
+            Safe.ArgumentNotNull(writer, "writer");
+            m_writer = writer;
+        }
+
+        public JSONWriter(TextWriter writer, bool indent) {
+            Safe.ArgumentNotNull(writer, "writer");
+
+            m_writer = writer;
+            m_indent = indent;
+        }
+
+        void WriteIndent() {
+            if (m_indent) {
+                var indent = new char[m_contextStack.Count * m_indentSize + 1];
+                indent[0] = '\n';
+                for (int i = 1; i < indent.Length; i++)
+                    indent[i] = ' ';
+                m_writer.Write(new String(indent));
+            } else {
+                m_writer.Write(' ');
+            }
+        }
+
+        void WriteMemberName(string name) {
+            Safe.ArgumentNotEmpty(name, "name");
+            if (m_context.element != JSONElementContext.Object)
+                OperationNotApplicable("WriteMember");
+            if (m_context.needComma)
+                m_writer.Write(",");
+
+            WriteIndent();
+            m_context.needComma = true;
+            Write(name);
+            m_writer.Write(" : ");
+        }
+
+        public void WriteValue(string name, string value) {
+            WriteMemberName(name);
+            Write(value);            
+        }
+
+        public void WriteValue(string name, bool value) {
+            WriteMemberName(name);
+            Write(value);
+        }
+
+        public void WriteValue(string name, double value) {
+            WriteMemberName(name);
+            Write(value);
+        }
+
+        public void WriteValue(string value) {
+            if (m_context.element == JSONElementContext.Array) {
+
+                if (m_context.needComma)
+                    m_writer.Write(",");
+                WriteIndent();
+                m_context.needComma = true;
+
+                Write(value);
+            } else if (m_context.element == JSONElementContext.None) {
+                Write(value);
+                m_context.element = JSONElementContext.Closed;
+            } else {
+                OperationNotApplicable("WriteValue");
+            }
+        }
+
+        public void WriteValue(bool value) {
+            if (m_context.element == JSONElementContext.Array) {
+
+                if (m_context.needComma)
+                    m_writer.Write(",");
+                WriteIndent();
+                m_context.needComma = true;
+
+                Write(value);
+            } else if (m_context.element == JSONElementContext.None) {
+                Write(value);
+                m_context.element = JSONElementContext.Closed;
+            } else {
+                OperationNotApplicable("WriteValue");
+            }
+        }
+
+        public void WriteValue(double value) {
+            if (m_context.element == JSONElementContext.Array) {
+
+                if (m_context.needComma)
+                    m_writer.Write(",");
+                WriteIndent();
+                m_context.needComma = true;
+
+                Write(value);
+            } else if (m_context.element == JSONElementContext.None) {
+                Write(value);
+                m_context.element = JSONElementContext.Closed;
+            } else {
+                OperationNotApplicable("WriteValue");
+            }
+        }
+        
+        public void BeginObject() {
+            if (m_context.element != JSONElementContext.None && m_context.element != JSONElementContext.Array)
+                OperationNotApplicable("BeginObject");
+            if (m_context.needComma)
+                m_writer.Write(",");
+
+            WriteIndent();
+
+            m_context.needComma = true;
+
+            m_contextStack.Push(m_context);
+
+            m_context = new Context { element = JSONElementContext.Object, needComma = false };
+            m_writer.Write("{");
+        }
+
+        public void BeginObject(string name) {
+            WriteMemberName(name);
+
+            m_contextStack.Push(m_context);
+
+            m_context = new Context { element = JSONElementContext.Object, needComma = false };
+            m_writer.Write("{");
+        }
+
+        public void EndObject() {
+            if (m_context.element != JSONElementContext.Object)
+                OperationNotApplicable("EndObject");
+
+            m_context = m_contextStack.Pop();
+            if (m_contextStack.Count == 0)
+                m_context.element = JSONElementContext.Closed;
+            WriteIndent();
+            m_writer.Write("}");
+        }
+
+        public void BeginArray() {
+            if (m_context.element != JSONElementContext.None && m_context.element != JSONElementContext.Array)
+                throw new InvalidOperationException();
+            if (m_context.needComma) {
+                m_writer.Write(",");
+
+            }
+            m_context.needComma = true;
+
+            WriteIndent();
+            m_contextStack.Push(m_context);
+            m_context = new Context { element = JSONElementContext.Array, needComma = false };
+            m_writer.Write("[");
+        }
+
+        public void BeginArray(string name) {
+            WriteMemberName(name);
+
+            m_contextStack.Push(m_context);
+
+            m_context = new Context { element = JSONElementContext.Array, needComma = false };
+            m_writer.Write("[");
+        }
+
+        public void EndArray() {
+            if (m_context.element != JSONElementContext.Array)
+                OperationNotApplicable("EndArray");
+
+            m_context = m_contextStack.Pop();
+            if (m_contextStack.Count == 0)
+                m_context.element = JSONElementContext.Closed;
+            WriteIndent();
+            m_writer.Write("]");
+        }
+
+        void Write(bool value) {
+            m_writer.Write(value ? "true" : "false");
+        }
+
+        void FlushBuffer() {
+            if (m_bufferPos > 0) {
+                m_writer.Write(m_buffer, 0, m_bufferPos);
+                m_bufferPos = 0;
+            }
+        }
+
+        void Write(string value) {
+            if (value == null) {
+                m_writer.Write("null");
+                return;
+            }
+
+            Debug.Assert(m_bufferPos == 0);
+
+            var chars = value.ToCharArray();
+            m_buffer[m_bufferPos++] = '"';
+
+            // Analysis disable once ForCanBeConvertedToForeach
+            for (int i = 0; i < chars.Length; i++) {
+                var ch = chars[i];
+
+                char[] escapeSeq;
+
+                switch (ch) {
+                    case '\b':
+                        escapeSeq = _escapeBKS;
+                        break;
+                    case '\f':
+                        escapeSeq = _escapeFWD;
+                        break;
+                    case '\r':
+                        escapeSeq = _escapeCR;
+                        break;
+                    case '\n':
+                        escapeSeq = _escapeNL;
+                        break;
+                    case '\t':
+                        escapeSeq = _escapeTAB;
+                        break;
+                    case '\\':
+                        escapeSeq = _escapeBSLASH;
+                        break;
+                    case '"':
+                        escapeSeq = _escapeQ;
+                        break;
+                    default:
+                        if (ch < 0x20) {
+                            if (m_bufferPos + 6 > BUFFER_SIZE)
+                                FlushBuffer();
+
+                            m_buffer[m_bufferPos++] = '\\';
+                            m_buffer[m_bufferPos++] = 'u';
+                            m_buffer[m_bufferPos++] = '0';
+                            m_buffer[m_bufferPos++] = '0';
+                            m_buffer[m_bufferPos++] = _hex[ch >> 4 & 0xf];
+                            m_buffer[m_bufferPos++] = _hex[ch & 0xf];
+
+                        } else {
+                            if (m_bufferPos >= BUFFER_SIZE)
+                                FlushBuffer();
+                            m_buffer[m_bufferPos++] = ch;
+                        }
+                        continue;
+                }
+
+                if (m_bufferPos + escapeSeq.Length > BUFFER_SIZE)
+                    FlushBuffer();
+
+                Array.Copy(escapeSeq, 0, m_buffer, m_bufferPos, escapeSeq.Length);
+                m_bufferPos += escapeSeq.Length;
+
+            }
+
+            if (m_bufferPos >= BUFFER_SIZE)
+                FlushBuffer();
+            
+            m_buffer[m_bufferPos++] = '"';
+
+            FlushBuffer();
+        }
+
+        void Write(double value) {
+            if (double.IsNaN(value))
+                Write("NaN");
+            else if (double.IsNegativeInfinity(value))
+                Write("-Infinity");
+            else if (double.IsPositiveInfinity(value))
+                Write("Infinity");
+            else
+                m_writer.Write(value.ToString(CultureInfo.InvariantCulture));
+        }
+
+        void OperationNotApplicable(string opName) {
+            throw new InvalidOperationException(String.Format("The operation '{0}' isn't applicable in the context of '{1}'", opName, m_context.element ));
+        }
+        
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Formats/JSON/JSONXmlReader.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Formats/JSON/JSONXmlReader.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,335 @@
+using Implab;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Xml;
+
+namespace Implab.Formats.JSON {
+    public class JSONXmlReader : XmlReader {
+
+        enum ValueContext {
+            Undefined,
+            ElementStart,
+            ElementValue,
+            ElementEnd,
+            ElementEmpty
+        }
+
+        struct LocalNameContext {
+            public string localName;
+            public bool isArray;
+        }
+
+        JSONParser m_parser;
+        ValueContext m_valueContext;
+        ReadState m_state = ReadState.Initial;
+        Stack<LocalNameContext> m_localNameStack = new Stack<LocalNameContext>();
+        LocalNameContext m_localName;
+        int m_depthCorrection;
+
+        readonly string m_rootName;
+        readonly string m_prefix;
+        readonly string m_namespaceUri;
+        readonly bool m_flattenArrays;
+        readonly string m_arrayItemName;
+        readonly XmlNameTable m_nameTable;
+
+        JSONXmlReader(JSONParser parser, JSONXmlReaderOptions options) {
+            m_parser = parser;
+
+            if (options != null) {
+                m_prefix = options.NodesPrefix ?? String.Empty;
+                m_namespaceUri = options.NamespaceURI ?? String.Empty;
+                m_rootName = options.RootName ?? "json";
+                m_flattenArrays = options.FlattenArrays;
+                m_arrayItemName = options.ArrayItemName ?? "item";
+                m_nameTable = options.NameTable ?? new NameTable();
+            } else {
+                m_prefix = String.Empty;
+                m_namespaceUri = String.Empty;
+                m_rootName = "json";
+                m_flattenArrays = false;
+                m_arrayItemName = "item";
+                m_nameTable = new NameTable();
+            }
+        }
+
+        /// <summary>
+        /// Always 0, JSON doesn't support attributes
+        /// </summary>
+        public override int AttributeCount {
+            get { return 0; }
+        }
+
+        public override string BaseURI {
+            get { return String.Empty; }
+        }
+
+        public override int Depth {
+            get {
+                return m_localNameStack.Count + m_depthCorrection;
+            }
+        }
+
+        public override bool EOF {
+            get { return m_parser.EOF; }
+        }
+
+        /// <summary>
+        /// Always throws an exception
+        /// </summary>
+        /// <param name="i"></param>
+        /// <returns></returns>
+        public override string GetAttribute(int i) {
+            throw new ArgumentOutOfRangeException();
+        }
+
+        /// <summary>
+        /// Always returns empty string
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="namespaceURI"></param>
+        /// <returns></returns>
+        public override string GetAttribute(string name, string namespaceURI) {
+            return String.Empty;
+        }
+
+        /// <summary>
+        /// Always returns empty string
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public override string GetAttribute(string name) {
+            return String.Empty;
+        }
+
+        public override bool IsEmptyElement {
+            get { return m_parser.ElementType == JSONElementType.Value && m_valueContext == ValueContext.ElementEmpty; }
+        }
+
+        public override string LocalName {
+            get { return m_localName.localName; }
+        }
+
+        public override string LookupNamespace(string prefix) {
+            if (String.IsNullOrEmpty(prefix) || prefix == m_prefix)
+                return m_namespaceUri;
+            
+            return String.Empty;
+        }
+
+        public override bool MoveToAttribute(string name, string ns) {
+            return false;
+        }
+
+        public override bool MoveToAttribute(string name) {
+            return false;
+        }
+
+        public override bool MoveToElement() {
+            return false;
+        }
+
+        public override bool MoveToFirstAttribute() {
+            return false;
+        }
+
+        public override bool MoveToNextAttribute() {
+            return false;
+        }
+
+        public override XmlNameTable NameTable {
+            get { return m_nameTable; }
+        }
+
+        public override string NamespaceURI {
+            get { return m_namespaceUri; }
+        }
+
+        public override XmlNodeType NodeType {
+            get {
+                switch (m_parser.ElementType) {
+                    case JSONElementType.BeginObject:
+                    case JSONElementType.BeginArray:
+                        return XmlNodeType.Element;
+                    case JSONElementType.EndObject:
+                    case JSONElementType.EndArray:
+                        return XmlNodeType.EndElement;
+                    case JSONElementType.Value:
+                        switch (m_valueContext) {
+                            case ValueContext.ElementStart:
+                            case ValueContext.ElementEmpty:
+                                return XmlNodeType.Element;
+                            case ValueContext.ElementValue:
+                                return XmlNodeType.Text;
+                            case ValueContext.ElementEnd:
+                                return XmlNodeType.EndElement;
+                            default:
+                                throw new InvalidOperationException();
+                        }
+                    default:
+                        throw new InvalidOperationException();
+                }
+            }
+        }
+
+        public override string Prefix {
+            get { return m_prefix; }
+        }
+
+        public override bool Read() {
+            if (m_state != ReadState.Interactive && m_state != ReadState.Initial)
+                return false;
+
+            if (m_state == ReadState.Initial)
+                m_state = ReadState.Interactive;
+
+            try {
+                switch (m_parser.ElementType) {
+                    case JSONElementType.Value:
+                        switch (m_valueContext) {
+                            case ValueContext.ElementStart:
+                                SetLocalName(String.Empty);
+                                m_valueContext = ValueContext.ElementValue;
+                                return true;
+                            case ValueContext.ElementValue:
+                                RestoreLocalName();
+                                m_valueContext = ValueContext.ElementEnd;
+                                return true;
+                            case ValueContext.ElementEmpty:
+                            case ValueContext.ElementEnd:
+                                RestoreLocalName();
+                                break;
+                        }
+                        break;
+                    case JSONElementType.EndArray:
+                    case JSONElementType.EndObject:
+                        RestoreLocalName();
+                        break;
+                }
+                string itemName = m_parser.ElementType == JSONElementType.None ? m_rootName : m_flattenArrays ? m_localName.localName : m_arrayItemName;
+                while (m_parser.Read()) {
+                    if (!String.IsNullOrEmpty(m_parser.ElementName))
+                        itemName = m_parser.ElementName;
+
+                    switch (m_parser.ElementType) {
+                        case JSONElementType.BeginArray:
+                            if (m_flattenArrays && !m_localName.isArray) {
+                                m_depthCorrection--;
+                                SetLocalName(itemName, true);
+                                continue;
+                            }
+                            SetLocalName(itemName, true);
+                            break;
+                        case JSONElementType.BeginObject:
+                            SetLocalName(itemName);
+                            break;
+                        case JSONElementType.EndArray:
+                            if (m_flattenArrays && !m_localNameStack.Peek().isArray) {
+                                RestoreLocalName();
+                                m_depthCorrection++;
+                                continue;
+                            }
+                            break;
+                        case JSONElementType.EndObject:
+                            break;
+                        case JSONElementType.Value:
+                            SetLocalName(itemName);
+                            m_valueContext = m_parser.ElementValue == null ? ValueContext.ElementEmpty : ValueContext.ElementStart;
+                            break;
+                    }
+                    return true;
+                }
+
+                m_state = ReadState.EndOfFile;
+                return false;
+            } catch {
+                m_state = ReadState.Error;
+                throw;
+            }
+        }
+
+        public override bool ReadAttributeValue() {
+            return false;
+        }
+
+        public override ReadState ReadState {
+            get { return m_state; }
+        }
+
+        public override void ResolveEntity() {
+            // do nothing
+        }
+
+        public override string Value {
+            get {
+                if (m_parser.ElementValue == null)
+                    return String.Empty;
+                if (Convert.GetTypeCode(m_parser.ElementValue) == TypeCode.Double)
+                    return ((double)m_parser.ElementValue).ToString(CultureInfo.InvariantCulture);
+                return m_parser.ElementValue.ToString();
+            }
+        }
+
+        void SetLocalName(string name) {
+            m_localNameStack.Push(m_localName);
+            m_localName.localName = name;
+            m_localName.isArray = false;
+        }
+
+        void SetLocalName(string name, bool isArray) {
+            m_localNameStack.Push(m_localName);
+            m_localName.localName = name;
+            m_localName.isArray = isArray;
+        }
+
+        void RestoreLocalName() {
+            m_localName = m_localNameStack.Pop();
+        }
+
+        public override void Close() {
+
+        }
+
+        protected override void Dispose(bool disposing) {
+            #if MONO
+            disposing = true;
+            #endif
+            if (disposing) {
+                m_parser.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        public static JSONXmlReader Create(string file, JSONXmlReaderOptions options) {
+            return Create(File.OpenText(file), options);
+        }
+
+        /// <summary>
+        /// Creates the XmlReader for the specified text stream with JSON data.
+        /// </summary>
+        /// <param name="reader">Text reader.</param>
+        /// <param name="options">Options.</param>
+        /// <remarks>
+        /// The reader will be disposed when the XmlReader is disposed.
+        /// </remarks>
+        public static JSONXmlReader Create(TextReader reader,  JSONXmlReaderOptions options) {
+            return new JSONXmlReader(new JSONParser(reader), options);
+        }
+
+        /// <summary>
+        /// Creates the XmlReader for the specified stream with JSON data.
+        /// </summary>
+        /// <param name="stream">Stream.</param>
+        /// <param name="options">Options.</param>
+        /// <remarks>
+        /// The stream will be disposed when the XmlReader is disposed.
+        /// </remarks>
+        public static JSONXmlReader Create(Stream stream,  JSONXmlReaderOptions options) {
+            Safe.ArgumentNotNull(stream, "stream");
+            // HACK don't dispose StreaReader to keep stream opened
+            return Create(new StreamReader(stream), options);
+        }
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Formats/JSON/JSONXmlReaderOptions.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Formats/JSON/JSONXmlReaderOptions.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,62 @@
+
+using System.Xml;
+
+namespace Implab.Formats.JSON {
+    /// <summary>
+    /// Набор необязательных параметров для <see cref="JSONXmlReader"/>, позволяющий управлять процессом
+    /// интерпретации <c>JSON</c> документа.
+    /// </summary>
+    public class JSONXmlReaderOptions {
+        /// <summary>
+        /// Пространство имен в котором будут располагаться читаемые элементы документа
+        /// </summary>
+        public string NamespaceURI {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Интерпретировать массивы как множественные элементы (убирает один уровень вложенности), иначе массив
+        /// представляется в виде узла, дочерними элементами которого являются элементы массива, имена дочерних элементов
+        /// определяются свойством <see cref="ArrayItemName"/>. По умолчанию <c>false</c>.
+        /// </summary>
+        public bool FlattenArrays {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Префикс, для узлов документа
+        /// </summary>
+        public string NodesPrefix {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Имя корневого элемента в xml документе
+        /// </summary>
+        public string RootName {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Имя элемента для массивов, если не включена опция <see cref="FlattenArrays"/>.
+        /// По умолчанию <c>item</c>.
+        /// </summary>
+        public string ArrayItemName {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Таблица атомизированных строк для построения документа.
+        /// </summary>
+        public XmlNameTable NameTable {
+            get;
+            set;
+        }
+
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Formats/JSON/JsonTokenType.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Formats/JSON/JsonTokenType.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,44 @@
+namespace Implab.Formats.JSON {
+    /// <summary>
+    /// Тип токенов, возвращаемых <see cref="JSONScanner"/>.
+    /// </summary>
+    public enum JsonTokenType : int {
+        None = 0,
+        /// <summary>
+        /// Начало объекта
+        /// </summary>
+        BeginObject,
+        /// <summary>
+        /// Конец объекта
+        /// </summary>
+        EndObject,
+        /// <summary>
+        /// Начало массива
+        /// </summary>
+        BeginArray,
+        /// <summary>
+        /// Конец массива
+        /// </summary>
+        EndArray,
+        /// <summary>
+        /// Строка
+        /// </summary>
+        String,
+        /// <summary>
+        /// Число
+        /// </summary>
+        Number,
+        /// <summary>
+        /// Литерал
+        /// </summary>
+        Literal,
+        /// <summary>
+        /// Разделитель имени <c>:</c>
+        /// </summary>
+        NameSeparator,
+        /// <summary>
+        /// Разделитель имени <c>,</c>
+        /// </summary>
+        ValueSeparator
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Formats/JSON/StringTranslator.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Formats/JSON/StringTranslator.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,52 @@
+using Implab;
+using Implab.Formats;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Implab.Formats.JSON {
+    /// <summary>
+    /// Класс для преобразования экранированной строки JSON
+    /// </summary>
+    static class StringTranslator {
+        static readonly char[] _escMap;
+        static readonly int[] _hexMap;
+
+        static StringTranslator() {
+            var chars = new char[] { 'b', 'f', 't', 'r', 'n', '\\', '/' };
+            var vals = new char[] { '\b', '\f', '\t', '\r', '\n', '\\', '/' };
+
+            _escMap = new char[chars.Max() + 1];
+
+            for (int i = 0; i < chars.Length; i++)
+                _escMap[chars[i]] = vals[i];
+
+            var hexs = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F' };
+            var ints = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 10, 11, 12, 13, 14, 15 };
+
+            _hexMap = new int[hexs.Max() + 1];
+
+            for (int i = 0; i < hexs.Length; i++)
+                _hexMap[hexs[i]] = ints[i];
+
+        }
+
+        internal static char TranslateEscapedChar(char symbol) {
+            return _escMap[symbol];
+        }
+
+        internal static char TranslateHexUnicode(char[] symbols, int offset) {
+            Debug.Assert(symbols != null);
+            Debug.Assert(symbols.Length - offset >= 4);
+
+            int value = (_hexMap[symbols[offset]] << 12)
+                | (_hexMap[symbols[offset + 1]] << 8)
+                | (_hexMap[symbols[offset + 2]] << 4)
+                | (_hexMap[symbols[offset + 3]]);
+            return (char)value;
+        }
+    }
+}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Formats/ReaderScanner.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Formats/ReaderScanner.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,30 @@
+using System;
+using System.IO;
+
+namespace Implab.Formats {
+    public class ReaderScanner: TextScanner {
+        const int CHUNK_SIZE = 1024*4;
+        const int BUFFER_MAX = CHUNK_SIZE*1024;
+
+        readonly TextReader m_reader;
+
+        public ReaderScanner(TextReader reader, int limit, int chunk) : base(limit, chunk) {
+            Safe.ArgumentNotNull(reader, "reader");
+            m_reader = reader;
+        }
+
+        public ReaderScanner(TextReader reader) : this(reader, BUFFER_MAX, CHUNK_SIZE) {
+        }
+
+        protected override int Read(char[] buffer, int offset, int size) {
+            return m_reader.Read(buffer, offset, size);
+        }
+
+        protected override void Dispose(bool disposing) {
+            if (disposing)
+                Safe.Dispose(m_reader);
+            base.Dispose(disposing);
+        }
+    }
+}
+
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Formats/ScannerContext.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Formats/ScannerContext.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,30 @@
+namespace Implab.Formats {
+    /// <summary>
+    /// Represents a scanner configuration usefull to recongnize token, based on the DFA.
+    /// </summary>
+    public class ScannerContext<TTag> {
+
+        public int[,] Dfa { get; private set; }
+
+        public bool[] Final { get; private set; }
+
+        public TTag[][] Tags { get; private set; }
+
+        public int State { get; private set; }
+
+        public int[] Alphabet { get; private set; }
+
+        public ScannerContext(int[,] dfa, bool[] final, TTag[][] tags, int state, int[] alphabet) {
+            Dfa = dfa;
+            Final = final;
+            Tags = tags;
+            State = state;
+            Alphabet = alphabet;
+        }
+
+        public bool Execute(TextScanner scanner, out TTag[] tag) {
+            return scanner.ReadToken(Dfa, Final, Tags, State, Alphabet, out tag);
+        }
+    }
+}
+
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Formats/StringScanner.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Formats/StringScanner.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,18 @@
+using System;
+
+namespace Implab.Formats {
+    public class StringScanner: TextScanner {
+        const int CHUNK_SIZE = 1024;
+
+        public StringScanner(string text) : base(null) {
+            Safe.ArgumentNotNull(text, "text");
+            var data = text.ToCharArray();
+            Feed(data, 0, data.Length);
+        }
+
+        protected override int Read(char[] buffer, int offset, int size) {
+            return 0;
+        }
+    }
+}
+
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Formats/TextScanner.cs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Implab/Formats/TextScanner.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,157 @@
+using System;
+using Implab.Components;
+using System.Diagnostics;
+using Implab.Automaton;
+using System.Text;
+
+namespace Implab.Formats {
+    public abstract class TextScanner : Disposable {
+        readonly int m_bufferMax;
+        readonly int m_chunkSize;
+
+        char[] m_buffer;
+        int m_bufferOffset;
+        int m_bufferSize;
+        int m_tokenOffset;
+        int m_tokenLength;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Implab.Formats.TextScanner"/> class.
+        /// </summary>
+        /// <param name="bufferMax">Buffer max.</param>
+        /// <param name="chunkSize">Chunk size.</param>
+        protected TextScanner(int bufferMax, int chunkSize) {
+            Debug.Assert(m_chunkSize <= m_bufferMax);
+
+            m_bufferMax = bufferMax;
+            m_chunkSize = chunkSize;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Implab.Formats.TextScanner"/> class.
+        /// </summary>
+        /// <param name="buffer">Buffer.</param>
+        protected TextScanner(char[] buffer) {
+            if (buffer != null) {
+                m_buffer = buffer;
+                m_bufferSize = buffer.Length;
+            }
+        }
+
+        /// <summary>
+        /// (hungry) Reads the next token.
+        /// </summary>
+        /// <returns><c>true</c>, if token internal was read, <c>false</c> if there is no more tokens in the stream.</returns>
+        /// <param name="dfa">The transition map for the automaton</param>
+        /// <param name="final">Final states of the automaton.</param>
+        /// <param name="tags">Tags.</param>
+        /// <param name="state">The initial state for the automaton.</param>
+        /// <param name="alphabet"></param>
+        /// <param name = "tag"></param>
+        internal bool ReadToken<TTag>(int[,] dfa, bool[] final, TTag[][] tags, int state, int[] alphabet, out TTag[] tag) {
+            m_tokenLength = 0;
+            tag = null;
+
+            var maxSymbol = alphabet.Length - 1;
+            int next;
+            do {
+                // after the next chunk is read the offset in the buffer may change
+                int pos = m_bufferOffset + m_tokenLength;
+                next = state;
+                while (pos < m_bufferSize) {
+                    var ch = m_buffer[pos];
+
+                    next = dfa[next, ch > maxSymbol ? AutomatonConst.UNCLASSIFIED_INPUT : alphabet[ch]];
+                    
+                    if (next == AutomatonConst.UNREACHABLE_STATE)
+                        break;
+                 
+                    state = next;
+                    pos++;
+                }
+                m_tokenLength = pos - m_bufferOffset;
+            } while (next != AutomatonConst.UNREACHABLE_STATE && Feed());
+
+            m_tokenOffset = m_bufferOffset;
+            m_bufferOffset += m_tokenLength;
+
+            if (final[state]) {
+                tag = tags[state];
+                return true;
+            }
+
+            if (m_bufferOffset == m_bufferSize) {
+                if (m_tokenLength == 0) //EOF
+                        return false;
+                    
+                throw new ParserException();
+            }
+
+            throw new ParserException(String.Format("Unexpected symbol '{0}'", m_buffer[m_bufferOffset]));
+            
+        }
+
+        protected void Feed(char[] buffer, int offset, int length) {
+            m_buffer = buffer;
+            m_bufferOffset = offset;
+            m_bufferSize = offset + length;
+        }
+
+        protected bool Feed() {
+            if (m_chunkSize <= 0)
+                return false;
+            
+            if (m_buffer != null) {
+                var free = m_buffer.Length - m_bufferSize;
+
+                if (free < m_chunkSize) {
+                    free += m_chunkSize;
+                    var used = m_bufferSize - m_bufferOffset;
+                    var size = used + free;
+
+                    if (size > m_bufferMax)
+                        throw new ParserException(String.Format("The buffer limit ({0} Kb) is reached", m_bufferMax / 1024));
+                    
+                    var temp = new char[size];
+
+                    var read = Read(temp, used, m_chunkSize);
+                    if (read == 0)
+                        return false;
+
+                    Array.Copy(m_buffer, m_bufferOffset, temp, 0, used);
+
+                    m_bufferOffset = 0;
+                    m_bufferSize = used + read;
+                    m_buffer = temp;
+                } else {
+                    var read = Read(m_buffer, m_bufferSize, m_chunkSize);
+                    if (read == 0)
+                        return false;
+                    m_bufferSize += m_chunkSize;
+                }
+                return true;
+            } else {
+                Debug.Assert(m_bufferOffset == 0);
+                m_buffer = new char[m_chunkSize];
+                m_bufferSize = Read(m_buffer, 0, m_chunkSize);
+                return (m_bufferSize != 0);
+            }
+        }
+
+        protected abstract int Read(char[] buffer, int offset, int size);
+
+        public string GetTokenValue() {
+            return new String(m_buffer, m_tokenOffset, m_tokenLength);
+        }
+
+        public void CopyTokenTo(char[] buffer, int offset) {
+            Array.Copy(m_buffer, m_tokenOffset,buffer, offset, m_tokenLength);
+        }
+
+        public void CopyTokenTo(StringBuilder sb) {
+            sb.Append(m_buffer, m_tokenOffset, m_tokenLength);
+        }
+         
+    }
+}
+
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/FuncChainTask.cs
--- a/Implab/FuncChainTask.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/FuncChainTask.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -13,8 +13,10 @@
             if (m_task != null && LockCancelation()) {
                 try {
                     var operation = m_task();
-                    operation.On(SetResult, HandleErrorInternal, SetCancelled);
+                    operation.On(SetResult, HandleErrorInternal, HandleCancelInternal);
                     CancellationRequested(operation.Cancel);
+                } catch (OperationCanceledException reason) {
+                    HandleCancelInternal(reason);
                 } catch (Exception err) {
                     HandleErrorInternal(err);
                 }
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/FuncChainTaskBase.cs
--- a/Implab/FuncChainTaskBase.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/FuncChainTaskBase.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -1,13 +1,10 @@
 using System;
-using System.Threading;
 
 namespace Implab {
-    public class FuncChainTaskBase<TResult> : AbstractPromise<TResult> {
+    public class FuncChainTaskBase<TResult> : AbstractTask<TResult> {
         readonly Func<Exception, IPromise<TResult>> m_error;
         readonly Func<Exception, IPromise<TResult>> m_cancel;
 
-        int m_cancelationLock;
-
         protected FuncChainTaskBase( Func<Exception, IPromise<TResult>> error, Func<Exception, IPromise<TResult>> cancel, bool autoCancellable) {
             m_error = error;
             m_cancel = cancel;
@@ -21,37 +18,36 @@
         }
 
         public override void CancelOperation(Exception reason) {
-            if (LockCancelation()) {
-                if (m_cancel != null) {
-                    try {
-                        m_cancel(reason).On(SetResult, HandleErrorInternal, SetCancelled);
-                    } catch (Exception err) {
-                        HandleErrorInternal(err);
-                    }
-                } else {
-                    SetCancelled(reason);
-                }
-            }
-
+            if (LockCancelation())
+                HandleCancelInternal(reason);
         }
 
         protected void HandleErrorInternal(Exception error) {
             if (m_error != null) {
                 try {
-                    var operation = m_error(error);
-
-                    operation.On(SetResult, SetError, SetCancelled);
-                    CancellationRequested(operation.Cancel);
+                    var p = m_error(error);
+                    p.On(SetResult, SetErrorInternal, SetCancelledInternal);
+                    CancellationRequested(p.Cancel);
                 } catch(Exception err) {
-                    SetError(err);
+                    SetErrorInternal(err);
                 }
             } else {
-                SetError(error);
+                SetErrorInternal(error);
             }
         }
 
-        protected bool LockCancelation() {
-            return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
+        protected void HandleCancelInternal(Exception reason) {
+            if (m_cancel != null) {
+                try {
+                    var p = m_cancel(reason);
+                    p.On(SetResult, HandleErrorInternal, SetCancelledInternal);
+                    CancellationRequested(p.Cancel);
+                } catch (Exception err) {
+                    HandleErrorInternal(err);
+                }
+            } else {
+                HandleErrorInternal(reason ?? new OperationCanceledException());
+            }
         }
     }
 }
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/FuncChainTaskT.cs
--- a/Implab/FuncChainTaskT.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/FuncChainTaskT.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -14,6 +14,8 @@
                     var operation = m_task(value);
                     operation.On(SetResult, HandleErrorInternal, SetCancelled);
                     CancellationRequested(operation.Cancel);
+                } catch (OperationCanceledException reason) {
+                    HandleCancelInternal(reason);
                 } catch (Exception err) {
                     HandleErrorInternal(err);
                 }
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/FuncTask.cs
--- a/Implab/FuncTask.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/FuncTask.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -13,6 +13,8 @@
             if (m_task != null && LockCancelation()) {
                 try {
                     SetResult(m_task());
+                } catch(OperationCanceledException reason)  {
+                    HandleCancelInternal(reason);
                 } catch(Exception err) {
                     HandleErrorInternal(err);
                 }
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/FuncTaskBase.cs
--- a/Implab/FuncTaskBase.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/FuncTaskBase.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -1,13 +1,10 @@
 using System;
-using System.Threading;
 
 namespace Implab {
-    public class FuncTaskBase<TResult> : AbstractPromise<TResult> {
+    public class FuncTaskBase<TResult> : AbstractTask<TResult> {
         readonly Func<Exception, TResult> m_cancel;
         readonly Func<Exception, TResult> m_error;
 
-        int m_cancelationLock;
-
         protected FuncTaskBase( Func<Exception, TResult> error, Func<Exception, TResult> cancel, bool autoCancellable) {
             m_error = error;
             m_cancel = cancel;
@@ -26,30 +23,30 @@
                 try {
                     SetResult(m_error(error));
                 } catch(Exception err) {
-                    SetError(err);
+                    SetErrorInternal(err);
                 }
             } else {
-                SetError(error);
+                SetErrorInternal(error);
             }
         }
 
         public override void CancelOperation(Exception reason) {
-            if (LockCancelation()) {
-                if (m_cancel != null) {
-                    try {
-                        SetResult(m_cancel(reason));
-                    } catch (Exception err) {
-                        HandleErrorInternal(err);
-                    }
-                } else {
-                    SetCancelled(reason);
+            if (LockCancelation())
+                HandleCancelInternal(reason);
+        }
+
+        protected void HandleCancelInternal(Exception reason) {
+            if (m_cancel != null) {
+                try {
+                    SetResult(m_cancel(reason));
+                } catch (Exception err) {
+                    HandleErrorInternal(err);
                 }
+            } else {
+                HandleErrorInternal(reason ?? new OperationCanceledException());
             }
         }
 
-        protected bool LockCancelation() {
-            return 0 == Interlocked.CompareExchange(ref m_cancelationLock, 1, 0);
-        }
     }
 }
 
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/FuncTaskT.cs
--- a/Implab/FuncTaskT.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/FuncTaskT.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -12,7 +12,9 @@
             if (m_task != null && LockCancelation()) {
                 try {
                     SetResult(m_task(value));
-                } catch (Exception err) {
+                } catch(OperationCanceledException reason)  {
+                    HandleCancelInternal(reason);
+                } catch(Exception err) {
                     HandleErrorInternal(err);
                 }
             }
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Implab.csproj
--- a/Implab/Implab.csproj	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/Implab.csproj	Fri Apr 22 13:08:08 2016 +0300
@@ -8,6 +8,9 @@
     <RootNamespace>Implab</RootNamespace>
     <AssemblyName>Implab</AssemblyName>
     <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <ReleaseVersion>0.2</ReleaseVersion>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -88,40 +91,10 @@
     <Compile Include="IPromise.cs" />
     <Compile Include="IServiceLocator.cs" />
     <Compile Include="ITaskController.cs" />
-    <Compile Include="JSON\JSONElementContext.cs" />
-    <Compile Include="JSON\JSONElementType.cs" />
-    <Compile Include="JSON\JSONGrammar.cs" />
-    <Compile Include="JSON\JSONParser.cs" />
-    <Compile Include="JSON\JSONScanner.cs" />
-    <Compile Include="JSON\JsonTokenType.cs" />
-    <Compile Include="JSON\JSONWriter.cs" />
-    <Compile Include="JSON\JSONXmlReader.cs" />
-    <Compile Include="JSON\JSONXmlReaderOptions.cs" />
-    <Compile Include="JSON\StringTranslator.cs" />
     <Compile Include="Parallels\DispatchPool.cs" />
     <Compile Include="Parallels\ArrayTraits.cs" />
     <Compile Include="Parallels\MTQueue.cs" />
     <Compile Include="Parallels\WorkerPool.cs" />
-    <Compile Include="Parsing\AltToken.cs" />
-    <Compile Include="Parsing\BinaryToken.cs" />
-    <Compile Include="Parsing\CatToken.cs" />
-    <Compile Include="Parsing\CDFADefinition.cs" />
-    <Compile Include="Parsing\DFABuilder.cs" />
-    <Compile Include="Parsing\DFAStateDescriptor.cs" />
-    <Compile Include="Parsing\DFAutomaton.cs" />
-    <Compile Include="Parsing\EDFADefinition.cs" />
-    <Compile Include="Parsing\EmptyToken.cs" />
-    <Compile Include="Parsing\EndToken.cs" />
-    <Compile Include="Parsing\EnumAlphabet.cs" />
-    <Compile Include="Parsing\Grammar.cs" />
-    <Compile Include="Parsing\IAlphabet.cs" />
-    <Compile Include="Parsing\IDFADefinition.cs" />
-    <Compile Include="Parsing\IVisitor.cs" />
-    <Compile Include="Parsing\ParserException.cs" />
-    <Compile Include="Parsing\Scanner.cs" />
-    <Compile Include="Parsing\StarToken.cs" />
-    <Compile Include="Parsing\SymbolToken.cs" />
-    <Compile Include="Parsing\Token.cs" />
     <Compile Include="ProgressInitEventArgs.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Parallels\AsyncPool.cs" />
@@ -178,11 +151,50 @@
     <Compile Include="Components\ExecutionState.cs" />
     <Compile Include="Components\RunnableComponent.cs" />
     <Compile Include="Components\IFactory.cs" />
-    <Compile Include="Parsing\DFADefinition.cs" />
-    <Compile Include="Parsing\IndexedAlphabetBase.cs" />
-    <Compile Include="Parsing\CharAlphabet.cs" />
-    <Compile Include="Parsing\IAlphabetBuilder.cs" />
-    <Compile Include="Parsing\IDFADefinitionBuilder.cs" />
+    <Compile Include="Automaton\IAlphabet.cs" />
+    <Compile Include="Automaton\ParserException.cs" />
+    <Compile Include="Automaton\IndexedAlphabetBase.cs" />
+    <Compile Include="Automaton\IAlphabetBuilder.cs" />
+    <Compile Include="Automaton\RegularExpressions\AltToken.cs" />
+    <Compile Include="Automaton\RegularExpressions\BinaryToken.cs" />
+    <Compile Include="Automaton\RegularExpressions\CatToken.cs" />
+    <Compile Include="Automaton\RegularExpressions\StarToken.cs" />
+    <Compile Include="Automaton\RegularExpressions\SymbolToken.cs" />
+    <Compile Include="Automaton\RegularExpressions\EmptyToken.cs" />
+    <Compile Include="Automaton\RegularExpressions\Token.cs" />
+    <Compile Include="Automaton\RegularExpressions\IVisitor.cs" />
+    <Compile Include="Automaton\AutomatonTransition.cs" />
+    <Compile Include="Formats\JSON\JSONElementContext.cs" />
+    <Compile Include="Formats\JSON\JSONElementType.cs" />
+    <Compile Include="Formats\JSON\JSONGrammar.cs" />
+    <Compile Include="Formats\JSON\JSONParser.cs" />
+    <Compile Include="Formats\JSON\JSONScanner.cs" />
+    <Compile Include="Formats\JSON\JsonTokenType.cs" />
+    <Compile Include="Formats\JSON\JSONWriter.cs" />
+    <Compile Include="Formats\JSON\JSONXmlReader.cs" />
+    <Compile Include="Formats\JSON\JSONXmlReaderOptions.cs" />
+    <Compile Include="Formats\JSON\StringTranslator.cs" />
+    <Compile Include="Automaton\MapAlphabet.cs" />
+    <Compile Include="Formats\CharAlphabet.cs" />
+    <Compile Include="Formats\ByteAlphabet.cs" />
+    <Compile Include="Automaton\IDFATable.cs" />
+    <Compile Include="Automaton\IDFATableBuilder.cs" />
+    <Compile Include="Automaton\DFATable.cs" />
+    <Compile Include="Automaton\RegularExpressions\RegularExpressionVisitor.cs" />
+    <Compile Include="Automaton\RegularExpressions\ITaggedDFABuilder.cs" />
+    <Compile Include="Formats\TextScanner.cs" />
+    <Compile Include="Formats\StringScanner.cs" />
+    <Compile Include="Formats\ReaderScanner.cs" />
+    <Compile Include="Formats\ScannerContext.cs" />
+    <Compile Include="Formats\Grammar.cs" />
+    <Compile Include="Automaton\RegularExpressions\EndTokenT.cs" />
+    <Compile Include="Automaton\RegularExpressions\EndToken.cs" />
+    <Compile Include="Automaton\RegularExpressions\RegularExpressionVisitorT.cs" />
+    <Compile Include="Automaton\AutomatonConst.cs" />
+    <Compile Include="Automaton\RegularExpressions\RegularDFA.cs" />
+    <Compile Include="Components\LazyAndWeak.cs" />
+    <Compile Include="AbstractTask.cs" />
+    <Compile Include="AbstractTaskT.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <ItemGroup />
@@ -257,5 +269,8 @@
   </ProjectExtensions>
   <ItemGroup>
     <Folder Include="Components\" />
+    <Folder Include="Automaton\RegularExpressions\" />
+    <Folder Include="Formats\" />
+    <Folder Include="Formats\JSON\" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/JSON/JSONElementContext.cs
--- a/Implab/JSON/JSONElementContext.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,17 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Implab.JSON {
-    /// <summary>
-    /// internal
-    /// </summary>
-    public enum JSONElementContext {
-        None,
-        Object,
-        Array,
-        Closed
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/JSON/JSONElementType.cs
--- a/Implab/JSON/JSONElementType.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,34 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Implab.JSON {
-    /// <summary>
-    /// Тип элемента на котором находится парсер
-    /// </summary>
-    public enum JSONElementType {
-        None,
-        /// <summary>
-        /// Начало объекта
-        /// </summary>
-        BeginObject,
-        /// <summary>
-        /// Конец объекта
-        /// </summary>
-        EndObject,
-        /// <summary>
-        /// Начало массива
-        /// </summary>
-        BeginArray,
-        /// <summary>
-        /// Конец массива
-        /// </summary>
-        EndArray,
-        /// <summary>
-        /// Простое значение
-        /// </summary>
-        Value
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/JSON/JSONGrammar.cs
--- a/Implab/JSON/JSONGrammar.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,99 +0,0 @@
-using Implab.Parsing;
-using System.Linq;
-
-namespace Implab.JSON {
-    class JSONGrammar : Grammar<JSONGrammar> {
-        public enum TokenType {
-            None,
-            BeginObject,
-            EndObject,
-            BeginArray,
-            EndArray,
-            String,
-            Number,
-            Literal,
-            NameSeparator,
-            ValueSeparator,
-
-            StringBound,
-            EscapedChar,
-            UnescapedChar,
-            EscapedUnicode,
-
-            Minus,
-            Plus,
-            Sign,
-            Integer,
-            Dot,
-            Exp
-        }
-
-        readonly CDFADefinition m_jsonDFA;
-        readonly CDFADefinition m_stringDFA;
-
-        public JSONGrammar() {
-            DefineAlphabet(Enumerable.Range(0, 0x20).Select(x => (char)x));
-            var hexDigit = SymbolRangeToken('a','f').Or(SymbolRangeToken('A','F')).Or(SymbolRangeToken('0','9'));
-            var digit9 = SymbolRangeToken('1', '9');
-            var zero = SymbolToken('0');
-            var digit = zero.Or(digit9);
-            var dot = SymbolToken('.');
-            var minus = SymbolToken('-');
-            var sign = SymbolSetToken('-', '+');
-            var expSign = SymbolSetToken('e', 'E');
-            var letters = SymbolRangeToken('a', 'z');
-            var integer = zero.Or(digit9.Cat(digit.EClosure()));
-            var frac = dot.Cat(digit.Closure());
-            var exp = expSign.Cat(sign.Optional()).Cat(digit.Closure());
-            var quote = SymbolToken('"');
-            var backSlash = SymbolToken('\\');
-            var specialEscapeChars = SymbolSetToken('\\', '"', '/', 'b', 'f', 't', 'n', 'r');
-            var unicodeEspace = SymbolToken('u').Cat(hexDigit.Repeat(4));
-            var whitespace = SymbolSetToken('\n', '\r', '\t', ' ').EClosure();
-            var beginObject = whitespace.Cat(SymbolToken('{')).Cat(whitespace);
-            var endObject = whitespace.Cat(SymbolToken('}')).Cat(whitespace);
-            var beginArray = whitespace.Cat(SymbolToken('[')).Cat(whitespace);
-            var endArray = whitespace.Cat(SymbolToken(']')).Cat(whitespace);
-            var nameSep = whitespace.Cat(SymbolToken(':')).Cat(whitespace);
-            var valueSep = whitespace.Cat(SymbolToken(',')).Cat(whitespace);
-            
-            var number = minus.Optional().Cat(integer).Cat(frac.Optional()).Cat(exp.Optional());
-            var literal = letters.Closure();
-            var unescaped = SymbolTokenExcept(Enumerable.Range(0, 0x20).Union(new int[] { '\\', '"' }).Select(x => (char)x));
-
-            var jsonExpression =
-                number.Tag(TokenType.Number)
-                .Or(literal.Tag(TokenType.Literal))
-                .Or(quote.Tag(TokenType.StringBound))
-                .Or(beginObject.Tag(TokenType.BeginObject))
-                .Or(endObject.Tag(TokenType.EndObject))
-                .Or(beginArray.Tag(TokenType.BeginArray))
-                .Or(endArray.Tag(TokenType.EndArray))
-                .Or(nameSep.Tag(TokenType.NameSeparator))
-                .Or(valueSep.Tag(TokenType.ValueSeparator));
-
-
-            var jsonStringExpression =
-                quote.Tag(TokenType.StringBound)
-                .Or(backSlash.Cat(specialEscapeChars).Tag(TokenType.EscapedChar))
-                .Or(backSlash.Cat(unicodeEspace).Tag(TokenType.EscapedUnicode))
-                .Or(unescaped.Closure().Tag(TokenType.UnescapedChar));
-                    
-
-            m_jsonDFA = BuildDFA(jsonExpression);
-            m_stringDFA = BuildDFA(jsonStringExpression);
-        }
-
-        public CDFADefinition JsonDFA {
-            get {
-                return m_jsonDFA;
-            }
-        }
-
-        public CDFADefinition JsonStringDFA {
-            get {
-                return m_stringDFA;
-            }
-        }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/JSON/JSONParser.cs
--- a/Implab/JSON/JSONParser.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,277 +0,0 @@
-using Implab.Parsing;
-using System;
-using System.Diagnostics;
-using System.IO;
-
-namespace Implab.JSON {
-    /// <summary>
-    /// internal
-    /// </summary>
-    public struct JSONParserContext {
-        public string memberName;
-        public JSONElementContext elementContext;
-    }
-
-    /// <summary>
-    /// Pull парсер JSON данных.
-    /// </summary>
-    /// <remarks>
-    /// Следует отметить отдельную интерпретацию свойства <see cref="Level"/>,
-    /// оно означает текущий уровень вложенности объектов, однако закрывающий
-    /// элемент объекта и массива имеет уровень меньше, чем сам объект.
-    /// <code>
-    /// { // Level = 1
-    ///     "name" : "Peter", // Level = 1
-    ///     "address" : { // Level = 2
-    ///         city : "Stern" // Level = 2
-    ///     } // Level = 1
-    /// } // Level = 0
-    /// </code>
-    /// </remarks>
-    public class JSONParser : DFAutomaton<JSONParserContext>, IDisposable {
-
-        enum MemberContext {
-            MemberName,
-            MemberValue
-        }
-
-        static readonly EnumAlphabet<JsonTokenType> _alphabet = EnumAlphabet<JsonTokenType>.FullAlphabet;
-        static readonly DFAStateDescriptior[] _jsonDFA;
-        static readonly DFAStateDescriptior[] _objectDFA;
-        static readonly DFAStateDescriptior[] _arrayDFA;
-
-        static JSONParser() {
-
-
-            var valueExpression = Token.New(JsonTokenType.BeginArray, JsonTokenType.BeginObject, JsonTokenType.Literal, JsonTokenType.Number, JsonTokenType.String);
-            var memberExpression = Token.New(JsonTokenType.String).Cat(Token.New(JsonTokenType.NameSeparator)).Cat(valueExpression);
-
-            var objectExpression = memberExpression
-                .Cat(
-                    Token.New(JsonTokenType.ValueSeparator)
-                    .Cat(memberExpression)
-                    .EClosure()
-                )
-                .Optional()
-                .Cat(Token.New(JsonTokenType.EndObject))
-                .Tag(0);
-            var arrayExpression = valueExpression
-                .Cat(
-                    Token.New(JsonTokenType.ValueSeparator)
-                    .Cat(valueExpression)
-                    .EClosure()
-                )
-                .Optional()
-                .Cat(Token.New(JsonTokenType.EndArray))
-                .Tag(0);
-
-            var jsonExpression = valueExpression.Tag(0);
-
-            _jsonDFA = BuildDFA(jsonExpression).States;
-            _objectDFA = BuildDFA(objectExpression).States;
-            _arrayDFA = BuildDFA(arrayExpression).States;
-        }
-
-        static EDFADefinition<JsonTokenType> BuildDFA(Token expr) {
-            var builder = new DFABuilder();
-            var dfa = new EDFADefinition<JsonTokenType>(_alphabet);
-            expr.Accept(builder);
-
-            builder.BuildDFA(dfa);
-            return dfa;
-        }
-
-        JSONScanner m_scanner;
-        MemberContext m_memberContext;
-
-        JSONElementType m_elementType;
-        object m_elementValue;
-
-        /// <summary>
-        /// Создает новый парсер на основе строки, содержащей JSON
-        /// </summary>
-        /// <param name="text"></param>
-        public JSONParser(string text)
-            : base(_jsonDFA, INITIAL_STATE, new JSONParserContext { elementContext = JSONElementContext.None, memberName = String.Empty }) {
-            Safe.ArgumentNotEmpty(text, "text");
-            m_scanner = new JSONScanner();
-            m_scanner.Feed(text.ToCharArray());
-        }
-
-        /// <summary>
-        /// Создает новый экземпляр парсера, на основе текстового потока.
-        /// </summary>
-        /// <param name="reader">Текстовый поток.</param>
-        /// <param name="dispose">Признак того, что парсер должен конролировать время жизни входного потока.</param>
-        public JSONParser(TextReader reader, bool dispose)
-            : base(_jsonDFA, INITIAL_STATE, new JSONParserContext { elementContext = JSONElementContext.None, memberName = String.Empty }) {
-            Safe.ArgumentNotNull(reader, "reader");
-            m_scanner = new JSONScanner();
-            m_scanner.Feed(reader, dispose);
-        }
-
-        /// <summary>
-        /// Тип текущего элемента на котором стоит парсер.
-        /// </summary>
-        public JSONElementType ElementType {
-            get { return m_elementType; }
-        }
-
-        /// <summary>
-        /// Имя элемента - имя свойства родительского контейнера. Для элементов массивов и корневого всегда
-        /// пустая строка.
-        /// </summary>
-        public string ElementName {
-            get { return m_context.info.memberName; }
-        }
-
-        /// <summary>
-        /// Значение элемента. Только для элементов типа <see cref="JSONElementType.Value"/>, для остальных <c>null</c>
-        /// </summary>
-        public object ElementValue {
-            get { return m_elementValue; }
-        }
-
-        /// <summary>
-        /// Читает слеюудущий объект из потока
-        /// </summary>
-        /// <returns><c>true</c> - операция чтения прошла успешно, <c>false</c> - конец данных</returns>
-        public bool Read() {
-            if (m_context.current == UNREACHEBLE_STATE)
-                throw new InvalidOperationException("The parser is in invalid state");
-            object tokenValue;
-            JsonTokenType tokenType;
-            m_context.info.memberName = String.Empty;
-            while (m_scanner.ReadToken(out tokenValue, out tokenType)) {
-                Move((int)tokenType);
-                if (m_context.current == UNREACHEBLE_STATE)
-                    UnexpectedToken(tokenValue, tokenType);
-                switch (tokenType) {
-                    case JsonTokenType.BeginObject:
-                        Switch(
-                            _objectDFA,
-                            INITIAL_STATE,
-                            new JSONParserContext {
-                                memberName = m_context.info.memberName,
-                                elementContext = JSONElementContext.Object
-                            }
-                        );
-                        m_elementValue = null;
-                        m_memberContext = MemberContext.MemberName;
-                        m_elementType = JSONElementType.BeginObject;
-                        return true;
-                    case JsonTokenType.EndObject:
-                        Restore();
-                        m_elementValue = null;
-                        m_elementType = JSONElementType.EndObject;
-                        return true;
-                    case JsonTokenType.BeginArray:
-                        Switch(
-                            _arrayDFA,
-                            INITIAL_STATE,
-                            new JSONParserContext {
-                                memberName = m_context.info.memberName,
-                                elementContext = JSONElementContext.Array
-                            }
-                        );
-                        m_elementValue = null;
-                        m_memberContext = MemberContext.MemberValue;
-                        m_elementType = JSONElementType.BeginArray;
-                        return true;
-                    case JsonTokenType.EndArray:
-                        Restore();
-                        m_elementValue = null;
-                        m_elementType = JSONElementType.EndArray;
-                        return true;
-                    case JsonTokenType.String:
-                        if (m_memberContext == MemberContext.MemberName) {
-                            m_context.info.memberName = (string)tokenValue;
-                            break;
-                        }
-                        m_elementType = JSONElementType.Value;
-                        m_elementValue = tokenValue;
-                        return true;
-                    case JsonTokenType.Number:
-                        m_elementType = JSONElementType.Value;
-                        m_elementValue = tokenValue;
-                        return true;
-                    case JsonTokenType.Literal:
-                        m_elementType = JSONElementType.Value;
-                        m_elementValue = ParseLiteral((string)tokenValue);
-                        return true;
-                    case JsonTokenType.NameSeparator:
-                        m_memberContext = MemberContext.MemberValue;
-                        break;
-                    case JsonTokenType.ValueSeparator:
-                        m_memberContext = m_context.info.elementContext == JSONElementContext.Object ? MemberContext.MemberName : MemberContext.MemberValue;
-                        break;
-                    default:
-                        UnexpectedToken(tokenValue, tokenType);
-                        break;
-                }
-            }
-            if (m_context.info.elementContext != JSONElementContext.None)
-                throw new ParserException("Unexpedted end of data");
-            return false;
-        }
-
-        object ParseLiteral(string literal) {
-            switch (literal) {
-                case "null":
-                    return null;
-                case "false":
-                    return false;
-                case "true":
-                    return true;
-                default:
-                    UnexpectedToken(literal, JsonTokenType.Literal);
-                    return null; // avoid compliler error
-            }
-        }
-
-        void UnexpectedToken(object value, JsonTokenType tokenType) {
-            throw new ParserException(String.Format("Unexpected token {0}: '{1}'", tokenType, value));
-        }
-
-
-        /// <summary>
-        /// Признак конца потока
-        /// </summary>
-        public bool EOF {
-            get {
-                return m_scanner.EOF;
-            }
-        }
-
-        protected virtual void Dispose(bool disposing) {
-            if (disposing) {
-                m_scanner.Dispose();
-            }
-        }
-
-        /// <summary>
-        /// Освобождает парсер и связанный с ним сканнер.
-        /// </summary>
-        public void Dispose() {
-            Dispose(true);
-            GC.SuppressFinalize(this);
-        }
-
-        ~JSONParser() {
-            Dispose(false);
-        }
-
-        /// <summary>
-        /// Переходит в конец текущего объекта.
-        /// </summary>
-        public void SeekElementEnd() {
-            var level = Level - 1;
-
-            Debug.Assert(level >= 0);
-
-            while (Level != level)
-                Read();
-        }
-    }
-
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/JSON/JSONScanner.cs
--- a/Implab/JSON/JSONScanner.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,100 +0,0 @@
-using Implab.Parsing;
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Implab.JSON {
-    /// <summary>
-    /// Сканнер (лексер), разбивающий поток символов на токены JSON.
-    /// </summary>
-    public class JSONScanner : Scanner {
-        char[] m_stringBuffer;
-        DFAStateDescriptior[] m_stringDFA;
-        int[] m_stringAlphabet;
-
-        /// <summary>
-        /// Создает новый экземпляр сканнера
-        /// </summary>
-        public JSONScanner()
-            : base(JSONGrammar.Instance.JsonDFA.States, JSONGrammar.Instance.JsonDFA.Alphabet.GetTranslationMap()) {
-            m_stringBuffer = new char[1024];
-            var dfa = JSONGrammar.Instance.JsonStringDFA;
-            m_stringAlphabet = dfa.Alphabet.GetTranslationMap();
-            m_stringDFA = dfa.States;
-        }
-
-        /// <summary>
-        /// Читает следующий лексический элемент из входных данных.
-        /// </summary>
-        /// <param name="tokenValue">Возвращает значение прочитанного токена.</param>
-        /// <param name="tokenType">Возвращает тип прочитанного токена.</param>
-        /// <returns><c>true</c> - чтение произведено успешно. <c>false</c> - достигнут конец входных данных</returns>
-        /// <remarks>В случе если токен не распознается, возникает исключение. Значения токенов обрабатываются, т.е.
-        /// в строках обрабатываются экранированные символы, числа становтся типа double.</remarks>
-        public bool ReadToken(out object tokenValue, out JsonTokenType tokenType) {
-            if (ReadTokenInternal()) {
-                switch ((JSONGrammar.TokenType)m_currentState.tag[0]) {
-                    case JSONGrammar.TokenType.StringBound:
-                        tokenValue = ReadString();
-                        tokenType = JsonTokenType.String;
-                        break;
-                    case JSONGrammar.TokenType.Number:
-                        tokenValue = Double.Parse(new String(m_buffer, m_tokenOffset, m_tokenLen), CultureInfo.InvariantCulture);
-                        tokenType = JsonTokenType.Number;
-                        break;
-                    default:
-                        tokenType = (JsonTokenType)m_currentState.tag[0];
-                        tokenValue = new String(m_buffer, m_tokenOffset, m_tokenLen);
-                        break;
-                }
-                return true;
-            }
-            tokenValue = null;
-            tokenType = JsonTokenType.None;
-            return false;
-        }
-
-        string ReadString() {
-            int pos = 0;
-            Switch(m_stringDFA, m_stringAlphabet);
-            while (ReadTokenInternal()) {
-                switch ((JSONGrammar.TokenType)m_currentState.tag[0]) {
-                    case JSONGrammar.TokenType.StringBound:
-                        Restore();
-                        return new String(m_stringBuffer, 0, pos);
-                    case JSONGrammar.TokenType.UnescapedChar:
-                        EnsureStringBufferSize(pos + m_tokenLen);
-                        Array.Copy(m_buffer, m_tokenOffset, m_stringBuffer, pos, m_tokenLen);
-                        pos += m_tokenLen;
-                        break;
-                    case JSONGrammar.TokenType.EscapedUnicode:
-                        EnsureStringBufferSize(pos + 1);
-                        m_stringBuffer[pos] = StringTranslator.TranslateHexUnicode(m_buffer, m_tokenOffset + 2);
-                        pos++;
-                        break;
-                    case JSONGrammar.TokenType.EscapedChar:
-                        EnsureStringBufferSize(pos + 1);
-                        m_stringBuffer[pos] = StringTranslator.TranslateEscapedChar(m_buffer[m_tokenOffset + 1]);
-                        pos++;
-                        break;
-                    default:
-                        break;
-                }
-
-            }
-
-            throw new ParserException("Unexpected end of data");
-        }
-
-        void EnsureStringBufferSize(int size) {
-            if (size > m_stringBuffer.Length) {
-                var newBuffer = new char[size];
-                m_stringBuffer.CopyTo(newBuffer, 0);
-                m_stringBuffer = newBuffer;
-            }
-        }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/JSON/JSONWriter.cs
--- a/Implab/JSON/JSONWriter.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,319 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Globalization;
-using System.Diagnostics;
-
-namespace Implab.JSON {
-    public class JSONWriter {
-        struct Context {
-            public bool needComma;
-            public JSONElementContext element;
-        }
-        Stack<Context> m_contextStack = new Stack<Context>();
-        Context m_context;
-
-        const int BUFFER_SIZE = 64;
-
-        TextWriter m_writer;
-        readonly bool m_indent = true;
-        readonly int m_indentSize = 4;
-        readonly char[] m_buffer = new char[BUFFER_SIZE];
-        int m_bufferPos;
-
-        static readonly char [] _hex = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
-        static readonly char [] _escapeBKS,
-            _escapeFWD,
-            _escapeCR,
-            _escapeNL,
-            _escapeTAB,
-            _escapeBSLASH,
-            _escapeQ;
-
-        static JSONWriter() {
-            _escapeBKS = "\\b".ToCharArray();
-            _escapeFWD = "\\f".ToCharArray();
-            _escapeCR = "\\r".ToCharArray();
-            _escapeNL = "\\n".ToCharArray();
-            _escapeTAB = "\\t".ToCharArray();
-            _escapeBSLASH = "\\\\".ToCharArray();
-            _escapeQ = "\\\"".ToCharArray();
-        }
-
-        public JSONWriter(TextWriter writer) {
-            Safe.ArgumentNotNull(writer, "writer");
-            m_writer = writer;
-        }
-
-        public JSONWriter(TextWriter writer, bool indent) {
-            Safe.ArgumentNotNull(writer, "writer");
-
-            m_writer = writer;
-            m_indent = indent;
-        }
-
-        void WriteIndent() {
-            if (m_indent) {
-                var indent = new char[m_contextStack.Count * m_indentSize + 1];
-                indent[0] = '\n';
-                for (int i = 1; i < indent.Length; i++)
-                    indent[i] = ' ';
-                m_writer.Write(new String(indent));
-            } else {
-                m_writer.Write(' ');
-            }
-        }
-
-        void WriteMemberName(string name) {
-            Safe.ArgumentNotEmpty(name, "name");
-            if (m_context.element != JSONElementContext.Object)
-                OperationNotApplicable("WriteMember");
-            if (m_context.needComma)
-                m_writer.Write(",");
-
-            WriteIndent();
-            m_context.needComma = true;
-            Write(name);
-            m_writer.Write(" : ");
-        }
-
-        public void WriteValue(string name, string value) {
-            WriteMemberName(name);
-            Write(value);            
-        }
-
-        public void WriteValue(string name, bool value) {
-            WriteMemberName(name);
-            Write(value);
-        }
-
-        public void WriteValue(string name, double value) {
-            WriteMemberName(name);
-            Write(value);
-        }
-
-        public void WriteValue(string value) {
-            if (m_context.element == JSONElementContext.Array) {
-
-                if (m_context.needComma)
-                    m_writer.Write(",");
-                WriteIndent();
-                m_context.needComma = true;
-
-                Write(value);
-            } else if (m_context.element == JSONElementContext.None) {
-                Write(value);
-                m_context.element = JSONElementContext.Closed;
-            } else {
-                OperationNotApplicable("WriteValue");
-            }
-        }
-
-        public void WriteValue(bool value) {
-            if (m_context.element == JSONElementContext.Array) {
-
-                if (m_context.needComma)
-                    m_writer.Write(",");
-                WriteIndent();
-                m_context.needComma = true;
-
-                Write(value);
-            } else if (m_context.element == JSONElementContext.None) {
-                Write(value);
-                m_context.element = JSONElementContext.Closed;
-            } else {
-                OperationNotApplicable("WriteValue");
-            }
-        }
-
-        public void WriteValue(double value) {
-            if (m_context.element == JSONElementContext.Array) {
-
-                if (m_context.needComma)
-                    m_writer.Write(",");
-                WriteIndent();
-                m_context.needComma = true;
-
-                Write(value);
-            } else if (m_context.element == JSONElementContext.None) {
-                Write(value);
-                m_context.element = JSONElementContext.Closed;
-            } else {
-                OperationNotApplicable("WriteValue");
-            }
-        }
-        
-        public void BeginObject() {
-            if (m_context.element != JSONElementContext.None && m_context.element != JSONElementContext.Array)
-                OperationNotApplicable("BeginObject");
-            if (m_context.needComma)
-                m_writer.Write(",");
-
-            WriteIndent();
-
-            m_context.needComma = true;
-
-            m_contextStack.Push(m_context);
-
-            m_context = new Context { element = JSONElementContext.Object, needComma = false };
-            m_writer.Write("{");
-        }
-
-        public void BeginObject(string name) {
-            WriteMemberName(name);
-
-            m_contextStack.Push(m_context);
-
-            m_context = new Context { element = JSONElementContext.Object, needComma = false };
-            m_writer.Write("{");
-        }
-
-        public void EndObject() {
-            if (m_context.element != JSONElementContext.Object)
-                OperationNotApplicable("EndObject");
-
-            m_context = m_contextStack.Pop();
-            if (m_contextStack.Count == 0)
-                m_context.element = JSONElementContext.Closed;
-            WriteIndent();
-            m_writer.Write("}");
-        }
-
-        public void BeginArray() {
-            if (m_context.element != JSONElementContext.None && m_context.element != JSONElementContext.Array)
-                throw new InvalidOperationException();
-            if (m_context.needComma) {
-                m_writer.Write(",");
-
-            }
-            m_context.needComma = true;
-
-            WriteIndent();
-            m_contextStack.Push(m_context);
-            m_context = new Context { element = JSONElementContext.Array, needComma = false };
-            m_writer.Write("[");
-        }
-
-        public void BeginArray(string name) {
-            WriteMemberName(name);
-
-            m_contextStack.Push(m_context);
-
-            m_context = new Context { element = JSONElementContext.Array, needComma = false };
-            m_writer.Write("[");
-        }
-
-        public void EndArray() {
-            if (m_context.element != JSONElementContext.Array)
-                OperationNotApplicable("EndArray");
-
-            m_context = m_contextStack.Pop();
-            if (m_contextStack.Count == 0)
-                m_context.element = JSONElementContext.Closed;
-            WriteIndent();
-            m_writer.Write("]");
-        }
-
-        void Write(bool value) {
-            m_writer.Write(value ? "true" : "false");
-        }
-
-        void FlushBuffer() {
-            if (m_bufferPos > 0) {
-                m_writer.Write(m_buffer, 0, m_bufferPos);
-                m_bufferPos = 0;
-            }
-        }
-
-        void Write(string value) {
-            if (value == null) {
-                m_writer.Write("null");
-                return;
-            }
-
-            Debug.Assert(m_bufferPos == 0);
-
-            var chars = value.ToCharArray();
-            m_buffer[m_bufferPos++] = '"';
-
-            // Analysis disable once ForCanBeConvertedToForeach
-            for (int i = 0; i < chars.Length; i++) {
-                var ch = chars[i];
-
-                char[] escapeSeq;
-
-                switch (ch) {
-                    case '\b':
-                        escapeSeq = _escapeBKS;
-                        break;
-                    case '\f':
-                        escapeSeq = _escapeFWD;
-                        break;
-                    case '\r':
-                        escapeSeq = _escapeCR;
-                        break;
-                    case '\n':
-                        escapeSeq = _escapeNL;
-                        break;
-                    case '\t':
-                        escapeSeq = _escapeTAB;
-                        break;
-                    case '\\':
-                        escapeSeq = _escapeBSLASH;
-                        break;
-                    case '"':
-                        escapeSeq = _escapeQ;
-                        break;
-                    default:
-                        if (ch < 0x20) {
-                            if (m_bufferPos + 6 > BUFFER_SIZE)
-                                FlushBuffer();
-
-                            m_buffer[m_bufferPos++] = '\\';
-                            m_buffer[m_bufferPos++] = 'u';
-                            m_buffer[m_bufferPos++] = '0';
-                            m_buffer[m_bufferPos++] = '0';
-                            m_buffer[m_bufferPos++] = _hex[ch >> 4 & 0xf];
-                            m_buffer[m_bufferPos++] = _hex[ch & 0xf];
-
-                        } else {
-                            if (m_bufferPos >= BUFFER_SIZE)
-                                FlushBuffer();
-                            m_buffer[m_bufferPos++] = ch;
-                        }
-                        continue;
-                }
-
-                if (m_bufferPos + escapeSeq.Length > BUFFER_SIZE)
-                    FlushBuffer();
-
-                Array.Copy(escapeSeq, 0, m_buffer, m_bufferPos, escapeSeq.Length);
-                m_bufferPos += escapeSeq.Length;
-
-            }
-
-            if (m_bufferPos >= BUFFER_SIZE)
-                FlushBuffer();
-            
-            m_buffer[m_bufferPos++] = '"';
-
-            FlushBuffer();
-        }
-
-        void Write(double value) {
-            if (double.IsNaN(value))
-                Write("NaN");
-            else if (double.IsNegativeInfinity(value))
-                Write("-Infinity");
-            else if (double.IsPositiveInfinity(value))
-                Write("Infinity");
-            else
-                m_writer.Write(value.ToString(CultureInfo.InvariantCulture));
-        }
-
-        void OperationNotApplicable(string opName) {
-            throw new InvalidOperationException(String.Format("The operation '{0}' isn't applicable in the context of '{1}'", opName, m_context.element ));
-        }
-        
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/JSON/JSONXmlReader.cs
--- a/Implab/JSON/JSONXmlReader.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,343 +0,0 @@
-using Implab;
-using Implab.Parsing;
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Xml;
-
-namespace Implab.JSON {
-    public class JSONXmlReader : XmlReader {
-
-        enum ValueContext {
-            Undefined,
-            ElementStart,
-            ElementValue,
-            ElementEnd,
-            ElementEmpty
-        }
-
-        struct LocalNameContext {
-            public string localName;
-            public bool isArray;
-        }
-
-        JSONParser m_parser;
-        ValueContext m_valueContext;
-        ReadState m_state = ReadState.Initial;
-        Stack<LocalNameContext> m_localNameStack = new Stack<LocalNameContext>();
-        LocalNameContext m_localName;
-        int m_depthCorrection = 0;
-
-        readonly string m_rootName;
-        readonly string m_prefix;
-        readonly string m_namespaceUri;
-        readonly bool m_flattenArrays;
-        readonly string m_arrayItemName;
-        readonly XmlNameTable m_nameTable;
-
-        JSONXmlReader(JSONParser parser, JSONXmlReaderOptions options) {
-            m_parser = parser;
-
-            if (options != null) {
-                m_prefix = options.NodesPrefix ?? String.Empty;
-                m_namespaceUri = options.NamespaceURI ?? String.Empty;
-                m_rootName = options.RootName ?? "json";
-                m_flattenArrays = options.FlattenArrays;
-                m_arrayItemName = options.ArrayItemName ?? "item";
-                m_nameTable = options.NameTable ?? new NameTable();
-            } else {
-                m_prefix = String.Empty;
-                m_namespaceUri = String.Empty;
-                m_rootName = "json";
-                m_flattenArrays = false;
-                m_arrayItemName = "item";
-                m_nameTable = new NameTable();
-            }
-        }
-
-        /// <summary>
-        /// Always 0, JSON doesn't support attributes
-        /// </summary>
-        public override int AttributeCount {
-            get { return 0; }
-        }
-
-        public override string BaseURI {
-            get { return String.Empty; }
-        }
-
-        public override int Depth {
-            get {
-                return m_localNameStack.Count + m_depthCorrection;
-            }
-        }
-
-        public override bool EOF {
-            get { return m_parser.EOF; }
-        }
-
-        /// <summary>
-        /// Always throws an exception
-        /// </summary>
-        /// <param name="i"></param>
-        /// <returns></returns>
-        public override string GetAttribute(int i) {
-            throw new ArgumentOutOfRangeException();
-        }
-
-        /// <summary>
-        /// Always returns empty string
-        /// </summary>
-        /// <param name="name"></param>
-        /// <param name="namespaceURI"></param>
-        /// <returns></returns>
-        public override string GetAttribute(string name, string namespaceURI) {
-            return String.Empty;
-        }
-
-        /// <summary>
-        /// Always returns empty string
-        /// </summary>
-        /// <param name="name"></param>
-        /// <returns></returns>
-        public override string GetAttribute(string name) {
-            return String.Empty;
-        }
-
-        public override bool IsEmptyElement {
-            get { return m_parser.ElementType == JSONElementType.Value && m_valueContext == ValueContext.ElementEmpty; }
-        }
-
-        public override string LocalName {
-            get { return m_localName.localName; }
-        }
-
-        public override string LookupNamespace(string prefix) {
-            if (String.IsNullOrEmpty(prefix) || prefix == m_prefix)
-                return m_namespaceUri;
-            else
-                return String.Empty;
-        }
-
-        public override bool MoveToAttribute(string name, string ns) {
-            return false;
-        }
-
-        public override bool MoveToAttribute(string name) {
-            return false;
-        }
-
-        public override bool MoveToElement() {
-            return false;
-        }
-
-        public override bool MoveToFirstAttribute() {
-            return false;
-        }
-
-        public override bool MoveToNextAttribute() {
-            return false;
-        }
-
-        public override XmlNameTable NameTable {
-            get { return m_nameTable; }
-        }
-
-        public override string NamespaceURI {
-            get { return m_namespaceUri; }
-        }
-
-        public override XmlNodeType NodeType {
-            get {
-                switch (m_parser.ElementType) {
-                    case JSONElementType.BeginObject:
-                    case JSONElementType.BeginArray:
-                        return XmlNodeType.Element;
-                    case JSONElementType.EndObject:
-                    case JSONElementType.EndArray:
-                        return XmlNodeType.EndElement;
-                    case JSONElementType.Value:
-                        switch (m_valueContext) {
-                            case ValueContext.ElementStart:
-                            case ValueContext.ElementEmpty:
-                                return XmlNodeType.Element;
-                            case ValueContext.ElementValue:
-                                return XmlNodeType.Text;
-                            case ValueContext.ElementEnd:
-                                return XmlNodeType.EndElement;
-                            default:
-                                throw new InvalidOperationException();
-                        }
-                    default:
-                        throw new InvalidOperationException();
-                }
-            }
-        }
-
-        public override string Prefix {
-            get { return m_prefix; }
-        }
-
-        public override bool Read() {
-            if (m_state != System.Xml.ReadState.Interactive && m_state != System.Xml.ReadState.Initial)
-                return false;
-
-            if (m_state == ReadState.Initial)
-                m_state = System.Xml.ReadState.Interactive;
-
-            try {
-                switch (m_parser.ElementType) {
-                    case JSONElementType.Value:
-                        switch (m_valueContext) {
-                            case ValueContext.ElementStart:
-                                SetLocalName(String.Empty);
-                                m_valueContext = ValueContext.ElementValue;
-                                return true;
-                            case ValueContext.ElementValue:
-                                RestoreLocalName();
-                                m_valueContext = ValueContext.ElementEnd;
-                                return true;
-                            case ValueContext.ElementEmpty:
-                            case ValueContext.ElementEnd:
-                                RestoreLocalName();
-                                break;
-                        }
-                        break;
-                    case JSONElementType.EndArray:
-                    case JSONElementType.EndObject:
-                        RestoreLocalName();
-                        break;
-                }
-                string itemName = m_parser.ElementType == JSONElementType.None ? m_rootName : m_flattenArrays ? m_localName.localName : m_arrayItemName;
-                while (m_parser.Read()) {
-                    if (!String.IsNullOrEmpty(m_parser.ElementName))
-                        itemName = m_parser.ElementName;
-
-                    switch (m_parser.ElementType) {
-                        case JSONElementType.BeginArray:
-                            if (m_flattenArrays && !m_localName.isArray) {
-                                m_depthCorrection--;
-                                SetLocalName(itemName, true);
-                                continue;
-                            } else {
-                                SetLocalName(itemName, true);
-                            }
-                            break;
-                        case JSONElementType.BeginObject:
-                            SetLocalName(itemName);
-                            break;
-                        case JSONElementType.EndArray:
-                            if (m_flattenArrays && !m_localNameStack.Peek().isArray) {
-                                RestoreLocalName();
-                                m_depthCorrection++;
-                                continue;
-                            }
-                            break;
-                        case JSONElementType.EndObject:
-                            break;
-                        case JSONElementType.Value:
-                            SetLocalName(itemName);
-                            m_valueContext = m_parser.ElementValue == null ? ValueContext.ElementEmpty : ValueContext.ElementStart;
-                            break;
-                        default:
-                            break;
-                    }
-                    return true;
-                }
-
-                m_state = System.Xml.ReadState.EndOfFile;
-                return false;
-            } catch {
-                m_state = System.Xml.ReadState.Error;
-                throw;
-            }
-        }
-
-        public override bool ReadAttributeValue() {
-            return false;
-        }
-
-        public override ReadState ReadState {
-            get { return m_state; }
-        }
-
-        public override void ResolveEntity() {
-            // do nothing
-        }
-
-        public override string Value {
-            get {
-                if (m_parser.ElementValue == null)
-                    return String.Empty;
-                if (Convert.GetTypeCode(m_parser.ElementValue) == TypeCode.Double)
-                    return ((double)m_parser.ElementValue).ToString(CultureInfo.InvariantCulture);
-                else
-                    return m_parser.ElementValue.ToString();
-            }
-        }
-
-        void SetLocalName(string name) {
-            m_localNameStack.Push(m_localName);
-            m_localName.localName = name;
-            m_localName.isArray = false;
-        }
-
-        void SetLocalName(string name, bool isArray) {
-            m_localNameStack.Push(m_localName);
-            m_localName.localName = name;
-            m_localName.isArray = isArray;
-        }
-
-        void RestoreLocalName() {
-            m_localName = m_localNameStack.Pop();
-        }
-
-        public override void Close() {
-
-        }
-
-        protected override void Dispose(bool disposing) {
-            #if MONO
-            disposing = true;
-            #endif
-            if (disposing) {
-                m_parser.Dispose();
-            }
-            base.Dispose(disposing);
-        }
-
-        public static JSONXmlReader Create(string file, JSONXmlReaderOptions options) {
-            return Create(File.OpenText(file), options);
-        }
-
-        /// <summary>
-        /// Creates the XmlReader for the specified text stream with JSON data.
-        /// </summary>
-        /// <param name="reader">Text reader.</param>
-        /// <param name="options">Options.</param>
-        /// <remarks>
-        /// The reader will be disposed when the XmlReader is disposed.
-        /// </remarks>
-        public static JSONXmlReader Create(TextReader reader,  JSONXmlReaderOptions options) {
-            return new JSONXmlReader(new JSONParser(reader, true), options);
-        }
-
-        /// <summary>
-        /// Creates the XmlReader for the specified stream with JSON data.
-        /// </summary>
-        /// <param name="stream">Stream.</param>
-        /// <param name="options">Options.</param>
-        /// <remarks>
-        /// The stream will be disposed when the XmlReader is disposed.
-        /// </remarks>
-        public static JSONXmlReader Create(Stream stream,  JSONXmlReaderOptions options) {
-            Safe.ArgumentNotNull(stream, "stream");
-            // HACK don't dispose StreaReader to keep stream opened
-            return Create(new StreamReader(stream), options);
-        }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/JSON/JSONXmlReaderOptions.cs
--- a/Implab/JSON/JSONXmlReaderOptions.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,65 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Xml;
-
-namespace Implab.JSON {
-    /// <summary>
-    /// Набор необязательных параметров для <see cref="JSONXmlReader"/>, позволяющий управлять процессом
-    /// интерпретации <c>JSON</c> документа.
-    /// </summary>
-    public class JSONXmlReaderOptions {
-        /// <summary>
-        /// Пространство имен в котором будут располагаться читаемые элементы документа
-        /// </summary>
-        public string NamespaceURI {
-            get;
-            set;
-        }
-
-        /// <summary>
-        /// Интерпретировать массивы как множественные элементы (убирает один уровень вложенности), иначе массив
-        /// представляется в виде узла, дочерними элементами которого являются элементы массива, имена дочерних элементов
-        /// определяются свойством <see cref="ArrayItemName"/>. По умолчанию <c>false</c>.
-        /// </summary>
-        public bool FlattenArrays {
-            get;
-            set;
-        }
-
-        /// <summary>
-        /// Префикс, для узлов документа
-        /// </summary>
-        public string NodesPrefix {
-            get;
-            set;
-        }
-
-        /// <summary>
-        /// Имя корневого элемента в xml документе
-        /// </summary>
-        public string RootName {
-            get;
-            set;
-        }
-
-        /// <summary>
-        /// Имя элемента для массивов, если не включена опция <see cref="FlattenArrays"/>.
-        /// По умолчанию <c>item</c>.
-        /// </summary>
-        public string ArrayItemName {
-            get;
-            set;
-        }
-
-        /// <summary>
-        /// Таблица атомизированных строк для построения документа.
-        /// </summary>
-        public XmlNameTable NameTable {
-            get;
-            set;
-        }
-
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/JSON/JsonTokenType.cs
--- a/Implab/JSON/JsonTokenType.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,50 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Implab.JSON {
-    /// <summary>
-    /// Тип токенов, возвращаемых <see cref="JSONScanner"/>.
-    /// </summary>
-    public enum JsonTokenType : int {
-        None = 0,
-        /// <summary>
-        /// Начало объекта
-        /// </summary>
-        BeginObject,
-        /// <summary>
-        /// Конец объекта
-        /// </summary>
-        EndObject,
-        /// <summary>
-        /// Начало массива
-        /// </summary>
-        BeginArray,
-        /// <summary>
-        /// Конец массива
-        /// </summary>
-        EndArray,
-        /// <summary>
-        /// Строка
-        /// </summary>
-        String,
-        /// <summary>
-        /// Число
-        /// </summary>
-        Number,
-        /// <summary>
-        /// Литерал
-        /// </summary>
-        Literal,
-        /// <summary>
-        /// Разделитель имени <c>:</c>
-        /// </summary>
-        NameSeparator,
-        /// <summary>
-        /// Разделитель имени <c>,</c>
-        /// </summary>
-        ValueSeparator
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/JSON/StringTranslator.cs
--- a/Implab/JSON/StringTranslator.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,96 +0,0 @@
-using Implab;
-using Implab.Parsing;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Implab.JSON {
-    /// <summary>
-    /// Класс для преобразования экранированной строки JSON
-    /// </summary>
-    public class StringTranslator : Scanner {
-        static readonly char[] _escMap;
-        static readonly int[] _hexMap;
-
-        static StringTranslator() {
-            var chars = new char[] { 'b', 'f', 't', 'r', 'n', '\\', '/' };
-            var vals = new char[] { '\b', '\f', '\t', '\r', '\n', '\\', '/' };
-
-            _escMap = new char[chars.Max() + 1];
-
-            for (int i = 0; i < chars.Length; i++)
-                _escMap[chars[i]] = vals[i];
-
-            var hexs = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F' };
-            var ints = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 10, 11, 12, 13, 14, 15 };
-
-            _hexMap = new int[hexs.Max() + 1];
-
-            for (int i = 0; i < hexs.Length; i++)
-                _hexMap[hexs[i]] = ints[i];
-
-        }
-
-        public StringTranslator()
-            : base(JSONGrammar.Instance.JsonStringDFA.States, JSONGrammar.Instance.JsonStringDFA.Alphabet.GetTranslationMap()) {
-        }
-
-        public string Translate(string data) {
-            Safe.ArgumentNotNull(data, "data");
-            return Translate(data.ToCharArray());
-        }
-
-        public string Translate(char[] data) {
-            Safe.ArgumentNotNull(data, "data");
-            return Translate(data, data.Length);
-        }
-
-        public string Translate(char[] data, int length) {
-            Safe.ArgumentNotNull(data, "data");
-            Safe.ArgumentInRange(length, 0, data.Length, "length");
-
-            var translated = new char[length];
-
-            Feed(data,length);
-
-            int pos = 0;
-
-            while (ReadTokenInternal()) {
-                switch ((JSONGrammar.TokenType)TokenTags[0]) {
-                    case JSONGrammar.TokenType.UnescapedChar:
-                        Array.Copy(m_buffer,m_tokenOffset,translated,pos,m_tokenLen);
-                        pos += m_tokenLen;
-                        break;
-                    case JSONGrammar.TokenType.EscapedChar:
-                        translated[pos] = _escMap[m_buffer[m_tokenOffset + 1]];
-                        pos++;
-                        break;
-                    case JSONGrammar.TokenType.EscapedUnicode:
-                        translated[pos] = TranslateHexUnicode(m_buffer,m_tokenOffset + 2);
-                        pos++;
-                        break;
-                }
-            }
-
-            return new String(translated, 0, pos);
-        }
-
-        internal static char TranslateEscapedChar(char symbol) {
-            return _escMap[symbol];
-        }
-
-        internal static char TranslateHexUnicode(char[] symbols, int offset) {
-            Debug.Assert(symbols != null);
-            Debug.Assert(symbols.Length - offset >= 4);
-
-            int value = (_hexMap[symbols[offset]] << 12)
-                | (_hexMap[symbols[offset + 1]] << 8)
-                | (_hexMap[symbols[offset + 2]] << 4)
-                | (_hexMap[symbols[offset + 3]]);
-            return (char)value;
-        }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/AltToken.cs
--- a/Implab/Parsing/AltToken.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,17 +0,0 @@
-using System;
-
-namespace Implab.Parsing {
-    public class AltToken: BinaryToken {
-        public AltToken(Token left, Token right)
-            : base(left, right) {
-        }
-
-        public override void Accept(IVisitor visitor) {
-            Safe.ArgumentNotNull(visitor, "visitor");
-            visitor.Visit(this);
-        }
-        public override string ToString() {
-            return String.Format(Right is BinaryToken ? "{0}|({1})" : "{0}|{1}", Left, Right);
-        }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/BinaryToken.cs
--- a/Implab/Parsing/BinaryToken.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,26 +0,0 @@
-using Implab;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Implab.Parsing {
-    public abstract class BinaryToken : Token {
-        Token m_left;
-        Token m_right;
-
-        public Token Left {
-            get { return m_left; }
-        }
-
-        public Token Right {
-            get { return m_right; }
-        }
-
-        protected BinaryToken(Token left, Token right) {
-            Safe.ArgumentNotNull(m_left = left, "left");
-            Safe.ArgumentNotNull(m_right = right, "right");
-        }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/CDFADefinition.cs
--- a/Implab/Parsing/CDFADefinition.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,22 +0,0 @@
-namespace Implab.Parsing {
-    public class CDFADefinition : DFADefinition {
-        readonly CharAlphabet m_alphabet;
-
-        public CharAlphabet Alphabet {
-            get { return m_alphabet; }
-        }
-
-        public CDFADefinition(CharAlphabet alphabet): base(alphabet.Count) {
-            m_alphabet = alphabet;
-        }
-
-        public CDFADefinition Optimize() {
-            
-            return (CDFADefinition)Optimize(alphabet => new CDFADefinition((CharAlphabet)alphabet), m_alphabet, new CharAlphabet());
-        }
-
-        public void PrintDFA() {
-            PrintDFA(m_alphabet);
-        }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/CatToken.cs
--- a/Implab/Parsing/CatToken.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,22 +0,0 @@
-using System;
-
-namespace Implab.Parsing {
-    public class CatToken : BinaryToken {
-        public CatToken(Token left, Token right)
-            : base(left, right) {
-        }
-
-        public override void Accept(IVisitor visitor) {
-            Safe.ArgumentNotNull(visitor, "visitor");
-            visitor.Visit(this);
-        }
-
-        public override string ToString() {
-            return String.Format("{0}{1}", FormatToken(Left), FormatToken(Right));
-        }
-
-        string FormatToken(Token token) {
-            return String.Format(token is AltToken ? "({0})" : "{0}", token);
-        }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/CharAlphabet.cs
--- a/Implab/Parsing/CharAlphabet.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,23 +0,0 @@
-using Implab;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Implab.Parsing {
-    public class CharAlphabet: IndexedAlphabetBase<char> {
-
-        public CharAlphabet()
-            : base(char.MaxValue + 1) {
-        }
-
-        public override int GetSymbolIndex(char symbol) {
-            return symbol;
-        }
-
-        public override IEnumerable<char> InputSymbols {
-            get { return Enumerable.Range(char.MinValue, char.MaxValue).Select(x => (char)x); }
-        }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/DFABuilder.cs
--- a/Implab/Parsing/DFABuilder.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,180 +0,0 @@
-using Implab;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-
-namespace Implab.Parsing {
-    /// <summary>
-    /// Используется для построения ДКА по регулярному выражению, сначала обходит
-    /// регулярное выражение и вычисляет followpos, затем используется метод
-    /// <see cref="BuildDFA(IDFADefinition)"/> для построения автомата.
-    /// </summary>
-    public class DFABuilder : IVisitor {
-        int m_idx = 0;
-        Token m_root;
-        HashSet<int> m_firstpos;
-        HashSet<int> m_lastpos;
-
-        Dictionary<int, HashSet<int>> m_followpos = new Dictionary<int, HashSet<int>>();
-        Dictionary<int, int> m_indexes = new Dictionary<int, int>();
-        Dictionary<int, int> m_ends = new Dictionary<int, int>();
-
-        public Dictionary<int, HashSet<int>> FollowposMap {
-            get { return m_followpos; }
-        }
-
-        public HashSet<int> Followpos(int pos) {
-            HashSet<int> set;
-            if (m_followpos.TryGetValue(pos, out set))
-                return set;
-            return m_followpos[pos] = new HashSet<int>();
-        }
-
-        bool Nullable(object n) {
-            if (n is EmptyToken || n is StarToken)
-                return true;
-            if (n is AltToken)
-                return Nullable(((AltToken)n).Left) || Nullable(((AltToken)n).Right);
-            if (n is CatToken)
-                return Nullable(((CatToken)n).Left) && Nullable(((CatToken)n).Right);
-            return false;
-        }
-
-
-        public void Visit(AltToken token) {
-            if (m_root == null)
-                m_root = token;
-            var firtspos = new HashSet<int>();
-            var lastpos = new HashSet<int>();
-
-            token.Left.Accept(this);
-            firtspos.UnionWith(m_firstpos);
-            lastpos.UnionWith(m_lastpos);
-
-            token.Right.Accept(this);
-            firtspos.UnionWith(m_firstpos);
-            lastpos.UnionWith(m_lastpos);
-
-            m_firstpos = firtspos;
-            m_lastpos = lastpos;
-        }
-
-        public void Visit(StarToken token) {
-            if (m_root == null)
-                m_root = token;
-            token.Token.Accept(this);
-
-            foreach (var i in m_lastpos)
-                Followpos(i).UnionWith(m_firstpos);
-        }
-
-        public void Visit(CatToken token) {
-            if (m_root == null)
-                m_root = token;
-
-            var firtspos = new HashSet<int>();
-            var lastpos = new HashSet<int>();
-            token.Left.Accept(this);
-            firtspos.UnionWith(m_firstpos);
-            var leftLastpos = m_lastpos;
-
-            token.Right.Accept(this);
-            lastpos.UnionWith(m_lastpos);
-            var rightFirstpos = m_firstpos;
-
-            if (Nullable(token.Left))
-                firtspos.UnionWith(rightFirstpos);
-
-            if (Nullable(token.Right))
-                lastpos.UnionWith(leftLastpos);
-
-            m_firstpos = firtspos;
-            m_lastpos = lastpos;
-
-            foreach (var i in leftLastpos)
-                Followpos(i).UnionWith(rightFirstpos);
-
-        }
-
-        public void Visit(EmptyToken token) {
-            if (m_root == null)
-                m_root = token;
-            ;
-        }
-
-        public void Visit(SymbolToken token) {
-            if (m_root == null)
-                m_root = token;
-            m_idx++;
-            m_indexes[m_idx] = token.Value;
-            m_firstpos = new HashSet<int>(new[] { m_idx });
-            m_lastpos = new HashSet<int>(new[] { m_idx });
-        }
-
-        public void Visit(EndToken token) {
-            if (m_root == null)
-                m_root = token;
-            m_idx++;
-            m_indexes[m_idx] = IndexedAlphabetBase<char>.UNCLASSIFIED;
-            m_firstpos = new HashSet<int>(new[] { m_idx });
-            m_lastpos = new HashSet<int>(new[] { m_idx });
-            Followpos(m_idx);
-            m_ends.Add(m_idx, token.Tag);
-        }
-
-        public void BuildDFA(IDFADefinition dfa) {
-            Safe.ArgumentNotNull(dfa,"dfa");
-            
-            var stateMap = new Dictionary<HashSet<int>, int>(new CustomEqualityComparer<HashSet<int>>(
-                (x, y) => x.SetEquals(y),
-                (x) => x.Sum(n => n.GetHashCode())
-            ));
-            
-            stateMap[m_firstpos] = DefineState( dfa, m_firstpos);
-            Debug.Assert(stateMap[m_firstpos] == DFADefinition.INITIAL_STATE);
-
-            var queue = new Queue<HashSet<int>>();
-
-            queue.Enqueue(m_firstpos);
-
-            while (queue.Count > 0) {
-                var state = queue.Dequeue();
-                var s1 = stateMap[state];
-
-                for (int a = 0; a < dfa.AlphabetSize; a++) {
-                    var next = new HashSet<int>();
-                    foreach (var p in state) {
-                        if (m_indexes[p] == a) {
-                            next.UnionWith(Followpos(p));
-                        }
-                    }
-                    if (next.Count > 0) {
-                        int s2;
-                        if (!stateMap.TryGetValue(next, out s2)) {
-                            stateMap[next] = s2 = DefineState(dfa, next);
-                            queue.Enqueue(next);
-                        }
-                        dfa.DefineTransition(s1, s2, a);
-                    }
-                }
-
-            }
-        }
-
-        int[] GetStateTags(HashSet<int> state) {
-            Debug.Assert(state != null);
-            return state.Where(m_ends.ContainsKey).Select(pos => m_ends[pos]).ToArray();
-        }
-
-        int DefineState(IDFADefinition automa, HashSet<int> state) {
-            Debug.Assert(automa != null);
-            Debug.Assert(state != null);
-
-            var tags = GetStateTags(state);
-         
-            return tags.Length > 0 ? automa.AddState(tags) : automa.AddState();
-        }
-
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/DFADefinition.cs
--- a/Implab/Parsing/DFADefinition.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,285 +0,0 @@
-using Implab;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-
-namespace Implab.Parsing {
-    public class DFADefinition<TInput, TState, TTag> : IDFADefinition<TInput, TState, TTag> {
-        readonly List<DFAStateDescriptior<TTag>> m_states;
-        
-        public const int INITIAL_STATE = 1;
-        public const int UNREACHEBLE_STATE = 0;
-
-        DFAStateDescriptior<TTag>[] m_statesArray;
-        readonly int m_alpabetSize;
-
-        public DFADefinition(int alphabetSize) {
-            m_states = new List<DFAStateDescriptior<TTag>>();
-            m_alpabetSize = alphabetSize;
-        
-            m_states.Add(new DFAStateDescriptior<TTag>());
-        }
-
-        public bool InitialStateIsFinal {
-            get {
-                return m_states[INITIAL_STATE].final;
-            }
-        }
-
-        public int AddState() {
-            var index = m_states.Count;
-            m_states.Add(new DFAStateDescriptior<TTag> {
-                final = false,
-                transitions = new int[AlphabetSize]
-            });
-            m_statesArray = null;
-
-            return index;
-        }
-
-        public int AddState(TTag[] tag) {
-            var index = m_states.Count;
-            bool final = tag != null && tag.Length != 0;
-            m_states.Add(new DFAStateDescriptior<TTag> {
-                final = final,
-                transitions = new int[AlphabetSize],
-                tag = final ? tag : null
-            });
-            m_statesArray = null;
-            return index;
-        }
-
-        public void DefineTransition(TState s1, TState s2, TInput symbol) {
-            int is1 = StateAlphabet.Translate(s1);
-            int is2 = StateAlphabet.Translate(s2);
-            int isym = InputAlphabet.Translate(symbol);
-
-            Safe.ArgumentAssert(is1 != 0, "s1");
-            Safe.ArgumentAssert(is2 != 0, "s2");
-            Safe.ArgumentAssert(isym != 0, "symbol");
-
-            m_states[is1].transitions[isym] = is2;
-        }
-
-        #region IDFADefinition implementation
-
-        public DFAStateDescriptior<TTag>[] GetTransitionTable() {
-            if (m_statesArray == null)
-                m_statesArray = m_states.ToArray();
-            return m_statesArray;
-        }
-
-        public IAlphabet<TInput> InputAlphabet {
-            get {
-                throw new NotImplementedException();
-            }
-        }
-
-        public IAlphabet<TState> StateAlphabet {
-            get {
-                throw new NotImplementedException();
-            }
-        }
-
-        #endregion
-
-        protected IDFADefinition<> Optimize<TA>(Func<IAlphabet<TA>, IDFADefinition> dfaFactory,IAlphabet<TA> sourceAlphabet, IAlphabet<TA> minimalAlphabet) {
-            Safe.ArgumentNotNull(dfaFactory, "dfaFactory");
-            Safe.ArgumentNotNull(minimalAlphabet, "minimalAlphabet");
-
-            var setComparer = new CustomEqualityComparer<HashSet<int>>(
-                (x, y) => x.SetEquals(y),
-                (s) => s.Sum(x => x.GetHashCode())
-            );
-
-            var arrayComparer = new CustomEqualityComparer<int[]>(
-                (x,y) => (new HashSet<int>(x)).SetEquals(new HashSet<int>(y)),
-                (a) => a.Sum(x => x.GetHashCode())
-            );
-
-            var optimalStates = new HashSet<HashSet<int>>(setComparer);
-            var queue = new HashSet<HashSet<int>>(setComparer);
-
-            foreach (var g in Enumerable
-                .Range(INITIAL_STATE, m_states.Count-1)
-                .Select(i => new {
-                    index = i,
-                    descriptor = m_states[i]
-                })
-                .Where(x => x.descriptor.final)
-                .GroupBy(x => x.descriptor.tag, arrayComparer)
-            ) {
-                optimalStates.Add(new HashSet<int>(g.Select(x => x.index)));
-            }
-
-            var state = new HashSet<int>(
-                Enumerable
-                    .Range(INITIAL_STATE, m_states.Count - 1)
-                    .Where(i => !m_states[i].final)
-            );
-            optimalStates.Add(state);
-            queue.Add(state);
-
-            while (queue.Count > 0) {
-                var stateA = queue.First();
-                queue.Remove(stateA);
-
-                for (int c = 0; c < AlphabetSize; c++) {
-                    var stateX = new HashSet<int>();
-
-                    for(int s = 1; s < m_states.Count; s++) {
-                        if (stateA.Contains(m_states[s].transitions[c]))
-                            stateX.Add(s);
-                    }
-
-                    foreach (var stateY in optimalStates.ToArray()) {
-                        if (stateX.Overlaps(stateY) && !stateY.IsSubsetOf(stateX)) {
-                            var stateR1 = new HashSet<int>(stateY);
-                            var stateR2 = new HashSet<int>(stateY);
-
-                            stateR1.IntersectWith(stateX);
-                            stateR2.ExceptWith(stateX);
-
-                            optimalStates.Remove(stateY);
-                            optimalStates.Add(stateR1);
-                            optimalStates.Add(stateR2);
-
-                            if (queue.Contains(stateY)) {
-                                queue.Remove(stateY);
-                                queue.Add(stateR1);
-                                queue.Add(stateR2);
-                            } else {
-                                queue.Add(stateR1.Count <= stateR2.Count ? stateR1 : stateR2);
-                            }
-                        }
-                    }
-                }
-            }
-
-            // строим карты соотвествия оптимальных состояний с оригинальными
-
-            var initialState = optimalStates.Single(x => x.Contains(INITIAL_STATE));
-
-            // карта получения оптимального состояния по соотвествующему ему простому состоянию
-            int[] reveseOptimalMap = new int[m_states.Count];
-            // карта с индексами оптимальных состояний 
-            HashSet<int>[] optimalMap = new HashSet<int>[optimalStates.Count + 1];
-            {
-                optimalMap[0] = new HashSet<int>(); // unreachable state
-                optimalMap[1] = initialState; // initial state
-                foreach (var ss in initialState)
-                    reveseOptimalMap[ss] = 1;
-
-                int i = 2;
-                foreach (var s in optimalStates) {
-                    if (s.SetEquals(initialState))
-                        continue;
-                    optimalMap[i] = s;
-                    foreach (var ss in s)
-                        reveseOptimalMap[ss] = i;
-                    i++;
-                }
-            }
-
-            // получаем минимальный алфавит
-
-            var minClasses = new HashSet<HashSet<int>>(setComparer);
-            var alphaQueue = new Queue<HashSet<int>>();
-            alphaQueue.Enqueue(new HashSet<int>(Enumerable.Range(0,AlphabetSize)));
-
-            for (int s = 1 ; s < optimalMap.Length; s++) {
-                var newQueue = new Queue<HashSet<int>>();
-
-                foreach (var A in alphaQueue) {
-                    if (A.Count == 1) {
-                        minClasses.Add(A);
-                        continue;
-                    }
-
-                    // различаем классы символов, которые переводят в различные оптимальные состояния
-                    // optimalState -> alphaClass
-                    var classes = new Dictionary<int, HashSet<int>>();
-
-                    foreach (var term in A) {
-                        // ищем все переходы класса по символу term
-                        var s2 = reveseOptimalMap[
-                                     optimalMap[s].Select(x => m_states[x].transitions[term]).FirstOrDefault(x => x != 0) // первое допустимое элементарное состояние, если есть
-                                 ];
-
-                        HashSet<int> A2;
-                        if (!classes.TryGetValue(s2, out A2)) {
-                            A2 = new HashSet<int>();
-                            newQueue.Enqueue(A2);
-                            classes[s2] = A2;
-                        }
-                        A2.Add(term);
-                    }
-                }
-
-                if (newQueue.Count == 0)
-                    break;
-                alphaQueue = newQueue;
-            }
-
-            foreach (var A in alphaQueue)
-                minClasses.Add(A);
-
-            var alphabetMap = sourceAlphabet.Reclassify(minimalAlphabet, minClasses);
-            
-            // построение автомата
-
-            var minimalDFA = dfaFactory(minimalAlphabet);
-
-            var states = new int[ optimalMap.Length ];
-            states[0] = UNREACHEBLE_STATE;
-            
-            for(var s = INITIAL_STATE; s < states.Length; s++) {
-                var tags = optimalMap[s].SelectMany(x => m_states[x].tag ?? Enumerable.Empty<int>()).Distinct().ToArray();
-                if (tags.Length > 0)
-                    states[s] = minimalDFA.AddState(tags);
-                else
-                    states[s] = minimalDFA.AddState();
-            }
-
-            Debug.Assert(states[INITIAL_STATE] == INITIAL_STATE);
-
-            for (int s1 = 1; s1 < m_states.Count;  s1++) {
-                for (int c = 0; c < AlphabetSize; c++) {
-                    var s2 = m_states[s1].transitions[c];
-                    if (s2 != UNREACHEBLE_STATE) {
-                        minimalDFA.DefineTransition(
-                            reveseOptimalMap[s1],
-                            reveseOptimalMap[s2],
-                            alphabetMap[c]
-                        );
-                    }
-                }
-            }
-
-            return minimalDFA;
-        }
-
-        public void PrintDFA<TA>(IAlphabet<TA> alphabet) {
-            
-            var reverseMap = alphabet.CreateReverseMap();
-            
-            for (int i = 1; i < reverseMap.Length; i++) {
-                Console.WriteLine("C{0}: {1}", i, String.Join(",", reverseMap[i]));
-            }
-
-            for (int i = 1; i < m_states.Count; i++) {
-                var s = m_states[i];
-                for (int c = 0; c < AlphabetSize; c++)
-                    if (s.transitions[c] != UNREACHEBLE_STATE)
-                        Console.WriteLine("S{0} -{1}-> S{2}{3}", i, String.Join(",", reverseMap[c]), s.transitions[c], m_states[s.transitions[c]].final ? "$" : "");
-            }
-        }
-
-        public int AlphabetSize {
-            get {
-                return m_alpabetSize;
-            }
-        }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/DFAStateDescriptor.cs
--- a/Implab/Parsing/DFAStateDescriptor.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,13 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Implab.Parsing {
-    public struct DFAStateDescriptior<TTag> {
-        public bool final;
-        public TTag[] tag;
-        public int[] transitions;
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/DFAutomaton.cs
--- a/Implab/Parsing/DFAutomaton.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,61 +0,0 @@
-using Implab;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Implab.Parsing {
-    public abstract class DFAutomaton<T> {
-        protected struct ContextFrame {
-            public DFAStateDescriptior[] states;
-            public int current;
-            public T info;
-        }
-
-        public const int INITIAL_STATE = DFADefinition.INITIAL_STATE;
-        public const int UNREACHEBLE_STATE = DFADefinition.UNREACHEBLE_STATE;
-
-        protected ContextFrame m_context;
-        Stack<ContextFrame> m_contextStack = new Stack<ContextFrame>();
-
-        protected int Level {
-            get { return m_contextStack.Count; }
-        }
-
-        protected DFAutomaton(DFAStateDescriptior[] states, int startState, T info) {
-            Safe.ArgumentNotNull(states, "states");
-            Safe.ArgumentInRange(startState, 0, states.Length - 1, "startState");
- 
-            m_context.states = states;
-            m_context.current = startState;
-            m_context.info = info;
-        }
-
-        protected void Switch(DFAStateDescriptior[] states, int current, T info) {
-            Debug.Assert(states != null);
-            Debug.Assert(current >= 0 && current < states.Length);
-            m_contextStack.Push(m_context);
-            m_context.states = states;
-            m_context.current = current;
-            m_context.info = info;
-        }
-
-        protected void Restore() {
-            Debug.Assert(m_contextStack.Count > 0);
-
-            m_context = m_contextStack.Pop();
-        }
-
-        protected void Move(int input) {
-            Debug.Assert(input > 0 && input < m_context.states[m_context.current].transitions.Length);
-            m_context.current = m_context.states[m_context.current].transitions[input];
-        }
-
-        protected bool CanMove(int input) {
-            Debug.Assert(input > 0 && input < m_context.states[m_context.current].transitions.Length);
-            return m_context.states[m_context.current].transitions[input] != UNREACHEBLE_STATE;
-        }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/EDFADefinition.cs
--- a/Implab/Parsing/EDFADefinition.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,29 +0,0 @@
-using Implab;
-using System;
-
-namespace Implab.Parsing {
-    public class EDFADefinition<T> : DFADefinition where T : struct, IConvertible {
-        readonly EnumAlphabet<T> m_alphabet;
-
-        public EnumAlphabet<T> Alphabet { 
-            get { return m_alphabet; }
-        }
-
-        public EDFADefinition(EnumAlphabet<T> alphabet) : base(alphabet.Count) {
-            m_alphabet = alphabet;
-        }
-
-        public void DefineTransition(int s1, int s2, T input) {
-            DefineTransition(s1, s2, m_alphabet.Translate(input));
-        }
-
-        public EDFADefinition<T> Optimize() {
-            
-            return (EDFADefinition<T>)Optimize(alphabet => new EDFADefinition<T>((EnumAlphabet<T>)alphabet), m_alphabet, new EnumAlphabet<T>());
-        }
-
-        public void PrintDFA() {
-            PrintDFA(m_alphabet);
-        }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/EmptyToken.cs
--- a/Implab/Parsing/EmptyToken.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,18 +0,0 @@
-using Implab;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Implab.Parsing {
-    public class EmptyToken : Token {
-        public override void Accept(IVisitor visitor) {
-            Safe.ArgumentNotNull(visitor, "visitor");
-            visitor.Visit(this);
-        }
-        public override string ToString() {
-            return "$";
-        }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/EndToken.cs
--- a/Implab/Parsing/EndToken.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,37 +0,0 @@
-using Implab;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Implab.Parsing {
-    /// <summary>
-    /// Конечный символ расширенного регулярного выражения, при построении ДКА
-    /// используется для определения конечных состояний.
-    /// </summary>
-    public class EndToken: Token {
-
-        int m_tag;
-
-        public EndToken(int tag) {
-            m_tag = tag;
-        }
-
-        public EndToken()
-            : this(0) {
-        }
-
-        public int Tag {
-            get { return m_tag; }
-        }
-        
-        public override void Accept(IVisitor visitor) {
-            Safe.ArgumentNotNull(visitor, "visitor");
-            visitor.Visit(this);
-        }
-        public override string ToString() {
-            return "#";
-        }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/EnumAlphabet.cs
--- a/Implab/Parsing/EnumAlphabet.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,67 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Globalization;
-using System.Linq;
-using System.Diagnostics.CodeAnalysis;
-
-namespace Implab.Parsing {
-    /// <summary>
-    /// Алфавит символами которого являются элементы перечислений.
-    /// </summary>
-    /// <typeparam name="T">Тип перечислений</typeparam>
-    public class EnumAlphabet<T> : IndexedAlphabetBase<T> where T : struct, IConvertible {
-        [SuppressMessage("Microsoft.Design", "CA1000:DoNotDeclareStaticMembersOnGenericTypes")]
-        static readonly T[] _symbols;
-        static readonly EnumAlphabet<T> _fullAlphabet;
-
-        [SuppressMessage("Microsoft.Design", "CA1065:DoNotRaiseExceptionsInUnexpectedLocations")]
-        static EnumAlphabet() {
-            if (!typeof(T).IsEnum)
-                throw new InvalidOperationException("Invalid generic parameter, enumeration is required");
-
-            if (Enum.GetUnderlyingType(typeof(T)) != typeof(Int32))
-                throw new InvalidOperationException("Only enums based on Int32 are supported");
-
-            _symbols = ((T[])Enum.GetValues(typeof(T)))
-                .OrderBy(x => x.ToInt32(CultureInfo.InvariantCulture))
-                .ToArray();
-
-            if (
-                _symbols[_symbols.Length - 1].ToInt32(CultureInfo.InvariantCulture) >= _symbols.Length
-                || _symbols[0].ToInt32(CultureInfo.InvariantCulture) != 0
-            )
-                throw new InvalidOperationException("The specified enumeration must be zero-based and continuously numbered");
-
-            _fullAlphabet = new EnumAlphabet<T>(_symbols.Select(x => x.ToInt32(CultureInfo.InvariantCulture)).ToArray());
-        }
-
-        
-
-        public static EnumAlphabet<T> FullAlphabet {
-            get {
-                return _fullAlphabet;
-            }
-        }
-
-
-        public EnumAlphabet()
-            : base(_symbols.Length) {
-        }
-
-        public EnumAlphabet(int[] map)
-            : base(map) {
-            Debug.Assert(map.Length == _symbols.Length);
-        }
-
-
-        public override int GetSymbolIndex(T symbol) {
-            return symbol.ToInt32(CultureInfo.InvariantCulture);
-        }
-
-        public override IEnumerable<T> InputSymbols {
-            get { return _symbols; }
-        }
-
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/Grammar.cs
--- a/Implab/Parsing/Grammar.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,108 +0,0 @@
-using Implab;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Implab.Parsing {
-    /// <summary>
-    /// Базовый абстрактный класс. Грамматика, позволяет формулировать выражения над алфавитом типа <c>char</c>.
-    /// </summary>
-    /// <typeparam name="TGrammar"></typeparam>
-    public abstract class Grammar<TGrammar> where TGrammar: Grammar<TGrammar>, new() {
-        static TGrammar _instance;
-        
-        public static TGrammar Instance{
-            get {
-                if (_instance == null)
-                    _instance = new TGrammar();
-                return _instance;
-            }
-        }
-
-        readonly CharAlphabet m_alphabet = new CharAlphabet();
-
-        public CharAlphabet Alphabet {
-            get { return m_alphabet; }
-        }
-
-        public SymbolToken UnclassifiedToken() {
-            return new SymbolToken(CharAlphabet.UNCLASSIFIED);
-        }
-
-        public void DefineAlphabet(IEnumerable<char> alphabet) {
-            Safe.ArgumentNotNull(alphabet, "alphabet");
-
-            foreach (var ch in alphabet)
-                m_alphabet.DefineSymbol(ch);
-        }
-        public Token SymbolRangeToken(char start, char end) {
-            return SymbolToken(Enumerable.Range(start, end - start + 1).Select(x => (char)x));
-        }
-
-        public Token SymbolToken(char symbol) {
-            return Token.New(TranslateOrAdd(symbol));
-        }
-
-        public Token SymbolToken(IEnumerable<char> symbols) {
-            Safe.ArgumentNotNull(symbols, "symbols");
-
-            return Token.New(TranslateOrAdd(symbols).ToArray());
-        }
-
-        public Token SymbolSetToken(params char[] set) {
-            return SymbolToken(set);
-        }
-
-        int TranslateOrAdd(char ch) {
-            var t = m_alphabet.Translate(ch);
-            if (t == CharAlphabet.UNCLASSIFIED)
-                t = m_alphabet.DefineSymbol(ch);
-            return t;
-        }
-
-        IEnumerable<int> TranslateOrAdd(IEnumerable<char> symbols) {
-            return symbols.Distinct().Select(TranslateOrAdd);
-        }
-
-        int TranslateOrDie(char ch) {
-            var t = m_alphabet.Translate(ch);
-                if (t == CharAlphabet.UNCLASSIFIED)
-                    throw new ApplicationException(String.Format("Symbol '{0}' is UNCLASSIFIED", ch));
-            return t;
-        }
-
-        IEnumerable<int> TranslateOrDie(IEnumerable<char> symbols) {
-            return symbols.Distinct().Select(TranslateOrDie);
-        }
-
-        public Token SymbolTokenExcept(IEnumerable<char> symbols) {
-            Safe.ArgumentNotNull(symbols, "symbols");
-
-            return Token.New( Enumerable.Range(0, m_alphabet.Count).Except(TranslateOrDie(symbols)).ToArray());
-        }
-
-        protected CDFADefinition BuildDFA(Token lang) {
-            Safe.ArgumentNotNull(lang, "lang");
-
-            var dfa = new CDFADefinition(m_alphabet);
-            
-            var builder = new DFABuilder();
-
-            lang.Accept( builder );
-
-            builder.BuildDFA(dfa);
-            if (dfa.InitialStateIsFinal)
-                throw new ApplicationException("The specified language contains empty token");
-
-            return dfa.Optimize();
-        }
-
-        
-
-        //protected abstract TGrammar CreateInstance();
-    }
-
-
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/IAlphabet.cs
--- a/Implab/Parsing/IAlphabet.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,48 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Implab.Parsing {
-    /// <summary>
-    /// Алфавит. Множество символов, которые разбиты на классы, при этом классы имеют непрерывную нумерацию,
-    /// что позволяет использовать их в качестве индексов массивов.
-    /// </summary>
-    /// <remarks>
-    /// <para>Алфавит является сюрьективным отображением множества символов в множество индексов, это позволяет сократить размер таблицы переходов автомата
-    /// для входных символов, которые для него не различимы.</para>
-    /// </remarks>
-    /// <typeparam name="TSymbol">Тип символов.</typeparam>
-    public interface IAlphabet<TSymbol> {
-        /// <summary>
-        /// Количество классов символов в алфавите.
-        /// </summary>
-        int Count { get; }
-
-        /// <summary>
-        /// Создает карту обратного сопоставления класса символов алфавита и сопоставленным
-        /// ему исходным символам.
-        /// </summary>
-        /// <returns></returns>
-        List<TSymbol>[] CreateReverseMap();
-
-        /// <summary>
-        /// Создает новый алфавит на основе текущего, горппируя его сиволы в более
-        /// крупные непересекающиеся классы символов.
-        /// </summary>
-        /// <param name="newAlphabet">Новый, пустой алфавит, в котором быдут определены классы.</param>
-        /// <param name="classes">Множество классов символов текущего алфавита.</param>
-        /// <returns>Карта для перехода классов текущего
-        /// алфавита к классам нового.</returns>
-        /// <remarks>Ползволяет укрупнить алфавит, объединив классы в текущем алфавите. Используется при оптимизации автомата.</remarks>
-        int[] Reclassify(IAlphabetBuilder<TSymbol> newAlphabet, IEnumerable<ICollection<int>> classes);
-
-        /// <summary>
-        /// Преобразует входной символ в индекс символа из алфавита.
-        /// </summary>
-        /// <param name="symobl">Исходный символ</param>
-        /// <returns>Индекс в алфавите</returns>
-        int Translate(TSymbol symobl);
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/IAlphabetBuilder.cs
--- a/Implab/Parsing/IAlphabetBuilder.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,25 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace Implab.Parsing {
-    public interface IAlphabetBuilder<TSymbol> : IAlphabet<TSymbol> {
-        /// <summary>
-        /// Добавляет новый символ в алфавит, если символ уже был добавлен, то
-        /// возвращается ранее сопоставленный с символом класс.
-        /// </summary>
-        /// <param name="symbol">Символ для добавления.</param>
-        /// <returns>Индекс класса, который попоставлен с символом.</returns>
-        int DefineSymbol(TSymbol symbol);
-        /// <summary>
-        /// Доабвляем класс символов. Множеству указанных исходных символов 
-        /// будет сопоставлен символ в алфавите.
-        /// </summary>
-        /// <param name="symbols">Множестов исходных символов</param>
-        /// <returns>Идентификатор символа алфавита.</returns>
-        int DefineClass(IEnumerable<TSymbol> symbols);
-
-
-
-    }
-}
-
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/IDFADefinition.cs
--- a/Implab/Parsing/IDFADefinition.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,61 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Implab.Parsing {
-    /// <summary>
-    /// Полностью описывает DFA автомат, его поведение, состояние и входные символы.
-    /// </summary>
-    /// <example>
-    /// class MyAutomaton {
-    ///     int m_current;
-    ///     readonly DFAStateDescriptor<string>[] m_automaton;
-    ///     readonly IAlphabet<MyCommands> m_commands;
-    /// 
-    ///     public MyAutomaton(IDFADefinition&lt;MyCommands,MyStates,string&gt; definition) {
-    ///         m_current = definition.StateAlphabet.Translate(MyStates.Initial);
-    ///         m_automaton = definition.GetTransitionTable();
-    ///         m_commands = definition.InputAlphabet;
-    ///     }
-    /// 
-    ///     // defined a method which will move the automaton to the next state
-    ///     public void Move(MyCommands cmd) {
-    ///         // use transition map to determine the next state
-    ///         var next = m_automaton[m_current].transitions[m_commands.Translate(cmd)];
-    /// 
-    ///         // validate that we aren't in the unreachable state
-    ///         if (next == DFAConst.UNREACHABLE_STATE)
-    ///             throw new InvalidOperationException("The specified command is invalid");
-    /// 
-    ///         // if everything is ok
-    ///         m_current = next;
-    ///     }
-    /// }
-    /// </example>
-    public interface IDFADefinition<TInput, TState, TTag> {
-        /// <summary>
-        /// Алфавит входных символов
-        /// </summary>
-        /// <value>The input alphabet.</value>
-        IAlphabet<TInput> InputAlphabet {
-            get;
-        }
-
-        /// <summary>
-        /// Алфавит состояний автомата
-        /// </summary>
-        /// <value>The state alphabet.</value>
-        IAlphabet<TState> StateAlphabet {
-            get;
-        }
-
-        /// <summary>
-        /// Таблица переходов состояний автомата
-        /// </summary>
-        /// <returns>The transition table.</returns>
-        DFAStateDescriptior<TTag>[] GetTransitionTable();
-
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/IDFADefinitionBuilder.cs
--- a/Implab/Parsing/IDFADefinitionBuilder.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,9 +0,0 @@
-using System;
-
-namespace Implab.Parsing {
-    public interface IDFADefinitionBuilder<TInput, TState, TTag> : IDFADefinition<TInput, TState, TTag> {
-
-
-    }
-}
-
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/IVisitor.cs
--- a/Implab/Parsing/IVisitor.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,19 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Implab.Parsing {
-    /// <summary>
-    /// Интерфейс обходчика синтаксического дерева регулярного выражения
-    /// </summary>
-    public interface IVisitor {
-        void Visit(AltToken token);
-        void Visit(StarToken token);
-        void Visit(CatToken token);
-        void Visit(EmptyToken token);
-        void Visit(EndToken token);
-        void Visit(SymbolToken token);
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/IndexedAlphabetBase.cs
--- a/Implab/Parsing/IndexedAlphabetBase.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,107 +0,0 @@
-using Implab;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Implab.Parsing {
-    /// <summary>
-    /// Indexed alphabet is the finite set of symbols where each symbol has a zero-based unique index.
-    /// </summary>
-    public abstract class IndexedAlphabetBase<T> : IAlphabet<T> {
-        public const int UNCLASSIFIED = 0;
-
-        int m_nextId = 1;
-        readonly int[] m_map;
-
-        public int Count {
-            get { return m_nextId; }
-        }
-
-        protected IndexedAlphabetBase(int mapSize) {
-            m_map = new int[mapSize];
-        }
-
-        protected IndexedAlphabetBase(int[] map) {
-            Debug.Assert(map != null);
-
-            m_map = map;
-            m_nextId = map.Max() + 1;
-        }
-
-        public int DefineSymbol(T symbol) {
-            var index = GetSymbolIndex(symbol);
-            if (m_map[index] == UNCLASSIFIED)
-                m_map[index] = m_nextId++;
-            return m_map[index];
-        }
-
-        public int DefineClass(IEnumerable<T> symbols) {
-            Safe.ArgumentNotNull(symbols, "symbols");
-            symbols = symbols.Distinct();
-
-            foreach (var symbol in symbols) {
-                var index = GetSymbolIndex(symbol);
-                if (m_map[index] == UNCLASSIFIED)
-                    m_map[GetSymbolIndex(symbol)] = m_nextId;
-                else
-                    throw new InvalidOperationException(String.Format("Symbol '{0}' already in use", symbol));
-            }
-            return m_nextId++;
-        }
-
-        public List<T>[] CreateReverseMap() {
-            return
-                Enumerable.Range(UNCLASSIFIED, Count)
-                    .Select(
-                        i => InputSymbols
-                            .Where(x => i != UNCLASSIFIED && m_map[GetSymbolIndex(x)] == i)
-                            .ToList()
-                    )
-                    .ToArray();
-        }
-
-        public int[] Reclassify(IAlphabet<T> newAlphabet, IEnumerable<ICollection<int>> classes) {
-            Safe.ArgumentNotNull(newAlphabet, "newAlphabet");
-            Safe.ArgumentNotNull(classes, "classes");
-            var reverseMap = CreateReverseMap();
-
-            int[] translationMap = new int[Count];
-
-            foreach (var scl in classes) {
-                // skip if the supper class contains the unclassified element
-                if (scl.Contains(UNCLASSIFIED))
-                    continue;
-                var range = new List<T>();
-                foreach (var cl in scl) {
-                    if (cl < 0 || cl >= reverseMap.Length)
-                        throw new ArgumentOutOfRangeException(String.Format("Class {0} is not valid for the current alphabet", cl));
-                    range.AddRange(reverseMap[cl]);
-                }
-                var newClass = newAlphabet.DefineClass(range);
-                foreach (var cl in scl)
-                    translationMap[cl] = newClass;
-            }
-
-            return translationMap;
-        }
-
-        public virtual int Translate(T symbol) {
-            return m_map[GetSymbolIndex(symbol)];
-        }
-
-        public abstract int GetSymbolIndex(T symbol);
-
-        public abstract IEnumerable<T> InputSymbols { get; }
-
-        /// <summary>
-        /// Gets the translation map from the index of the symbol to it's class this is usefull for the optimized input symbols transtaion.
-        /// </summary>
-        /// <returns>The translation map.</returns>
-        public int[] GetTranslationMap() {
-            return m_map;
-        }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/ParserException.cs
--- a/Implab/Parsing/ParserException.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,17 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Implab.Parsing {
-    [Serializable]
-    public class ParserException : Exception {
-        public ParserException() { }
-        public ParserException(string message) : base(message) { }
-        public ParserException(string message, Exception inner) : base(message, inner) { }
-        protected ParserException(
-          System.Runtime.Serialization.SerializationInfo info,
-          System.Runtime.Serialization.StreamingContext context)
-            : base(info, context) { }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/Scanner.cs
--- a/Implab/Parsing/Scanner.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,259 +0,0 @@
-using Implab;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using Implab.Components;
-
-namespace Implab.Parsing {
-    /// <summary>
-    /// Базовый класс для разбора потока входных символов на токены.
-    /// </summary>
-    /// <remarks>
-    /// Сканнер имеет внутри буффер с симолами входного текста, по которому перемещаются два
-    /// указателя, начала и конца токена, при перемещении искользуется ДКА для определения
-    /// конца токена и допустимости текущего символа.
-    /// </remarks>
-    public abstract class Scanner : Disposable {
-        struct ScannerConfig {
-            public DFAStateDescriptior[] states;
-            public int[] alphabetMap;
-        }
-
-        Stack<ScannerConfig> m_defs = new Stack<ScannerConfig>();
-
-        DFAStateDescriptior[] m_states;
-        int[] m_alphabetMap;
-
-        protected DFAStateDescriptior m_currentState;
-        int m_previewCode;
-
-        protected int m_tokenLen = 0;
-        protected int m_tokenOffset;
-
-        protected char[] m_buffer;
-        protected int m_bufferSize;
-        protected int m_pointer;
-
-        TextReader m_reader;
-        bool m_disposeReader;
-        int m_chunkSize = 1024; // 1k
-        int m_limit = 10 * 1024 * 1024; // 10Mb
-
-        protected Scanner(DFAStateDescriptior[] states, int[] alphabet) {
-            Safe.ArgumentNotEmpty(states, "states");
-            Safe.ArgumentNotNull(alphabet, "alphabet");
-
-            m_states = states;
-            m_alphabetMap = alphabet;
-
-            Feed(new char[0]);
-        }
-
-        /// <summary>
-        /// Заполняет входными данными буффер.
-        /// </summary>
-        /// <param name="data">Данные для обработки.</param>
-        /// <remarks>Копирование данных не происходит, переданный массив используется в
-        /// качестве входного буффера.</remarks>
-        public void Feed(char[] data) {
-            Safe.ArgumentNotNull(data, "data");
-
-            Feed(data, data.Length);
-        }
-
-        /// <summary>
-        /// Заполняет буффур чтения входными данными.
-        /// </summary>
-        /// <param name="data">Данные для обработки.</param>
-        /// <param name="length">Длина данных для обработки.</param>
-        /// <remarks>Копирование данных не происходит, переданный массив используется в
-        /// качестве входного буффера.</remarks>
-        public void Feed(char[] data, int length) {
-            Safe.ArgumentNotNull(data, "data");
-            Safe.ArgumentInRange(length, 0, data.Length, "length");
-            AssertNotDisposed();
-
-            m_pointer = -1;
-            m_buffer = data;
-            m_bufferSize = length;
-            Shift();
-        }
-
-        public void Feed(TextReader reader, bool dispose) {
-            Safe.ArgumentNotNull(reader, "reader");
-            AssertNotDisposed();
-
-            if (m_reader != null && m_disposeReader)
-                m_reader.Dispose();
-
-            m_reader = reader;
-            m_disposeReader = dispose;
-            m_pointer = -1;
-            m_buffer = new char[m_chunkSize];
-            m_bufferSize = 0;
-            Shift();
-        }
-
-        /// <summary>
-        /// Получает текущий токен в виде строки.
-        /// </summary>
-        /// <returns></returns>
-        protected string GetTokenValue() {
-            return new String(m_buffer, m_tokenOffset, m_tokenLen);
-        }
-
-        /// <summary>
-        /// Метки текущего токена, которые были назначены в регулярном выражении.
-        /// </summary>
-        protected int[] TokenTags {
-            get {
-                return m_currentState.tag;
-            }
-        }
-
-        /// <summary>
-        /// Признак конца данных
-        /// </summary>
-        public bool EOF {
-            get {
-                return m_pointer >= m_bufferSize;
-            }
-        }
-
-        /// <summary>
-        /// Читает следующий токен, при этом <see cref="m_tokenOffset"/> указывает на начало токена,
-        /// <see cref="m_tokenLen"/> на длину токена, <see cref="m_buffer"/> - массив символов, в
-        /// котором находится токен.
-        /// </summary>
-        /// <returns><c>false</c> - достигнут конец данных, токен не прочитан.</returns>
-        protected bool ReadTokenInternal() {
-            if (m_pointer >= m_bufferSize)
-                return false;
-
-            m_currentState = m_states[DFADefinition.INITIAL_STATE];
-            m_tokenLen = 0;
-            m_tokenOffset = m_pointer;
-            int nextState;
-            do {
-                nextState = m_currentState.transitions[m_previewCode];
-                if (nextState == DFADefinition.UNREACHEBLE_STATE) {
-                    if (m_currentState.final)
-                        return true;
-                    else
-                        throw new ParserException(
-                            String.Format(
-                                "Unexpected symbol '{0}', at pos {1}",
-                                m_buffer[m_pointer],
-                                Position
-                            )
-                        );
-                } else {
-                    m_currentState = m_states[nextState];
-                    m_tokenLen++;
-                }
-
-            } while (Shift());
-
-            // END OF DATA
-            if (!m_currentState.final)
-                throw new ParserException("Unexpected end of data");
-
-            return true;
-        }
-
-
-        bool Shift() {
-            m_pointer++;
-
-            if (m_pointer >= m_bufferSize) {
-                if (!ReadNextChunk())
-                    return false;
-            }
-
-            m_previewCode = m_alphabetMap[m_buffer[m_pointer]];
-
-            return true;
-        }
-
-        bool ReadNextChunk() {
-            if (m_reader == null)
-                return false;
-
-            //  extend buffer if nesessary
-            if (m_pointer + m_chunkSize > m_buffer.Length) {
-                // trim unused buffer head
-                var size = m_tokenLen + m_chunkSize;
-                if (size >= m_limit)
-                    throw new ParserException(String.Format("Input buffer {0} bytes limit exceeded", m_limit));
-                var temp = new char[size];
-                Array.Copy(m_buffer, m_tokenOffset, temp, 0, m_tokenLen);
-                m_pointer -= m_tokenOffset;
-                m_bufferSize -= m_tokenOffset;
-                m_tokenOffset = 0;
-                m_buffer = temp;
-            }
-            
-            var read = m_reader.Read(m_buffer, m_tokenLen, m_chunkSize);
-            if (read == 0)
-                return false;
-
-            m_bufferSize += read;
-
-            return true;
-        }
-
-        /// <summary>
-        /// Позиция сканнера во входном буфере
-        /// </summary>
-        public int Position {
-            get {
-                return m_pointer + 1;
-            }
-        }
-
-        /// <summary>
-        /// Преключает внутренний ДКА на указанный, позволяет реализовать подобие захватывающей
-        /// группировки.
-        /// </summary>
-        /// <param name="states">Таблица состояний нового ДКА</param>
-        /// <param name="alphabet">Таблица входных символов для нового ДКА</param>
-        protected void Switch(DFAStateDescriptior[] states, int[] alphabet) {
-            Safe.ArgumentNotNull(states, "dfa");
-
-            m_defs.Push(new ScannerConfig {
-                states = m_states,
-                alphabetMap = m_alphabetMap
-            });
-
-            m_states = states;
-            m_alphabetMap = alphabet;
-
-            m_previewCode = m_alphabetMap[m_buffer[m_pointer]];
-        }
-
-        /// <summary>
-        /// Восстанавливает предыдущей ДКА сканнера.
-        /// </summary>
-        protected void Restore() {
-            if (m_defs.Count == 0)
-                throw new InvalidOperationException();
-            var prev = m_defs.Pop();
-            m_states = prev.states;
-            m_alphabetMap = prev.alphabetMap;
-            m_previewCode = m_alphabetMap[m_buffer[m_pointer]];
-        }
-
-        protected override void Dispose(bool disposing) {
-            if (disposing) {
-                if (m_reader != null && m_disposeReader)
-                    m_reader.Dispose();
-                m_buffer = null;
-                m_bufferSize = 0;
-                m_pointer = 0;
-                m_tokenLen = 0;
-                m_tokenOffset = 0;
-            }
-            base.Dispose(disposing);
-        }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/StarToken.cs
--- a/Implab/Parsing/StarToken.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,34 +0,0 @@
-using Implab;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Implab.Parsing {
-    /// <summary>
-    /// Замыкание выражения с 0 и более повторов.
-    /// </summary>
-    public class StarToken: Token {
-
-        Token m_token;
-
-        public Token Token {
-            get { return m_token; }
-        }
-
-        public StarToken(Token token) {
-            Safe.ArgumentNotNull(token, "token");
-            m_token = token;
-        }
-
-        public override void Accept(IVisitor visitor) {
-            Safe.ArgumentNotNull(visitor, "visitor");
-            visitor.Visit(this);
-        }
-
-        public override string ToString() {
-            return String.Format("({0})*", Token.ToString());
-        }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/SymbolToken.cs
--- a/Implab/Parsing/SymbolToken.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,33 +0,0 @@
-using Implab;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Implab.Parsing {
-    /// <summary>
-    /// Выражение, соответсвующее одному символу.
-    /// </summary>
-    public class SymbolToken : Token {
-        int m_value;
-
-        public int Value {
-            get { return m_value; }
-        }
-
-        public SymbolToken(int value) {
-            m_value = value;
-        }
-        public override void Accept(IVisitor visitor) {
-            Safe.ArgumentNotNull(visitor, "visitor");
-
-            visitor.Visit(this);
-            
-        }
-
-        public override string ToString() {
-            return Value.ToString();
-        }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Parsing/Token.cs
--- a/Implab/Parsing/Token.cs	Fri Feb 19 18:07:17 2016 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,67 +0,0 @@
-using Implab;
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Implab.Parsing {
-    public abstract class Token {
-        public abstract void Accept(IVisitor visitor);
-
-        public Token Extend() {
-            return new CatToken(this, new EndToken());
-        }
-
-        public Token Tag<T>(T tag) where T : IConvertible {
-            return new CatToken(this, new EndToken(tag.ToInt32(CultureInfo.InvariantCulture)));
-        }
-
-        public Token Cat(Token right) {
-            return new CatToken(this, right);
-        }
-
-        public Token Or(Token right) {
-            return new AltToken(this, right);
-        }
-
-        public Token Optional() {
-            return Or(new EmptyToken());
-        }
-
-        public Token EClosure() {
-            return new StarToken(this);
-        }
-
-        public Token Closure() {
-            return new CatToken(this, new StarToken(this));
-        }
-
-        public Token Repeat(int count) {
-            Token token = null;
-
-            for (int i = 0; i < count; i++)
-                token = token != null ? token.Cat(this) : this;
-            return token ?? new EmptyToken();
-        }
-
-        public Token Repeat(int min, int max) {
-            if (min > max || min < 1)
-                throw new ArgumentOutOfRangeException();
-            var token = Repeat(min);
-
-            for (int i = min; i < max; i++)
-                token = token.Cat( this.Optional() );
-            return token;
-        }
-
-        public static Token New<T>(params T[] set) where T : struct, IConvertible {
-            Safe.ArgumentNotNull(set, "set");
-            Token token = null;
-            foreach(var c in set.Distinct())
-                token = token == null ? new SymbolToken(c.ToInt32(CultureInfo.InvariantCulture)) : token.Or(new SymbolToken(c.ToInt32(CultureInfo.InvariantCulture)));
-            return token;
-        }
-    }
-}
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/PromiseExtensions.cs
--- a/Implab/PromiseExtensions.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/PromiseExtensions.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -3,11 +3,6 @@
 using Implab.Diagnostics;
 using System.Collections.Generic;
 
-
-#if NET_4_5
-using System.Threading.Tasks;
-#endif
-
 namespace Implab {
     public static class PromiseExtensions {
         public static IPromise<T> DispatchToCurrentContext<T>(this IPromise<T> that) {
@@ -17,12 +12,12 @@
                 return that;
 
             var p = new SyncContextPromise<T>(context);
-            p.On(that.Cancel, PromiseEventType.Cancelled);
+            p.CancellationRequested(that.Cancel);
 
             that.On(
                 p.Resolve,
                 p.Reject,
-                p.Cancel
+                p.CancelOperation
             );
             return p;
         }
@@ -32,13 +27,12 @@
             Safe.ArgumentNotNull(context, "context");
 
             var p = new SyncContextPromise<T>(context);
-            p.On(that.Cancel, PromiseEventType.Cancelled);
-
+            p.CancellationRequested(that.Cancel);
 
             that.On(
                 p.Resolve,
                 p.Reject,
-                p.Cancel
+                p.CancelOperation
             );
             return p;
         }
@@ -77,8 +71,8 @@
             };
         }
 
-        static void CancelCallback(object cookie) {
-            ((ICancellable)cookie).Cancel();
+        static void CancelByTimeoutCallback(object cookie) {
+            ((ICancellable)cookie).Cancel(new TimeoutException());
         }
 
         /// <summary>
@@ -89,7 +83,7 @@
         /// <typeparam name="TPromise">The 1st type parameter.</typeparam>
         public static TPromise Timeout<TPromise>(this TPromise that, int milliseconds) where TPromise : IPromise {
             Safe.ArgumentNotNull(that, "that");
-            var timer = new Timer(CancelCallback, that, milliseconds, -1);
+            var timer = new Timer(CancelByTimeoutCallback, that, milliseconds, -1);
             that.On(timer.Dispose, PromiseEventType.All);
             return that;
         }
@@ -180,8 +174,7 @@
 
             var d = new ActionTask(success, error, cancel, false);
             that.On(d.Resolve, d.Reject, d.CancelOperation);
-            if (success != null)
-                d.CancellationRequested(that.Cancel);
+            d.CancellationRequested(that.Cancel);
             return d;
         }
 
@@ -198,8 +191,7 @@
 
             var d = new FuncTask<T>(success, error, cancel, false);
             that.On(d.Resolve, d.Reject, d.CancelOperation);
-            if (success != null)
-                d.CancellationRequested(that.Cancel);
+            d.CancellationRequested(that.Cancel);
             return d;
         }
 
@@ -215,8 +207,7 @@
             Safe.ArgumentNotNull(that, "that");
             var d = new FuncTask<T,T2>(success, error, cancel, false);
             that.On(d.Resolve, d.Reject, d.CancelOperation);
-            if (success != null)
-                d.CancellationRequested(that.Cancel);
+            d.CancellationRequested(that.Cancel);
             return d;
         }
 
@@ -234,8 +225,7 @@
 
             var d = new ActionChainTask(success, error, cancel, false);
             that.On(d.Resolve, d.Reject, d.CancelOperation);
-            if (success != null)
-                d.CancellationRequested(that.Cancel);
+            d.CancellationRequested(that.Cancel);
             return d;
         }
 
diff -r 2a8466f0cb8a -r 1c2a16d071a7 Implab/Safe.cs
--- a/Implab/Safe.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/Implab/Safe.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -41,6 +41,11 @@
                 throw new ArgumentOutOfRangeException(paramName);
         }
 
+        public static void ArgumentOfType(object value, Type type, string paramName) {
+            if (!type.IsInstanceOfType(value))
+                throw new ArgumentException(String.Format("The parameter must be of type {0}", type), paramName);
+        }
+
         public static void Dispose(params IDisposable[] objects) {
             foreach (var d in objects)
                 if (d != null)
diff -r 2a8466f0cb8a -r 1c2a16d071a7 MonoPlay/MonoPlay.csproj
--- a/MonoPlay/MonoPlay.csproj	Fri Feb 19 18:07:17 2016 +0300
+++ b/MonoPlay/MonoPlay.csproj	Fri Apr 22 13:08:08 2016 +0300
@@ -32,6 +32,9 @@
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
+    <Reference Include="System.Text.Json">
+      <HintPath>..\packages\System.Text.Json.2.0.0.11\lib\net40\System.Text.Json.dll</HintPath>
+    </Reference>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Program.cs" />
@@ -44,4 +47,7 @@
       <Name>Implab</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff -r 2a8466f0cb8a -r 1c2a16d071a7 MonoPlay/Program.cs
--- a/MonoPlay/Program.cs	Fri Feb 19 18:07:17 2016 +0300
+++ b/MonoPlay/Program.cs	Fri Apr 22 13:08:08 2016 +0300
@@ -1,6 +1,9 @@
 using System;
 using Implab;
 using System.Threading.Tasks;
+using Implab.Formats.JSON;
+using System.IO;
+using System.Text.Json;
 
 namespace MonoPlay {
     class MainClass {
@@ -9,28 +12,33 @@
         public static void Main(string[] args) {
             if (args == null)
                 throw new ArgumentNullException("args");
-
-            var t1 = Environment.TickCount;
-
-            DoWork().GetAwaiter().GetResult();
+            int t1, t2;
 
-            var t2 = Environment.TickCount;
-            Console.WriteLine("done: {0} ms, {1:.00} Mb, {2} GC", t2 - t1, GC.GetTotalMemory(false) / (1024*1024), GC.CollectionCount(0) );
+            for (int i = 0; i < 2; i++) {
+                t1 = Environment.TickCount;
+                int elements =0;
+                using (var reader = new JSONParser(File.OpenText("/home/sergey/temp/citylots.json"))) {
+                    while (reader.Read())
+                        elements++;
+                }
 
-        }
+                t2 = Environment.TickCount;
+                Console.WriteLine("attempt {0} done: {1} ms, {2:.00} Mb, {3} GC, Elements: {4}",i+1, t2 - t1, GC.GetTotalMemory(false) / (1024*1024), GC.CollectionCount(0), elements );
+            }
 
-        static IPromise<int> DoItem(int x) {
-            //return Promise<int>.FromResult(x + 1);
-            var p = new Promise<int>();
-            p.Resolve(x+1);
-            return p;
-        }
+            Console.WriteLine("Syste.Text.Json");
+            var paraser = new JsonParser();
+            for (int i = 0; i < 2; i++) {
+                t1 = Environment.TickCount;
+                using (var reader = File.OpenText("/home/sergey/temp/citylots.json")) {
+                    paraser.Parse(reader);
+                }
 
-        static async Task<int> DoWork() {
-            var c = 0;
-            for (int i = 0; i < 10000000; i++)
-                c = await DoItem(c);
-            return c;
+                t2 = Environment.TickCount;
+                Console.WriteLine("attempt {0} done: {1} ms, {2:.00} Mb, {3} GC, ",i+1, t2 - t1, GC.GetTotalMemory(false) / (1024*1024), GC.CollectionCount(0));
+            }
+
+
         }
 
     }
diff -r 2a8466f0cb8a -r 1c2a16d071a7 MonoPlay/packages.config
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/MonoPlay/packages.config	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="System.Text.Json" version="2.0.0.11" targetFramework="net45" />
+</packages>
\ No newline at end of file
diff -r 2a8466f0cb8a -r 1c2a16d071a7 packages/NUnit.2.6.4/NUnit.2.6.4.nupkg
Binary file packages/NUnit.2.6.4/NUnit.2.6.4.nupkg has changed
diff -r 2a8466f0cb8a -r 1c2a16d071a7 packages/NUnit.2.6.4/lib/nunit.framework.dll
Binary file packages/NUnit.2.6.4/lib/nunit.framework.dll has changed
diff -r 2a8466f0cb8a -r 1c2a16d071a7 packages/NUnit.2.6.4/lib/nunit.framework.xml
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/packages/NUnit.2.6.4/lib/nunit.framework.xml	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,10984 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>nunit.framework</name>
+    </assembly>
+    <members>
+        <member name="T:NUnit.Framework.ActionTargets">
+            <summary>
+            The different targets a test action attribute can be applied to
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.ActionTargets.Default">
+            <summary>
+            Default target, which is determined by where the action attribute is attached
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.ActionTargets.Test">
+            <summary>
+            Target a individual test case
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.ActionTargets.Suite">
+            <summary>
+            Target a suite of test cases
+            </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.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="actual">The actual value to test</param>
+            <param name="expression">A Constraint to be applied</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="actual">The actual value to test</param>
+            <param name="expression">A Constraint to be applied</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="actual">The actual value to test</param>
+            <param name="expression">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(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``1(NUnit.Framework.Constraints.ActualValueDelegate{``0},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="del">An ActualValueDelegate returning the value to be tested</param>
+            <param name="expr">A Constraint expression to be applied</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.That``1(NUnit.Framework.Constraints.ActualValueDelegate{``0},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="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>
+        </member>
+        <member name="M:NUnit.Framework.Assert.That``1(NUnit.Framework.Constraints.ActualValueDelegate{``0},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="actual">The actual value to test</param>
+            <param name="expression">A Constraint to be applied</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="actual">The actual value to test</param>
+            <param name="expression">A Constraint to be applied</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="actual">The actual value to test</param>
+            <param name="expression">A Constraint 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(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.ByVal(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.
+            Used as a synonym for That in rare cases where a private setter 
+            causes a Visual Basic compilation error.
+            </summary>
+            <param name="actual">The actual value to test</param>
+            <param name="expression">A Constraint to be applied</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.ByVal(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.
+            Used as a synonym for That in rare cases where a private setter 
+            causes a Visual Basic compilation error.
+            </summary>
+            <param name="actual">The actual value to test</param>
+            <param name="expression">A Constraint to be applied</param>
+            <param name="message">The message that will be displayed on failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.ByVal(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. 
+            Used as a synonym for That in rare cases where a private setter 
+            causes a Visual Basic compilation error.
+            </summary>
+            <remarks>
+            This method is provided for use by VB developers needing to test
+            the value of properties with private setters.
+            </remarks>
+            <param name="actual">The actual value to test</param>
+            <param name="expression">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.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 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.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 TestDelegate</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 TestDelegate</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 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.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 TestDelegate</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 TestDelegate</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 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.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 TestDelegate</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 TestDelegate</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 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.DoesNotThrow(NUnit.Framework.TestDelegate,System.String)">
+            <summary>
+            Verifies that a delegate does not throw an exception.
+            </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.DoesNotThrow(NUnit.Framework.TestDelegate)">
+            <summary>
+            Verifies that a delegate does not throw an exception.
+            </summary>
+            <param name="code">A TestDelegate</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.AreEqual(System.Int32,System.Int32,System.String,System.Object[])">
+            <summary>
+            Verifies that two ints 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 ints 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 ints 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 longs 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 longs 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 longs 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 unsigned ints 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 unsigned ints 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 unsigned ints 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 unsigned longs 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 unsigned longs 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 unsigned longs 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 decimals 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 decimals 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 decimals 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 ints 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 ints 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 ints 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 longs 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 longs 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 longs 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 unsigned ints 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 unsigned ints 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 unsigned ints 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 unsigned longs 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 unsigned longs 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 unsigned longs 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 decimals 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 decimals 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 decimals 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 floats 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 floats 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 floats 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 doubles 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 doubles 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 doubles 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.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.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 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.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 ICollection</param>
+            <param name="message">The message to display in case of failure</param>
+        </member>
+        <member name="M:NUnit.Framework.Assert.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 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.IEnumerable,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.IEnumerable,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.IEnumerable)">
+            <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.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="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="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="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.Exactly(System.Int32)">
+            <summary>
+            Returns a ConstraintExpression, which will apply
+            the following constraint to all members of a collection,
+            succeeding only if a specified number of them succeed.
+            </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 regular expression 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 regular expression 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``1(``0,``0)">
+            <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.Positive">
+            <summary>
+            Returns a constraint that tests for a positive value
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Negative">
+            <summary>
+            Returns a constraint that tests for a negative value
+            </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="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 Assert.That.
+            </summary>
+            <param name="actual">The actual value to test</param>
+            <param name="expression">A Constraint to be applied</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 Assert.That.
+            </summary>
+            <param name="actual">The actual value to test</param>
+            <param name="expression">A Constraint to be applied</param>
+            <param name="message">The message to be displayed in case of 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 Assert.That.
+            </summary>
+            <param name="actual">The actual value to test</param>
+            <param name="expression">A Constraint to be applied</param>
+            <param name="message">The message to be displayed in case of failure</param>
+            <param name="args">Arguments to use 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``1(NUnit.Framework.Constraints.ActualValueDelegate{``0},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``1(NUnit.Framework.Constraints.ActualValueDelegate{``0},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``1(NUnit.Framework.Constraints.ActualValueDelegate{``0},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="actual">The actual value to test</param>
+            <param name="expression">A Constraint to be applied</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="actual">The actual value to test</param>
+            <param name="expression">A Constraint to be applied</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="actual">The actual value to test</param>
+            <param name="expression">A Constraint 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(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(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``1(NUnit.Framework.Constraints.ActualValueDelegate{``0},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``1(NUnit.Framework.Constraints.ActualValueDelegate{``0},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``1(NUnit.Framework.Constraints.ActualValueDelegate{``0},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(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.AsyncInvocationRegion.WaitForPendingOperationsToComplete(System.Object)">
+            <summary>
+            Waits for pending asynchronous operations to complete, if appropriate,
+            and returns a proper result of the invocation by unwrapping task results
+            </summary>
+            <param name="invocationResult">The raw result of the method invocation</param>
+            <returns>The unwrapped result, if necessary</returns>
+        </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 the superset does not contain the subset
+            </summary>
+            <param name="subset">The IEnumerable subset to be considered</param>
+            <param name="superset">The IEnumerable superset to be considered</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsNotSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+            <summary>
+            Asserts that the superset does not contain the subset
+            </summary>
+            <param name="subset">The IEnumerable subset to be considered</param>
+            <param name="superset">The IEnumerable superset 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 the superset does not contain the subset
+            </summary>
+            <param name="subset">The IEnumerable subset to be considered</param>
+            <param name="superset">The IEnumerable superset 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 the superset contains the subset.
+            </summary>
+            <param name="subset">The IEnumerable subset to be considered</param>
+            <param name="superset">The IEnumerable superset to be considered</param>
+        </member>
+        <member name="M:NUnit.Framework.CollectionAssert.IsSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+            <summary>
+            Asserts that the superset contains the subset.
+            </summary>
+            <param name="subset">The IEnumerable subset to be considered</param>
+            <param name="superset">The IEnumerable superset 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 the superset contains the subset.
+            </summary>
+            <param name="subset">The IEnumerable subset to be considered</param>
+            <param name="superset">The IEnumerable superset 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>
+            Helper class with properties and methods that supply
+            a number of constraints used in Asserts.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Contains.Item(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.Contains.Substring(System.String)">
+            <summary>
+            Returns a constraint that succeeds if the actual
+            value contains the substring supplied as an argument.
+            </summary>
+        </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.Guard">
+            <summary>
+            Class used to guard against unexpected argument values
+            by throwing an appropriate exception.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Guard.ArgumentNotNull(System.Object,System.String)">
+            <summary>
+            Throws an exception if an argument is null
+            </summary>
+            <param name="value">The value to be tested</param>
+            <param name="name">The name of the argument</param>
+        </member>
+        <member name="M:NUnit.Framework.Guard.ArgumentNotNullOrEmpty(System.String,System.String)">
+            <summary>
+            Throws an exception if a string argument is null or empty
+            </summary>
+            <param name="value">The value to be tested</param>
+            <param name="name">The name of the argument</param>
+        </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.Exactly(System.Int32)">
+            <summary>
+            Returns a ConstraintExpression, which will apply
+            the following constraint to all members of a collection,
+            succeeding only if a specified number of them succeed.
+            </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 regular expression 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 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``1(``0,``0)">
+            <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.Positive">
+            <summary>
+            Returns a constraint that tests for a positive value
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Is.Negative">
+            <summary>
+            Returns a constraint that tests for a negative value
+            </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.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.HasExpectedResult">
+            <summary>
+            Indicates whether a result has been specified.
+            This is necessary because the result may be
+            null, so it's value cannot be checked.
+            </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.Explicit">
+            <summary>
+            Gets a value indicating whether this <see cref="T:NUnit.Framework.ITestCaseData"/> is explicit.
+            </summary>
+            <value><c>true</c> if explicit; 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="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 attribute 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.expectedResult">
+            <summary>
+            The expected result to be returned
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.TestCaseData.hasExpectedResult">
+            <summary>
+            Set to true if this has an expected result
+            </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.isExplicit">
+            <summary>
+            If true, indicates that the test case is marked explicit
+            </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="M:NUnit.Framework.TestCaseData.MakeExplicit">
+            <summary>
+            Marks this TestCase as Explicit
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseData.MakeExplicit(System.String)">
+            <summary>
+            Marks this TestCase as Explicit, 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.HasExpectedResult">
+            <summary>
+            Returns true if the result has been set
+            </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.Explicit">
+            <summary>
+            Gets a value indicating whether this <see cref="T:NUnit.Framework.ITestCaseData"/> is explicit.
+            </summary>
+            <value><c>true</c> if explicit; 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 directory containing the current test assembly.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestContext.WorkDirectory">
+            <summary>
+            Gets the directory to be used for outputing files created
+            by this test run.
+            </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.TestDetails">
+            <summary>
+            Provides details about a test
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.TestDetails.#ctor(System.Object,System.Reflection.MethodInfo,System.String,System.String,System.Boolean)">
+            <summary>
+             Creates an instance of TestDetails
+            </summary>
+            <param name="fixture">The fixture that the test is a member of, if available.</param>
+            <param name="method">The method that implements the test, if available.</param>
+            <param name="fullName">The full name of the test.</param>
+            <param name="type">A string representing the type of test, e.g. "Test Case".</param>
+            <param name="isSuite">Indicates if the test represents a suite of tests.</param>
+        </member>
+        <member name="P:NUnit.Framework.TestDetails.Fixture">
+            <summary>
+             The fixture that the test is a member of, if available.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestDetails.Method">
+            <summary>
+            The method that implements the test, if available.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestDetails.FullName">
+            <summary>
+            The full name of the test.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestDetails.Type">
+            <summary>
+            A string representing the type of test, e.g. "Test Case".
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestDetails.IsSuite">
+            <summary>
+            Indicates if the test represents a suite of tests.
+            </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="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.IEnumerable,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="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.IEnumerable,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>
+        <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>
+            SetUpAttribute is used in a TestFixture to identify a method
+            that is called immediately before each test is run. It is 
+            also used in a SetUpFixture to identify the method that is
+            called once, before any of the subordinate tests are run.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.SetUpFixtureAttribute">
+            <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.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 in a TestFixture to identify a method that is 
+            called immediately after each test is run. It is also used
+            in a SetUpFixture to identify the method that is called once,
+            after all subordinate tests have run. In either case, the method 
+            is guaranteed to be called, even if an exception is thrown.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.TestActionAttribute">
+            <summary>
+            Provide actions to execute before and after tests.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.ITestAction">
+            <summary>
+            When implemented by an attribute, this interface implemented to provide actions to execute before and after tests.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.ITestAction.BeforeTest(NUnit.Framework.TestDetails)">
+            <summary>
+            Executed before each test is run
+            </summary>
+            <param name="testDetails">Provides details about the test that is going to be run.</param>
+        </member>
+        <member name="M:NUnit.Framework.ITestAction.AfterTest(NUnit.Framework.TestDetails)">
+            <summary>
+            Executed after each test is run
+            </summary>
+            <param name="testDetails">Provides details about the test that has just been run.</param>
+        </member>
+        <member name="P:NUnit.Framework.ITestAction.Targets">
+            <summary>
+            Provides the target for the action attribute
+            </summary>
+            <returns>The target for the action attribute</returns>
+        </member>
+        <member name="M:NUnit.Framework.TestActionAttribute.BeforeTest(NUnit.Framework.TestDetails)">
+            <summary>
+            Method called before each test
+            </summary>
+            <param name="testDetails">Info about the test to be run</param>
+        </member>
+        <member name="M:NUnit.Framework.TestActionAttribute.AfterTest(NUnit.Framework.TestDetails)">
+            <summary>
+            Method called after each test
+            </summary>
+            <param name="testDetails">Info about the test that was just run</param>
+        </member>
+        <member name="P:NUnit.Framework.TestActionAttribute.Targets">
+            <summary>
+            Gets or sets the ActionTargets for this attribute
+            </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="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. Use
+            ExpectedResult by preference.
+            </summary>
+            <value>The result.</value>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseAttribute.ExpectedResult">
+            <summary>
+            Gets or sets the expected result.
+            </summary>
+            <value>The result.</value>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseAttribute.HasExpectedResult">
+            <summary>
+            Gets a flag indicating whether an expected
+            result has been set.
+            </summary>
+        </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.Explicit">
+            <summary>
+            Gets or sets the explicit status of the test
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseAttribute.Reason">
+            <summary>
+            Gets or sets the reason for not running the test
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.TestCaseAttribute.IgnoreReason">
+            <summary>
+            Gets or sets the reason for not running the test.
+            Set has the side effect of marking the test as ignored.
+            </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 data source, which must
+            be a property, field or method of the test class itself.
+            </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)">
+            <summary>
+            Construct with a Type, which must implement IEnumerable
+            </summary>
+            <param name="sourceType">The Type that will provide data</param>
+        </member>
+        <member name="M:NUnit.Framework.TestCaseSourceAttribute.#ctor(System.Type,System.String)">
+            <summary>
+            Construct with a Type and name.
+            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="P:NUnit.Framework.TestCaseSourceAttribute.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="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>
+            Used 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.AllItemsConstraint">
+            <summary>
+            AllItemsConstraint applies another constraint to each
+            item in a collection, succeeding if they all succeed.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.PrefixConstraint">
+            <summary>
+            Abstract base class used for prefixes
+            </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``1(NUnit.Framework.Constraints.ActualValueDelegate{``0})">
+            <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 <see cref="T:NUnit.Framework.Constraints.ActualValueDelegate`1"/></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="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.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.AndConstraint">
+            <summary>
+            AndConstraint succeeds only if both members succeed.
+            </summary>
+        </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="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.AssignableFromConstraint">
+            <summary>
+            AssignableFromConstraint is used to test that an object
+            can be assigned from a given Type.
+            </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="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.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="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.AttributeExistsConstraint">
+            <summary>
+            AttributeExistsConstraint tests for the presence of a
+            specified attribute on  a Type.
+            </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.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.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.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.CollectionContainsConstraint">
+            <summary>
+            CollectionContainsConstraint is used to test whether a collection
+            contains an expected object as a member.
+            </summary>
+        </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(NUnit.Framework.Constraints.EqualityAdapter)">
+            <summary>
+            Flag the constraint to use the supplied EqualityAdapter.
+            NOTE: For internal use only.
+            </summary>
+            <param name="adapter">The EqualityAdapter to use.</param>
+            <returns>Self.</returns>
+        </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="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.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.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.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. This class supplies the Using modifiers.
+            </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)">
+            <summary>
+            Initializes a new instance of the <see cref="T:ComparisonConstraint"/> class.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.#ctor(System.Object,System.Object)">
+            <summary>
+            Initializes a new instance of the <see cref="T:ComparisonConstraint"/> class.
+            </summary>
+        </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.ActualValueDelegate`1">
+            <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 
+            ConstraintExpression class, which represents a 
+            compound constraint in the process of being constructed 
+            from a series of syntactic elements.
+            
+            NOTE: ConstraintExpressionBase is separate because the
+            ConstraintExpression class was generated in earlier
+            versions of NUnit. The two classes may be combined
+            in a future version.
+            </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.Exactly(System.Int32)">
+            <summary>
+            Returns a ConstraintExpression, which will apply
+            the following constraint to all members of a collection,
+            succeeding only if a specified number of them succeed.
+            </summary>
+        </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.IResolveConstraint)">
+            <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 regular expression 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 regular expression 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``1(``0,``0)">
+            <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.Positive">
+            <summary>
+            Returns a constraint that tests for a positive value
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Negative">
+            <summary>
+            Returns a constraint that tests for a negative value
+            </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.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:NUnit.Framework.Constraints.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``1(NUnit.Framework.Constraints.ActualValueDelegate{``0})">
+            <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.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.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.EmptyDirectoryConstraint">
+            <summary>
+            EmptyDirectoryConstraint is used to test that a directory is empty
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EmptyDirectoryConstraint.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.EmptyDirectoryConstraint.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.EmptyDirectoryConstraint.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.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.EndsWithConstraint">
+            <summary>
+            EndsWithConstraint can test whether a string ends
+            with an expected substring.
+            </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="M:NUnit.Framework.Constraints.StringConstraint.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.StringConstraint.Matches(System.String)">
+            <summary>
+            Test whether the constraint is satisfied by a given string
+            </summary>
+            <param name="actual">The string to be tested</param>
+            <returns>True for success, false for failure</returns>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.StringConstraint.IgnoreCase">
+            <summary>
+            Modify the constraint to ignore case in matching.
+            </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.String)">
+            <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.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.DisplayTypesAndSizes(NUnit.Framework.Constraints.MessageWriter,System.Collections.IEnumerable,System.Collections.IEnumerable,System.Int32)">
+            <summary>
+            Displays a single line showing the types and sizes of the expected
+            and actual enumerations, 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.IEnumerable,System.Collections.IEnumerable,NUnit.Framework.Constraints.FailurePoint,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="M:NUnit.Framework.Constraints.EqualConstraint.DisplayEnumerableDifferences(NUnit.Framework.Constraints.MessageWriter,System.Collections.IEnumerable,System.Collections.IEnumerable,System.Int32)">
+            <summary>
+            Display the failure information for two IEnumerables that did not match.
+            </summary>
+            <param name="writer">The MessageWriter on which to display</param>
+            <param name="expected">The expected enumeration.</param>
+            <param name="actual">The actual enumeration</param>
+            <param name="depth">The depth of this failure in a set of nested collections</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.AreEqual(System.Object,System.Object)">
+            <summary>
+            Compares two objects, returning true if they are equal
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualityAdapter.CanCompare(System.Object,System.Object)">
+            <summary>
+            Returns true if the two objects can be compared by this adapter.
+            The base adapter cannot handle IEnumerables except for strings.
+            </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.EqualityAdapter.ComparerAdapter">
+            <summary>
+            EqualityAdapter that wraps an IComparer.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.EqualityAdapter.GenericEqualityAdapter`1.CanCompare(System.Object,System.Object)">
+            <summary>
+            Returns true if the two objects can be compared by this adapter.
+            Generic adapter requires objects of the specified type.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.EqualityAdapter.ComparerAdapter`1">
+            <summary>
+            EqualityAdapter that wraps an IComparer.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.EqualityAdapterList">
+            <summary>
+            EqualityAdapterList represents a list of EqualityAdapters
+            in a common class across platforms.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.ExactCountConstraint">
+            <summary>
+            ExactCountConstraint applies another constraint to each
+            item in a collection, succeeding only if a specified
+            number of items succeed.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ExactCountConstraint.#ctor(System.Int32,NUnit.Framework.Constraints.Constraint)">
+            <summary>
+            Construct an ExactCountConstraint on top of an existing constraint
+            </summary>
+            <param name="expectedCount"></param>
+            <param name="itemConstraint"></param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ExactCountConstraint.Matches(System.Object)">
+            <summary>
+            Apply the item constraint to each item in the collection,
+            succeeding only if the expected number of items pass.
+            </summary>
+            <param name="actual"></param>
+            <returns></returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ExactCountConstraint.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.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.ExceptionTypeConstraint">
+            <summary>
+            ExceptionTypeConstraint is a special version of ExactTypeConstraint
+            used to provided detailed info about the exception thrown in
+            an error message.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ExceptionTypeConstraint.#ctor(System.Type)">
+            <summary>
+            Constructs an ExceptionTypeConstraint
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ExceptionTypeConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+            <summary>
+            Write the actual value for a failing constraint test to a
+            MessageWriter. Overriden to write additional information 
+            in the case of an Exception.
+            </summary>
+            <param name="writer">The MessageWriter to use</param>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.FailurePoint">
+            <summary>
+            FailurePoint class represents one point of failure
+            in an equality test.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.FailurePoint.Position">
+            <summary>
+            The location of the failure
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.FailurePoint.ExpectedValue">
+            <summary>
+            The expected value
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.FailurePoint.ActualValue">
+            <summary>
+            The actual value
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.FailurePoint.ExpectedHasData">
+            <summary>
+            Indicates whether the expected value is valid
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.FailurePoint.ActualHasData">
+            <summary>
+            Indicates whether the actual value is valid
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.FailurePointList">
+            <summary>
+            FailurePointList represents a set of FailurePoints
+            in a cross-platform way.
+            </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.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.GreaterThanConstraint">
+            <summary>
+            Tests whether a value is greater than the value supplied to its constructor
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.GreaterThanConstraint.expected">
+            <summary>
+            The value against which a comparison is to be made
+            </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="M:NUnit.Framework.Constraints.GreaterThanConstraint.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.GreaterThanConstraint.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="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="F:NUnit.Framework.Constraints.GreaterThanOrEqualConstraint.expected">
+            <summary>
+            The value against which a comparison is to be made
+            </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="M:NUnit.Framework.Constraints.GreaterThanOrEqualConstraint.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.GreaterThanOrEqualConstraint.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="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.LessThanConstraint">
+            <summary>
+            Tests whether a value is less than the value supplied to its constructor
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.LessThanConstraint.expected">
+            <summary>
+            The value against which a comparison is to be made
+            </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="M:NUnit.Framework.Constraints.LessThanConstraint.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.LessThanConstraint.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="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="F:NUnit.Framework.Constraints.LessThanOrEqualConstraint.expected">
+            <summary>
+            The value against which a comparison is to be made
+            </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="M:NUnit.Framework.Constraints.LessThanOrEqualConstraint.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.LessThanOrEqualConstraint.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="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.IEnumerable,System.Int32)">
+            <summary>
+            Get an array of indices representing the point in a enumerable, 
+            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.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.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 NoItemConstraint 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.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:NUnit.Framework.Constraints.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.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.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.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.NUnitComparer`1">
+            <summary>
+            Generic version of NUnitComparer
+            </summary>
+            <typeparam name="T"></typeparam>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NUnitComparer`1.Compare(`0,`0)">
+            <summary>
+            Compare two objects of the same type
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.NUnitEqualityComparer">
+            <summary>
+            NUnitEqualityComparer encapsulates NUnit's handling of
+            equality tests between objects.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.INUnitEqualityComparer">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.INUnitEqualityComparer.AreEqual(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance@)">
+            <summary>
+            Compares two objects for equality within a tolerance
+            </summary>
+            <param name="x">The first object to compare</param>
+            <param name="y">The second object to compare</param>
+            <param name="tolerance">The tolerance to use in the comparison</param>
+            <returns></returns>
+        </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.externalComparers">
+            <summary>
+            Comparison objects used in comparisons for some constraints.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.failurePoints">
+            <summary>
+            List of points at which a failure occured.
+            </summary>
+        </member>
+        <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.recursionDetector">
+            <summary>
+            RecursionDetector used to check for recursion when
+            evaluating self-referencing enumerables.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NUnitEqualityComparer.AreEqual(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance@)">
+            <summary>
+            Compares two objects for equality within a tolerance, setting
+            the tolerance to the actual tolerance used if an empty
+            tolerance is supplied.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NUnitEqualityComparer.ArraysEqual(System.Array,System.Array,NUnit.Framework.Constraints.Tolerance@)">
+            <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="expected">first directory to compare</param>
+            <param name="actual">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.ExternalComparers">
+            <summary>
+            Gets the list of external comparers to be used to
+            test for equality. They are applied to members of
+            collections, in place of NUnit's own logic.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.FailurePoints">
+            <summary>
+            Gets the list of failure points for the last Match performed.
+            The list consists of objects to be interpreted by the caller.
+            This generally means that the caller may only make use of
+            objects it has placed on the list at a particular depthy.
+            </summary>
+        </member>
+        <member name="T:NUnit.Framework.Constraints.NUnitEqualityComparer.RecursionDetector">
+            <summary>
+            RecursionDetector detects when a comparison
+            between two enumerables has reached a point
+            where the same objects that were previously
+            compared are again being compared. This allows
+            the caller to stop the comparison if desired.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.NUnitEqualityComparer.RecursionDetector.CheckRecursion(System.Collections.IEnumerable,System.Collections.IEnumerable)">
+            <summary>
+            Check whether two objects have previously
+            been compared, returning true if they have.
+            The two objects are remembered, so that a
+            second call will always return true.
+            </summary>
+        </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.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.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="expectedPath">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>
+            Transform the provided path to its canonical form so that it 
+            may be more easily be compared with other paths.
+            </summary>
+            <param name="path">The original path</param>
+            <returns>The path in canonical form</returns>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.PathConstraint.IsSubPath(System.String,System.String,System.Boolean)">
+            <summary>
+            Test whether one path in canonical form is under another.
+            </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="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.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.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.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.RangeConstraint`1">
+            <summary>
+            RangeConstraint tests whether two values are within a 
+            specified range.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.RangeConstraint`1.#ctor(`0,`0)">
+            <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`1.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`1.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.String)">
+            <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.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="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.op_BitwiseAnd(NUnit.Framework.Constraints.ResolvableConstraintExpression,NUnit.Framework.Constraints.ResolvableConstraintExpression)">
+            <summary>
+            This operator creates a constraint that is satisfied only if both 
+            argument constraints are satisfied.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.op_BitwiseAnd(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.ResolvableConstraintExpression)">
+            <summary>
+            This operator creates a constraint that is satisfied only if both 
+            argument constraints are satisfied.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.op_BitwiseAnd(NUnit.Framework.Constraints.ResolvableConstraintExpression,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.ResolvableConstraintExpression.op_BitwiseOr(NUnit.Framework.Constraints.ResolvableConstraintExpression,NUnit.Framework.Constraints.ResolvableConstraintExpression)">
+            <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.ResolvableConstraintExpression.op_BitwiseOr(NUnit.Framework.Constraints.ResolvableConstraintExpression,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.ResolvableConstraintExpression.op_BitwiseOr(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.ResolvableConstraintExpression)">
+            <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.ResolvableConstraintExpression.op_LogicalNot(NUnit.Framework.Constraints.ResolvableConstraintExpression)">
+            <summary>
+            This operator creates a constraint that is satisfied if the 
+            argument constraint is not satisfied.
+            </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 constraint expression after 
+            resolving it so that it can be reused consistently.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ReusableConstraint.#ctor(NUnit.Framework.Constraints.IResolveConstraint)">
+            <summary>
+            Construct a ReusableConstraint from a constraint expression
+            </summary>
+            <param name="c">The expression to be resolved and reused</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ReusableConstraint.op_Implicit(NUnit.Framework.Constraints.Constraint)~NUnit.Framework.Constraints.ReusableConstraint">
+            <summary>
+            Converts a constraint to a ReusableConstraint
+            </summary>
+            <param name="c">The constraint to be converted</param>
+            <returns>A ReusableConstraint</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.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.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.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.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.String)">
+            <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.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.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.String)">
+            <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.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:NUnit.Framework.Constraints.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``1(NUnit.Framework.Constraints.ActualValueDelegate{``0})">
+            <summary>
+            Converts an ActualValueDelegate to a TestDelegate
+            before calling the primary overload.
+            </summary>
+        </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``1(NUnit.Framework.Constraints.ActualValueDelegate{``0})">
+            <summary>
+            Test whether the constraint is satisfied by a given delegate
+            </summary>
+            <param name="del">Delegate returning the value to be tested</param>
+            <returns>True if no exception is thrown, otherwise false</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. Overridden in ThrowsNothingConstraint to write 
+            information about the exception that was actually caught.
+            </summary>
+            <param name="writer">The writer on which the actual value is displayed</param>
+        </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 no tolerance. In most cases, it results
+            in an exact match but for floats and doubles a
+            default tolerance may be used.
+            </summary>
+        </member>
+        <member name="P:NUnit.Framework.Constraints.Tolerance.Zero">
+            <summary>
+            Returns a zero 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.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.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.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.XmlSerializableConstraint">
+            <summary>
+            XmlSerializableConstraint tests whether 
+            an object is serializable in XML 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.AllOperator">
+            <summary>
+            Represents a constraint that succeeds if all the 
+            members of a collection match a base constraint.
+            </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="T:NUnit.Framework.Constraints.PrefixOperator">
+            <summary>
+            PrefixOperator takes a single constraint and modifies
+            it's action in some way.
+            </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="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="M:NUnit.Framework.Constraints.CollectionOperator.#ctor">
+            <summary>
+            Constructs a CollectionOperator
+            </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.AndOperator">
+            <summary>
+            Operator that requires both it's arguments to succeed
+            </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="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.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="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="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.ExactCountOperator">
+            <summary>
+            Represents a constraint that succeeds if the specified 
+            count of members of a collection match a base constraint.
+            </summary>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ExactCountOperator.#ctor(System.Int32)">
+            <summary>
+            Construct an ExactCountOperator for a specified count
+            </summary>
+            <param name="expectedCount">The expected count</param>
+        </member>
+        <member name="M:NUnit.Framework.Constraints.ExactCountOperator.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.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.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.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.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.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.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.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.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.INUnitEqualityComparer`1">
+            <summary>
+            
+            </summary>
+            <typeparam name="T"></typeparam>
+        </member>
+        <member name="M:NUnit.Framework.INUnitEqualityComparer`1.AreEqual(`0,`0,NUnit.Framework.Constraints.Tolerance@)">
+            <summary>
+            Compares two objects of a given Type for equality within a tolerance
+            </summary>
+            <param name="x">The first object to compare</param>
+            <param name="y">The second object to compare</param>
+            <param name="tolerance">The tolerance to use in the comparison</param>
+            <returns></returns>
+        </member>
+    </members>
+</doc>
diff -r 2a8466f0cb8a -r 1c2a16d071a7 packages/NUnit.2.6.4/license.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/packages/NUnit.2.6.4/license.txt	Fri Apr 22 13:08:08 2016 +0300
@@ -0,0 +1,15 @@
+Copyright � 2002-2014 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-2014 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 -r 2a8466f0cb8a -r 1c2a16d071a7 packages/System.Text.Json.2.0.0.11/System.Text.Json.2.0.0.11.nupkg
Binary file packages/System.Text.Json.2.0.0.11/System.Text.Json.2.0.0.11.nupkg has changed
diff -r 2a8466f0cb8a -r 1c2a16d071a7 packages/System.Text.Json.2.0.0.11/lib/net40/System.Text.Json.dll
Binary file packages/System.Text.Json.2.0.0.11/lib/net40/System.Text.Json.dll has changed
diff -r 2a8466f0cb8a -r 1c2a16d071a7 packages/repositories.config
--- a/packages/repositories.config	Fri Feb 19 18:07:17 2016 +0300
+++ b/packages/repositories.config	Fri Apr 22 13:08:08 2016 +0300
@@ -1,4 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <repositories>
   <repository path="../Implab.Test/Implab.Format.Test/packages.config" />
+  <repository path="../MonoPlay/packages.config" />
 </repositories>
\ No newline at end of file