albacore 1.0.0.rc.2 → 1.0.0.rc.3

data/spec/support/TestSolution/TestSolution.vsmdi

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<TestLists xmlns="http://microsoft.com/schemas/VisualStudio/TeamTest/2010">
-  <TestList name="Lists of Tests" id="8c43106b-9dc1-4907-a29f-aa66a61bf5b6">
-    <RunConfiguration id="e3671143-2726-48d4-a12e-73c211aea02d" name="Local Test Run" storage="localtestrun.testrunconfig" type="Microsoft.VisualStudio.TestTools.Common.TestRunConfiguration, Microsoft.VisualStudio.QualityTools.Common,   PublicKeyToken=b03f5f7f11d50a3a" />
-  </TestList>
-</TestLists>

data/spec/support/TestSolution/TestSolution/Class1.cs

@@ -1,17 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace TestSolution
-{
-	public class Class1
-	{
-
-		public string Foo()
-		{
-			return "bar";
-		}
-
-	}
-}

data/spec/support/TestSolution/TestSolution/TestSolution.csproj

@@ -1,97 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>9.0.30729</ProductVersion>
-    <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{36F8C06F-3BBA-4D11-9333-83573A760284}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>TestSolution</RootNamespace>
-    <AssemblyName>TestSolution</AssemblyName>
-    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <FileUpgradeFlags>
-    </FileUpgradeFlags>
-    <OldToolsVersion>3.5</OldToolsVersion>
-    <UpgradeBackupLocation />
-    <PublishUrl>publish\</PublishUrl>
-    <Install>true</Install>
-    <InstallFrom>Disk</InstallFrom>
-    <UpdateEnabled>false</UpdateEnabled>
-    <UpdateMode>Foreground</UpdateMode>
-    <UpdateInterval>7</UpdateInterval>
-    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
-    <UpdatePeriodically>false</UpdatePeriodically>
-    <UpdateRequired>false</UpdateRequired>
-    <MapFileExtensions>true</MapFileExtensions>
-    <ApplicationRevision>0</ApplicationRevision>
-    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
-    <IsWebBootstrapper>false</IsWebBootstrapper>
-    <UseApplicationTrust>false</UseApplicationTrust>
-    <BootstrapperEnabled>true</BootstrapperEnabled>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="System" />
-    <Reference Include="System.Core">
-      <RequiredTargetFramework>3.5</RequiredTargetFramework>
-    </Reference>
-    <Reference Include="System.Xml.Linq">
-      <RequiredTargetFramework>3.5</RequiredTargetFramework>
-    </Reference>
-    <Reference Include="System.Data.DataSetExtensions">
-      <RequiredTargetFramework>3.5</RequiredTargetFramework>
-    </Reference>
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="Class1.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
-      <Visible>False</Visible>
-      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
-      <Install>false</Install>
-    </BootstrapperPackage>
-    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
-      <Visible>False</Visible>
-      <ProductName>.NET Framework 3.5 SP1</ProductName>
-      <Install>true</Install>
-    </BootstrapperPackage>
-    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
-      <Visible>False</Visible>
-      <ProductName>Windows Installer 3.1</ProductName>
-      <Install>true</Install>
-    </BootstrapperPackage>
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
-</Project>

data/spec/support/Tools/FluentMigrator-0.9/Migrate.exe.config

@@ -1,6 +0,0 @@
-<?xml version="1.0"?>
-<configuration>
-	<startup>
-		<supportedRuntime version="v2.0.50727"/>
-	</startup>
-</configuration>

data/spec/support/Tools/FluentMigrator-0.9/Moq.xml

@@ -1,3467 +0,0 @@
-<?xml version="1.0"?>
-<doc>
-    <assembly>
-        <name>Moq</name>
-    </assembly>
-    <members>
-        <member name="T:Moq.EmptyDefaultValueProvider">
-            <summary>
-            A <see cref="T:Moq.IDefaultValueProvider"/> that returns an empty default value 
-            for invocations that do not have setups or return values, with loose mocks.
-            This is the default behavior for a mock.
-            </summary>
-        </member>
-        <member name="T:Moq.IDefaultValueProvider">
-            <summary>
-            Interface to be implemented by classes that determine the 
-            default value of non-expected invocations.
-            </summary>
-        </member>
-        <member name="M:Moq.IDefaultValueProvider.ProvideDefault(System.Reflection.MethodInfo,System.Object[])">
-            <summary>
-            Provides a value for the given member and arguments.
-            </summary>
-            <param name="member">The member to provide a default 
-            value for.</param>
-            <param name="arguments">Optional arguments passed in 
-            to the call that requires a default value.</param>
-        </member>
-        <member name="T:Moq.Language.Flow.IReturnsResult`1">
-            <summary>
-            Implements the fluent API.
-            </summary>
-        </member>
-        <member name="T:Moq.Language.ICallback">
-            <summary>
-            Defines the <c>Callback</c> verb and overloads.
-            </summary>
-        </member>
-        <member name="T:Moq.IHideObjectMembers">
-            <summary>
-            Helper interface used to hide the base <see cref="T:System.Object"/> 
-            members from the fluent API to make it much cleaner 
-            in Visual Studio intellisense.
-            </summary>
-        </member>
-        <member name="M:Moq.IHideObjectMembers.GetType">
-            <summary/>
-        </member>
-        <member name="M:Moq.IHideObjectMembers.GetHashCode">
-            <summary/>
-        </member>
-        <member name="M:Moq.IHideObjectMembers.ToString">
-            <summary/>
-        </member>
-        <member name="M:Moq.IHideObjectMembers.Equals(System.Object)">
-            <summary/>
-        </member>
-        <member name="M:Moq.Language.ICallback.Callback(System.Action)">
-            <summary>
-            Specifies a callback to invoke when the method is called.
-            </summary>
-            <param name="action">Callback method to invoke.</param>
-            <example>
-            The following example specifies a callback to set a boolean 
-            value that can be used later:
-            <code>
-            bool called = false;
-            mock.Setup(x => x.Execute())
-                .Callback(() => called = true);
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Language.ICallback.Callback``1(System.Action{``0})">
-            <summary>
-            Specifies a callback to invoke when the method is called that receives the original
-            arguments.
-            </summary>
-            <typeparam name="T">Argument type of the invoked method.</typeparam>
-            <param name="action">Callback method to invoke.</param>
-            <example>
-            Invokes the given callback with the concrete invocation argument value. 
-            <para>
-            Notice how the specific string argument is retrieved by simply declaring 
-            it as part of the lambda expression for the callback:
-            </para>
-            <code>
-            mock.Setup(x => x.Execute(It.IsAny&lt;string&gt;()))
-                .Callback((string command) => Console.WriteLine(command));
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Language.ICallback.Callback``2(System.Action{``0,``1})">
-            <summary>
-            Specifies a callback to invoke when the method is called that receives the original
-            arguments.
-            </summary>
-            <typeparam name="T1">Type of the first argument of the invoked method.</typeparam>
-            <typeparam name="T2">Type of the second argument of the invoked method.</typeparam>
-            <param name="action">Callback method to invoke.</param>
-            <example>
-            Invokes the given callback with the concrete invocation arguments values. 
-            <para>
-            Notice how the specific arguments are retrieved by simply declaring 
-            them as part of the lambda expression for the callback:
-            </para>
-            <code>
-            mock.Setup(x => x.Execute(
-                                 It.IsAny&lt;string&gt;(), 
-                                 It.IsAny&lt;string&gt;()))
-                .Callback((string arg1, string arg2) => Console.WriteLine(arg1 + arg2));
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Language.ICallback.Callback``3(System.Action{``0,``1,``2})">
-            <summary>
-            Specifies a callback to invoke when the method is called that receives the original
-            arguments.
-            </summary>
-            <typeparam name="T1">Type of the first argument of the invoked method.</typeparam>
-            <typeparam name="T2">Type of the second argument of the invoked method.</typeparam>
-            <typeparam name="T3">Type of the third argument of the invoked method.</typeparam>
-            <param name="action">Callback method to invoke.</param>
-            <example>
-            Invokes the given callback with the concrete invocation arguments values. 
-            <para>
-            Notice how the specific arguments are retrieved by simply declaring 
-            them as part of the lambda expression for the callback:
-            </para>
-            <code>
-            mock.Setup(x => x.Execute(
-                                 It.IsAny&lt;string&gt;(), 
-                                 It.IsAny&lt;string&gt;(), 
-                                 It.IsAny&lt;int&gt;()))
-                .Callback((string arg1, string arg2, int arg3) => Console.WriteLine(arg1 + arg2 + arg3));
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Language.ICallback.Callback``4(System.Action{``0,``1,``2,``3})">
-            <summary>
-            Specifies a callback to invoke when the method is called that receives the original
-            arguments.
-            </summary>
-            <typeparam name="T1">Type of the first argument of the invoked method.</typeparam>
-            <typeparam name="T2">Type of the second argument of the invoked method.</typeparam>
-            <typeparam name="T3">Type of the third argument of the invoked method.</typeparam>
-            <typeparam name="T4">Type of the fourth argument of the invoked method.</typeparam>
-            <param name="action">Callback method to invoke.</param>
-            <example>
-            Invokes the given callback with the concrete invocation arguments values. 
-            <para>
-            Notice how the specific arguments are retrieved by simply declaring 
-            them as part of the lambda expression for the callback:
-            </para>
-            <code>
-            mock.Setup(x => x.Execute(
-                                 It.IsAny&lt;string&gt;(), 
-                                 It.IsAny&lt;string&gt;(), 
-                                 It.IsAny&lt;int&gt;(),
-                                 It.IsAny&lt;bool&gt;()))
-                .Callback((string arg1, string arg2, int arg3, bool arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4));
-            </code>
-            </example>
-        </member>
-        <member name="T:Moq.Language.IOccurrence">
-            <summary>
-            Defines occurrence members to constraint setups.
-            </summary>
-        </member>
-        <member name="M:Moq.Language.IOccurrence.AtMostOnce">
-            <summary>
-            The expected invocation can happen at most once.
-            </summary>
-            <example>
-            <code>
-            var mock = new Mock&lt;ICommand&gt;();
-            mock.Setup(foo => foo.Execute("ping"))
-                .AtMostOnce();
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Language.IOccurrence.AtMost(System.Int32)">
-            <summary>
-            The expected invocation can happen at most specified number of times.
-            </summary>
-            <param name="callCount">The number of times to accept calls.</param>
-            <example>
-            <code>
-            var mock = new Mock&lt;ICommand&gt;();
-            mock.Setup(foo => foo.Execute("ping"))
-                .AtMost( 5 );
-            </code>
-            </example>
-        </member>
-        <member name="T:Moq.Language.IRaise`1">
-            <summary>
-            Defines the <c>Raises</c> verb.
-            </summary>
-        </member>
-        <member name="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)">
-            <summary>
-            Specifies the event that will be raised 
-            when the setup is met.
-            </summary>
-            <param name="eventExpression">An expression that represents an event attach or detach action.</param>
-            <param name="args">The event arguments to pass for the raised event.</param>
-            <example>
-            The following example shows how to raise an event when 
-            the setup is met:
-            <code>
-            var mock = new Mock&lt;IContainer&gt;();
-            
-            mock.Setup(add => add.Add(It.IsAny&lt;string&gt;(), It.IsAny&lt;object&gt;()))
-                .Raises(add => add.Added += null, EventArgs.Empty);
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.Func{System.EventArgs})">
-            <summary>
-            Specifies the event that will be raised 
-            when the setup is matched.
-            </summary>
-            <param name="eventExpression">An expression that represents an event attach or detach action.</param>
-            <param name="func">A function that will build the <see cref="T:System.EventArgs"/> 
-            to pass when raising the event.</param>
-            <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/>
-        </member>
-        <member name="M:Moq.Language.IRaise`1.Raises``1(System.Action{`0},System.Func{``0,System.EventArgs})">
-            <summary>
-            Specifies the event that will be raised 
-            when the setup is matched.
-            </summary>
-            <param name="eventExpression">An expression that represents an event attach or detach action.</param>
-            <param name="func">A function that will build the <see cref="T:System.EventArgs"/> 
-            to pass when raising the event.</param>
-            <typeparam name="T1">Type of the argument received by the expected invocation.</typeparam>
-            <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/>
-        </member>
-        <member name="M:Moq.Language.IRaise`1.Raises``2(System.Action{`0},System.Func{``0,``1,System.EventArgs})">
-            <summary>
-            Specifies the event that will be raised 
-            when the setup is matched.
-            </summary>
-            <param name="eventExpression">An expression that represents an event attach or detach action.</param>
-            <param name="func">A function that will build the <see cref="T:System.EventArgs"/> 
-            to pass when raising the event.</param>
-            <typeparam name="T1">Type of the first argument received by the expected invocation.</typeparam>
-            <typeparam name="T2">Type of the second argument received by the expected invocation.</typeparam>
-            <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/>
-        </member>
-        <member name="M:Moq.Language.IRaise`1.Raises``3(System.Action{`0},System.Func{``0,``1,``2,System.EventArgs})">
-            <summary>
-            Specifies the event that will be raised 
-            when the setup is matched.
-            </summary>
-            <param name="eventExpression">An expression that represents an event attach or detach action.</param>
-            <param name="func">A function that will build the <see cref="T:System.EventArgs"/> 
-            to pass when raising the event.</param>
-            <typeparam name="T1">Type of the first argument received by the expected invocation.</typeparam>
-            <typeparam name="T2">Type of the second argument received by the expected invocation.</typeparam>
-            <typeparam name="T3">Type of the third argument received by the expected invocation.</typeparam>
-            <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/>
-        </member>
-        <member name="M:Moq.Language.IRaise`1.Raises``4(System.Action{`0},System.Func{``0,``1,``2,``3,System.EventArgs})">
-            <summary>
-            Specifies the event that will be raised 
-            when the setup is matched.
-            </summary>
-            <param name="eventExpression">An expression that represents an event attach or detach action.</param>
-            <param name="func">A function that will build the <see cref="T:System.EventArgs"/> 
-            to pass when raising the event.</param>
-            <typeparam name="T1">Type of the first argument received by the expected invocation.</typeparam>
-            <typeparam name="T2">Type of the second argument received by the expected invocation.</typeparam>
-            <typeparam name="T3">Type of the third argument received by the expected invocation.</typeparam>
-            <typeparam name="T4">Type of the fourth argument received by the expected invocation.</typeparam>
-            <seealso cref="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.EventArgs)"/>
-        </member>
-        <member name="M:Moq.Language.IRaise`1.Raises(System.Action{`0},System.Object[])">
-            <summary>
-            Specifies the custom event that will be raised 
-            when the setup is matched.
-            </summary>
-            <param name="eventExpression">An expression that represents an event attach or detach action.</param>
-            <param name="args">The arguments to pass to the custom delegate (non EventHandler-compatible).</param>
-        </member>
-        <member name="T:Moq.Language.IRaise">
-            <summary>
-            Defines the <c>Raises</c> verb.
-            </summary>
-        </member>
-        <member name="M:Moq.Language.IRaise.Raises(Moq.MockedEvent,System.EventArgs)">
-            <summary>
-            Specifies the mocked event that will be raised 
-            when the setup is met.
-            </summary>
-            <param name="eventHandler">The mocked event, retrieved from 
-            <see cref="M:Moq.Mock.CreateEventHandler"/> or <see cref="M:Moq.Mock.CreateEventHandler``1"/>.
-            </param>
-            <param name="args">The event args to pass when raising the event.</param>
-            <example>
-            The following example shows how to raise an event when 
-            the setup is met:
-            <code>
-            var mock = new Mock&lt;IContainer&gt;();
-            // create handler to associate with the event to raise
-            var handler = mock.CreateEventHandler();
-            // associate the handler with the event to raise
-            mock.Object.Added += handler;
-            // setup the invocation and the handler to raise
-            mock.Setup(add =&gt; add.Add(It.IsAny&lt;string&gt;(), It.IsAny&lt;object&gt;()))
-                .Raises(handler, EventArgs.Empty);
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Language.IRaise.Raises(Moq.MockedEvent,System.Func{System.EventArgs})">
-            <summary>
-            Specifies the mocked event that will be raised 
-            when the setup is matched.
-            </summary>
-            <param name="eventHandler">The mocked event, retrieved from 
-            <see cref="M:Moq.Mock.CreateEventHandler"/> or <see cref="M:Moq.Mock.CreateEventHandler``1"/>.
-            </param>
-            <param name="func">A function that will build the <see cref="T:System.EventArgs"/> 
-            to pass when raising the event.</param>
-            <seealso cref="M:Moq.Language.IRaise.Raises(Moq.MockedEvent,System.EventArgs)"/>
-        </member>
-        <member name="M:Moq.Language.IRaise.Raises``1(Moq.MockedEvent,System.Func{``0,System.EventArgs})">
-            <summary>
-            Specifies the mocked event that will be raised 
-            when the setup is matched.
-            </summary>
-            <param name="eventHandler">The mocked event, retrieved from 
-            <see cref="M:Moq.Mock.CreateEventHandler"/> or <see cref="M:Moq.Mock.CreateEventHandler``1"/>.
-            </param>
-            <param name="func">A function that will build the <see cref="T:System.EventArgs"/> 
-            to pass when raising the event.</param>
-            <typeparam name="T">Type of the argument received by the expected invocation.</typeparam>
-            <seealso cref="M:Moq.Language.IRaise.Raises(Moq.MockedEvent,System.EventArgs)"/>
-        </member>
-        <member name="M:Moq.Language.IRaise.Raises``2(Moq.MockedEvent,System.Func{``0,``1,System.EventArgs})">
-            <summary>
-            Specifies the mocked event that will be raised 
-            when the setup is matched.
-            </summary>
-            <param name="eventHandler">The mocked event, retrieved from 
-            <see cref="M:Moq.Mock.CreateEventHandler"/> or <see cref="M:Moq.Mock.CreateEventHandler``1"/>.
-            </param>
-            <param name="func">A function that will build the <see cref="T:System.EventArgs"/> 
-            to pass when raising the event.</param>
-            <typeparam name="T1">Type of the first argument received by the expected invocation.</typeparam>
-            <typeparam name="T2">Type of the second argument received by the expected invocation.</typeparam>
-            <seealso cref="M:Moq.Language.IRaise.Raises(Moq.MockedEvent,System.EventArgs)"/>
-        </member>
-        <member name="M:Moq.Language.IRaise.Raises``3(Moq.MockedEvent,System.Func{``0,``1,``2,System.EventArgs})">
-            <summary>
-            Specifies the mocked event that will be raised 
-            when the setup is matched.
-            </summary>
-            <param name="eventHandler">The mocked event, retrieved from 
-            <see cref="M:Moq.Mock.CreateEventHandler"/> or <see cref="M:Moq.Mock.CreateEventHandler``1"/>.
-            </param>
-            <param name="func">A function that will build the <see cref="T:System.EventArgs"/> 
-            to pass when raising the event.</param>
-            <typeparam name="T1">Type of the first argument received by the expected invocation.</typeparam>
-            <typeparam name="T2">Type of the second argument received by the expected invocation.</typeparam>
-            <typeparam name="T3">Type of the third argument received by the expected invocation.</typeparam>
-            <seealso cref="M:Moq.Language.IRaise.Raises(Moq.MockedEvent,System.EventArgs)"/>
-        </member>
-        <member name="M:Moq.Language.IRaise.Raises``4(Moq.MockedEvent,System.Func{``0,``1,``2,``3,System.EventArgs})">
-            <summary>
-            Specifies the mocked event that will be raised 
-            when the setup is matched.
-            </summary>
-            <param name="eventHandler">The mocked event, retrieved from 
-            <see cref="M:Moq.Mock.CreateEventHandler"/> or <see cref="M:Moq.Mock.CreateEventHandler``1"/>.
-            </param>
-            <param name="func">A function that will build the <see cref="T:System.EventArgs"/> 
-            to pass when raising the event.</param>
-            <typeparam name="T1">Type of the first argument received by the expected invocation.</typeparam>
-            <typeparam name="T2">Type of the second argument received by the expected invocation.</typeparam>
-            <typeparam name="T3">Type of the third argument received by the expected invocation.</typeparam>
-            <typeparam name="T4">Type of the fourth argument received by the expected invocation.</typeparam>
-            <seealso cref="M:Moq.Language.IRaise.Raises(Moq.MockedEvent,System.EventArgs)"/>
-        </member>
-        <member name="T:Moq.Language.IVerifies">
-            <summary>
-            Defines the <c>Verifiable</c> verb.
-            </summary>
-        </member>
-        <member name="M:Moq.Language.IVerifies.Verifiable">
-            <summary>
-            Marks the expectation as verifiable, meaning that a call 
-            to <see cref="M:Moq.Mock.Verify"/> will check if this particular 
-            expectation was met.
-            </summary>
-            <example>
-            The following example marks the expectation as verifiable:
-            <code>
-            mock.Expect(x =&gt; x.Execute("ping"))
-                .Returns(true)
-                .Verifiable();
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Language.IVerifies.Verifiable(System.String)">
-            <summary>
-            Marks the expectation as verifiable, meaning that a call 
-            to <see cref="M:Moq.Mock.Verify"/> will check if this particular 
-            expectation was met, and specifies a message for failures.
-            </summary>
-            <example>
-            The following example marks the expectation as verifiable:
-            <code>
-            mock.Expect(x =&gt; x.Execute("ping"))
-                .Returns(true)
-                .Verifiable("Ping should be executed always!");
-            </code>
-            </example>
-        </member>
-        <member name="T:Moq.MatcherAttribute">
-            <summary>
-            Marks a method as a matcher, which allows complete replacement 
-            of the built-in <see cref="T:Moq.It"/> class with your own argument 
-            matching rules.
-            </summary>
-            <remarks>
-            <b>This feature has been deprecated in favor of the new 
-            and simpler <see cref="T:Moq.Match`1"/>.
-            </b>
-            <para>
-            The argument matching is used to determine whether a concrete 
-            invocation in the mock matches a given setup. This 
-            matching mechanism is fully extensible. 
-            </para>
-            <para>
-            There are two parts of a matcher: the compiler matcher 
-            and the runtime matcher.
-            <list type="bullet">
-            <item>
-            <term>Compiler matcher</term>
-            <description>Used to satisfy the compiler requirements for the 
-            argument. Needs to be a method optionally receiving any arguments 
-            you might need for the matching, but with a return type that 
-            matches that of the argument. 
-            <para>
-            Let's say I want to match a lists of orders that contains 
-            a particular one. I might create a compiler matcher like the following:
-            </para>
-            <code>
-            public static class Orders
-            {
-              [Matcher]
-              public static IEnumerable&lt;Order&gt; Contains(Order order)
-              {
-                return null;
-              }
-            }
-            </code>
-            Now we can invoke this static method instead of an argument in an 
-            invocation:
-            <code>
-            var order = new Order { ... };
-            var mock = new Mock&lt;IRepository&lt;Order&gt;&gt;();
-            
-            mock.Setup(x =&gt; x.Save(Orders.Contains(order)))
-                .Throws&lt;ArgumentException&gt;();
-            </code>
-            Note that the return value from the compiler matcher is irrelevant. 
-            This method will never be called, and is just used to satisfy the 
-            compiler and to signal Moq that this is not a method that we want 
-            to be invoked at runtime.
-            </description>
-            </item>
-            <item>
-            <term>Runtime matcher</term>
-            <description>
-            The runtime matcher is the one that will actually perform evaluation 
-            when the test is run, and is defined by convention to have the 
-            same signature as the compiler matcher, but where the return 
-            value is the first argument to the call, which contains the 
-            object received by the actual invocation at runtime:
-            <code>
-              public static bool Contains(IEnumerable&lt;Order&gt; orders, Order order)
-              {
-                return orders.Contains(order);
-              }
-            </code>
-            At runtime, the mocked method will be invoked with a specific 
-            list of orders. This value will be passed to this runtime 
-            matcher as the first argument, while the second argument is the 
-            one specified in the setup (<c>x.Save(Orders.Contains(order))</c>).
-            <para>
-            The boolean returned determines whether the given argument has been 
-            matched. If all arguments to the expected method are matched, then 
-            the setup matches and is evaluated.
-            </para>
-            </description>
-            </item>
-            </list>
-            </para>
-            Using this extensible infrastructure, you can easily replace the entire 
-            <see cref="T:Moq.It"/> set of matchers with your own. You can also avoid the 
-            typical (and annoying) lengthy expressions that result when you have 
-            multiple arguments that use generics.
-            </remarks>
-            <example>
-            The following is the complete example explained above:
-            <code>
-            public static class Orders
-            {
-              [Matcher]
-              public static IEnumerable&lt;Order&gt; Contains(Order order)
-              {
-                return null;
-              }
-              
-              public static bool Contains(IEnumerable&lt;Order&gt; orders, Order order)
-              {
-                return orders.Contains(order);
-              }
-            }
-            </code>
-            And the concrete test using this matcher:
-            <code>
-            var order = new Order { ... };
-            var mock = new Mock&lt;IRepository&lt;Order&gt;&gt;();
-            
-            mock.Setup(x =&gt; x.Save(Orders.Contains(order)))
-                .Throws&lt;ArgumentException&gt;();
-                
-            // use mock, invoke Save, and have the matcher filter.
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.ExpressionExtensions.ToLambda(System.Linq.Expressions.Expression)">
-            <summary>
-            Casts the expression to a lambda expression, removing 
-            a cast if there's any.
-            </summary>
-        </member>
-        <member name="M:Moq.ExpressionExtensions.ToMethodCall(System.Linq.Expressions.LambdaExpression)">
-            <summary>
-            Casts the body of the lambda expression to a <see cref="T:System.Linq.Expressions.MethodCallExpression"/>.
-            </summary>
-            <exception cref="T:System.ArgumentException">If the body is not a method call.</exception>
-        </member>
-        <member name="M:Moq.ExpressionExtensions.ToPropertyInfo(System.Linq.Expressions.LambdaExpression)">
-            <summary>
-            Converts the body of the lambda expression into the <see cref="T:System.Reflection.PropertyInfo"/> referenced by it.
-            </summary>
-        </member>
-        <member name="M:Moq.ExpressionExtensions.IsProperty(System.Linq.Expressions.LambdaExpression)">
-            <summary>
-            Checks whether the body of the lambda expression is a property access.
-            </summary>
-        </member>
-        <member name="M:Moq.ExpressionExtensions.IsProperty(System.Linq.Expressions.Expression)">
-            <summary>
-            Checks whether the expression is a property access.
-            </summary>
-        </member>
-        <member name="M:Moq.ExpressionExtensions.IsPropertyIndexer(System.Linq.Expressions.LambdaExpression)">
-            <summary>
-            Checks whether the body of the lambda expression is a property indexer, which is true 
-            when the expression is an <see cref="T:System.Linq.Expressions.MethodCallExpression"/> whose 
-            <see cref="P:System.Linq.Expressions.MethodCallExpression.Method"/> has <see cref="P:System.Reflection.MethodBase.IsSpecialName"/> 
-            equal to <see langword="true"/>.
-            </summary>
-        </member>
-        <member name="M:Moq.ExpressionExtensions.IsPropertyIndexer(System.Linq.Expressions.Expression)">
-            <summary>
-            Checks whether the expression is a property indexer, which is true 
-            when the expression is an <see cref="T:System.Linq.Expressions.MethodCallExpression"/> whose 
-            <see cref="P:System.Linq.Expressions.MethodCallExpression.Method"/> has <see cref="P:System.Reflection.MethodBase.IsSpecialName"/> 
-            equal to <see langword="true"/>.
-            </summary>
-        </member>
-        <member name="M:Moq.ExpressionExtensions.CastTo``1(System.Linq.Expressions.Expression)">
-            <summary>
-            Creates an expression that casts the given expression to the <typeparamref name="T"/> 
-            type.
-            </summary>
-        </member>
-        <member name="M:Moq.ExpressionExtensions.ToStringFixed(System.Linq.Expressions.Expression)">
-            <devdoc>
-            TODO: remove this code when https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=331583 
-            is fixed.
-            </devdoc>
-        </member>
-        <member name="T:Moq.ExpressionVisitor">
-            <summary>
-            Base class for visitors of expression trees.
-            </summary>
-            <remarks>
-            <para>Provides the functionality of the internal visitor base class that 
-            comes with Linq.</para>
-            <para>Matt's comments on the implementation:</para>
-            <para>
-            In this variant there is only one visitor class that dispatches calls to the general 
-            Visit function out to specific VisitXXX methods corresponding to different node types.  
-            Note not every node type gets it own method, for example all binary operators are 
-            treated in one VisitBinary method.  The nodes themselves do not directly participate 
-            in the visitation process. They are treated as just data. 
-            The reason for this is that the quantity of visitors is actually open ended. 
-            You can write your own. Therefore no semantics of visiting is coupled into the node classes.  
-            It’s all in the visitors.  The default visit behavior for node XXX is baked into the base 
-            class’s version of VisitXXX.
-            </para>
-            <para>
-            Another variant is that all VisitXXX methods return a node. 
-            The Expression tree nodes are immutable. In order to change the tree you must construct 
-            a new one. The default VisitXXX methods will construct a new node if any of its sub-trees change. 
-            If no changes are made then the same node is returned. That way if you make a change 
-            to a node (by making a new node) deep down in a tree, the rest of the tree is rebuilt 
-            automatically for you.
-            </para>
-            See: http://blogs.msdn.com/mattwar/archive/2007/07/31/linq-building-an-iqueryable-provider-part-ii.aspx.
-            </remarks>
-            <author>Matt Warren: http://blogs.msdn.com/mattwar</author>
-            <contributor>Documented by InSTEDD: http://www.instedd.org</contributor>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.#ctor">
-            <summary>
-            Default constructor used by derived visitors.
-            </summary>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.Visit(System.Linq.Expressions.Expression)">
-            <summary>
-            Visits the <see cref="T:System.Linq.Expressions.Expression"/>, determining which 
-            of the concrete Visit methods to call.
-            </summary>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitBinding(System.Linq.Expressions.MemberBinding)">
-            <summary>
-            Visits the generic <see cref="T:System.Linq.Expressions.MemberBinding"/>, determining and 
-            calling the appropriate Visit method according to the 
-            <see cref="P:System.Linq.Expressions.MemberBinding.BindingType"/>, which will result 
-            in calls to <see cref="M:Moq.ExpressionVisitor.VisitMemberAssignment(System.Linq.Expressions.MemberAssignment)"/>, 
-            <see cref="M:Moq.ExpressionVisitor.VisitMemberMemberBinding(System.Linq.Expressions.MemberMemberBinding)"/> or <see cref="M:Moq.ExpressionVisitor.VisitMemberListBinding(System.Linq.Expressions.MemberListBinding)"/>.
-            </summary>
-            <param name="binding"></param>
-            <returns></returns>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitElementInitializer(System.Linq.Expressions.ElementInit)">
-            <summary>
-            Visits the <see cref="T:System.Linq.Expressions.ElementInit"/> initializer by 
-            calling the <see cref="M:Moq.ExpressionVisitor.VisitExpressionList(System.Collections.ObjectModel.ReadOnlyCollection{System.Linq.Expressions.Expression})"/> for the 
-            <see cref="P:System.Linq.Expressions.ElementInit.Arguments"/>.
-            </summary>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitUnary(System.Linq.Expressions.UnaryExpression)">
-            <summary>
-            Visits the <see cref="T:System.Linq.Expressions.UnaryExpression"/> expression by 
-            calling <see cref="M:Moq.ExpressionVisitor.Visit(System.Linq.Expressions.Expression)"/> with the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand"/> expression.
-            </summary>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitBinary(System.Linq.Expressions.BinaryExpression)">
-            <summary>
-            Visits the <see cref="T:System.Linq.Expressions.BinaryExpression"/> by calling 
-            <see cref="M:Moq.ExpressionVisitor.Visit(System.Linq.Expressions.Expression)"/> with the <see cref="P:System.Linq.Expressions.BinaryExpression.Left"/>, 
-            <see cref="P:System.Linq.Expressions.BinaryExpression.Right"/> and <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion"/> 
-            expressions.
-            </summary>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitTypeIs(System.Linq.Expressions.TypeBinaryExpression)">
-            <summary>
-            Visits the <see cref="T:System.Linq.Expressions.TypeBinaryExpression"/> by calling 
-            <see cref="M:Moq.ExpressionVisitor.Visit(System.Linq.Expressions.Expression)"/> with the <see cref="P:System.Linq.Expressions.TypeBinaryExpression.Expression"/> 
-            expression.
-            </summary>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitConstant(System.Linq.Expressions.ConstantExpression)">
-            <summary>
-            Visits the <see cref="T:System.Linq.Expressions.ConstantExpression"/>, by default returning the
-            same <see cref="T:System.Linq.Expressions.ConstantExpression"/> without further behavior.
-            </summary>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitConditional(System.Linq.Expressions.ConditionalExpression)">
-            <summary>
-            Visits the <see cref="T:System.Linq.Expressions.ConditionalExpression"/> by calling 
-            <see cref="M:Moq.ExpressionVisitor.Visit(System.Linq.Expressions.Expression)"/> with the <see cref="P:System.Linq.Expressions.ConditionalExpression.Test"/>, 
-            <see cref="P:System.Linq.Expressions.ConditionalExpression.IfTrue"/> and <see cref="P:System.Linq.Expressions.ConditionalExpression.IfFalse"/> 
-            expressions.
-            </summary>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitParameter(System.Linq.Expressions.ParameterExpression)">
-            <summary>
-            Visits the <see cref="T:System.Linq.Expressions.ParameterExpression"/> returning it 
-            by default without further behavior.
-            </summary>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitMemberAccess(System.Linq.Expressions.MemberExpression)">
-            <summary>
-            Visits the <see cref="T:System.Linq.Expressions.MemberExpression"/> by calling 
-            <see cref="M:Moq.ExpressionVisitor.Visit(System.Linq.Expressions.Expression)"/> with the <see cref="P:System.Linq.Expressions.MemberExpression.Expression"/> 
-            expression.
-            </summary>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitMethodCall(System.Linq.Expressions.MethodCallExpression)">
-            <summary>
-            Visits the <see cref="T:System.Linq.Expressions.MethodCallExpression"/> by calling 
-            <see cref="M:Moq.ExpressionVisitor.Visit(System.Linq.Expressions.Expression)"/> with the <see cref="P:System.Linq.Expressions.MethodCallExpression.Object"/> expression, 
-            and then <see cref="M:Moq.ExpressionVisitor.VisitExpressionList(System.Collections.ObjectModel.ReadOnlyCollection{System.Linq.Expressions.Expression})"/> with the <see cref="P:System.Linq.Expressions.MethodCallExpression.Arguments"/>.
-            </summary>
-            <param name="m"></param>
-            <returns></returns>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitExpressionList(System.Collections.ObjectModel.ReadOnlyCollection{System.Linq.Expressions.Expression})">
-            <summary>
-            Visits the <see cref="T:System.Collections.ObjectModel.ReadOnlyCollection`1"/> by iterating 
-            the list and visiting each <see cref="T:System.Linq.Expressions.Expression"/> in it.
-            </summary>
-            <param name="original"></param>
-            <returns></returns>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitMemberAssignment(System.Linq.Expressions.MemberAssignment)">
-            <summary>
-            Visits the <see cref="T:System.Linq.Expressions.MemberAssignment"/> by calling 
-            <see cref="M:Moq.ExpressionVisitor.Visit(System.Linq.Expressions.Expression)"/> with the <see cref="P:System.Linq.Expressions.MemberAssignment.Expression"/> expression.
-            </summary>
-            <param name="assignment"></param>
-            <returns></returns>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitMemberMemberBinding(System.Linq.Expressions.MemberMemberBinding)">
-            <summary>
-            Visits the <see cref="T:System.Linq.Expressions.MemberMemberBinding"/> by calling 
-            <see cref="M:Moq.ExpressionVisitor.VisitBindingList(System.Collections.ObjectModel.ReadOnlyCollection{System.Linq.Expressions.MemberBinding})"/> with the <see cref="P:System.Linq.Expressions.MemberMemberBinding.Bindings"/>.
-            </summary>
-            <param name="binding"></param>
-            <returns></returns>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitMemberListBinding(System.Linq.Expressions.MemberListBinding)">
-            <summary>
-            Visits the <see cref="T:System.Linq.Expressions.MemberListBinding"/> by calling 
-            <see cref="M:Moq.ExpressionVisitor.VisitElementInitializerList(System.Collections.ObjectModel.ReadOnlyCollection{System.Linq.Expressions.ElementInit})"/> with the 
-            <see cref="P:System.Linq.Expressions.MemberListBinding.Initializers"/>.
-            </summary>
-            <param name="binding"></param>
-            <returns></returns>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitBindingList(System.Collections.ObjectModel.ReadOnlyCollection{System.Linq.Expressions.MemberBinding})">
-            <summary>
-            Visits the <see cref="T:System.Collections.ObjectModel.ReadOnlyCollection`1"/> by 
-            calling <see cref="M:Moq.ExpressionVisitor.VisitBinding(System.Linq.Expressions.MemberBinding)"/> for each <see cref="T:System.Linq.Expressions.MemberBinding"/> in the 
-            collection.
-            </summary>
-            <param name="original"></param>
-            <returns></returns>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitElementInitializerList(System.Collections.ObjectModel.ReadOnlyCollection{System.Linq.Expressions.ElementInit})">
-            <summary>
-            Visits the <see cref="T:System.Collections.ObjectModel.ReadOnlyCollection`1"/> by 
-            calling <see cref="M:Moq.ExpressionVisitor.VisitElementInitializer(System.Linq.Expressions.ElementInit)"/> for each 
-            <see cref="T:System.Linq.Expressions.ElementInit"/> in the collection.
-            </summary>
-            <param name="original"></param>
-            <returns></returns>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitLambda(System.Linq.Expressions.LambdaExpression)">
-            <summary>
-            Visits the <see cref="T:System.Linq.Expressions.LambdaExpression"/> by calling 
-            <see cref="M:Moq.ExpressionVisitor.Visit(System.Linq.Expressions.Expression)"/> with the <see cref="P:System.Linq.Expressions.LambdaExpression.Body"/> expression.
-            </summary>
-            <param name="lambda"></param>
-            <returns></returns>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitNew(System.Linq.Expressions.NewExpression)">
-            <summary>
-            Visits the <see cref="T:System.Linq.Expressions.NewExpression"/> by calling 
-            <see cref="M:Moq.ExpressionVisitor.VisitExpressionList(System.Collections.ObjectModel.ReadOnlyCollection{System.Linq.Expressions.Expression})"/> with the <see cref="P:System.Linq.Expressions.NewExpression.Arguments"/> 
-            expressions.
-            </summary>
-            <param name="nex"></param>
-            <returns></returns>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitMemberInit(System.Linq.Expressions.MemberInitExpression)">
-            <summary>
-            Visits the <see cref="T:System.Linq.Expressions.MemberInitExpression"/> by calling 
-            <see cref="M:Moq.ExpressionVisitor.VisitNew(System.Linq.Expressions.NewExpression)"/> with the <see cref="P:System.Linq.Expressions.MemberInitExpression.NewExpression"/> 
-            expression, then <see cref="M:Moq.ExpressionVisitor.VisitBindingList(System.Collections.ObjectModel.ReadOnlyCollection{System.Linq.Expressions.MemberBinding})"/> with the 
-            <see cref="P:System.Linq.Expressions.MemberInitExpression.Bindings"/>.
-            </summary>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitListInit(System.Linq.Expressions.ListInitExpression)">
-            <summary>
-            Visits the <see cref="T:System.Linq.Expressions.ListInitExpression"/> by calling 
-            <see cref="M:Moq.ExpressionVisitor.VisitNew(System.Linq.Expressions.NewExpression)"/> with the <see cref="P:System.Linq.Expressions.ListInitExpression.NewExpression"/> 
-            expression, and then <see cref="M:Moq.ExpressionVisitor.VisitElementInitializerList(System.Collections.ObjectModel.ReadOnlyCollection{System.Linq.Expressions.ElementInit})"/> with the 
-            <see cref="P:System.Linq.Expressions.ListInitExpression.Initializers"/>.
-            </summary>
-            <param name="init"></param>
-            <returns></returns>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitNewArray(System.Linq.Expressions.NewArrayExpression)">
-            <summary>
-            Visits the <see cref="T:System.Linq.Expressions.NewArrayExpression"/> by calling 
-            <see cref="M:Moq.ExpressionVisitor.VisitExpressionList(System.Collections.ObjectModel.ReadOnlyCollection{System.Linq.Expressions.Expression})"/> with the <see cref="P:System.Linq.Expressions.NewArrayExpression.Expressions"/> 
-            expressions.
-            </summary>
-            <param name="na"></param>
-            <returns></returns>
-        </member>
-        <member name="M:Moq.ExpressionVisitor.VisitInvocation(System.Linq.Expressions.InvocationExpression)">
-            <summary>
-            Visits the <see cref="T:System.Linq.Expressions.InvocationExpression"/> by calling 
-            <see cref="M:Moq.ExpressionVisitor.VisitExpressionList(System.Collections.ObjectModel.ReadOnlyCollection{System.Linq.Expressions.Expression})"/> with the <see cref="P:System.Linq.Expressions.InvocationExpression.Arguments"/> 
-            expressions.
-            </summary>
-            <param name="iv"></param>
-            <returns></returns>
-        </member>
-        <member name="T:Moq.Evaluator">
-            <summary>
-            Provides partial evaluation of subtrees, whenever they can be evaluated locally.
-            </summary>
-            <author>Matt Warren: http://blogs.msdn.com/mattwar</author>
-            <contributor>Documented by InSTEDD: http://www.instedd.org</contributor>
-        </member>
-        <member name="M:Moq.Evaluator.PartialEval(System.Linq.Expressions.Expression,System.Func{System.Linq.Expressions.Expression,System.Boolean})">
-            <summary>
-            Performs evaluation and replacement of independent sub-trees
-            </summary>
-            <param name="expression">The root of the expression tree.</param>
-            <param name="fnCanBeEvaluated">A function that decides whether a given expression
-            node can be part of the local function.</param>
-            <returns>A new tree with sub-trees evaluated and replaced.</returns>
-        </member>
-        <member name="M:Moq.Evaluator.PartialEval(System.Linq.Expressions.Expression)">
-            <summary>
-            Performs evaluation and replacement of independent sub-trees
-            </summary>
-            <param name="expression">The root of the expression tree.</param>
-            <returns>A new tree with sub-trees evaluated and replaced.</returns>
-        </member>
-        <member name="T:Moq.Evaluator.SubtreeEvaluator">
-            <summary>
-            Evaluates and replaces sub-trees when first candidate is reached (top-down)
-            </summary>
-        </member>
-        <member name="T:Moq.Evaluator.Nominator">
-            <summary>
-            Performs bottom-up analysis to determine which nodes can possibly
-            be part of an evaluated sub-tree.
-            </summary>
-        </member>
-        <member name="M:Guard.ArgumentNotNull(System.Object,System.String)">
-            <summary>
-            Checks an argument to ensure it isn't null.
-            </summary>
-            <param name="value">The argument value to check.</param>
-            <param name="argumentName">The name of the argument.</param>
-        </member>
-        <member name="M:Guard.ArgumentNotNullOrEmptyString(System.String,System.String)">
-            <summary>
-            Checks a string argument to ensure it isn't null or empty.
-            </summary>
-            <param name="argumentValue">The argument value to check.</param>
-            <param name="argumentName">The name of the argument.</param>
-        </member>
-        <member name="M:Guard.ArgumentNotOutOfRangeInclusive``1(``0,``0,``0,System.String)">
-            <summary>
-            Checks an argument to ensure it is in the specified range including the edges.
-            </summary>
-            <typeparam name="T">Type of the argument to check, it must be an <see cref="T:System.IComparable"/> type.
-            </typeparam>
-            <param name="value">The argument value to check.</param>
-            <param name="from">The minimun allowed value for the argument.</param>
-            <param name="to">The maximun allowed value for the argument.</param>
-            <param name="argumentName">The name of the argument.</param>
-        </member>
-        <member name="M:Guard.ArgumentNotOutOfRangeExclusive``1(``0,``0,``0,System.String)">
-            <summary>
-            Checks an argument to ensure it is in the specified range excluding the edges.
-            </summary>
-            <typeparam name="T">Type of the argument to check, it must be an <see cref="T:System.IComparable"/> type.
-            </typeparam>
-            <param name="value">The argument value to check.</param>
-            <param name="from">The minimun allowed value for the argument.</param>
-            <param name="to">The maximun allowed value for the argument.</param>
-            <param name="argumentName">The name of the argument.</param>
-        </member>
-        <member name="T:Moq.Language.IReturnsGetter`2">
-            <summary>
-            Defines the <c>Returns</c> verb for property get setups.
-            </summary>
-            <typeparam name="TMock">Mocked type.</typeparam>
-            <typeparam name="TProperty">Type of the property.</typeparam>
-        </member>
-        <member name="M:Moq.Language.IReturnsGetter`2.Returns(`1)">
-            <summary>
-            Specifies the value to return.
-            </summary>
-            <param name="value">The value to return, or <see langword="null"/>.</param>
-            <example>
-            Return a <c>true</c> value from the property getter call:
-            <code>
-            mock.SetupGet(x => x.Suspended)
-                .Returns(true);
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Language.IReturnsGetter`2.Returns(System.Func{`1})">
-            <summary>
-            Specifies a function that will calculate the value to return for the property.
-            </summary>
-            <param name="valueFunction">The function that will calculate the return value.</param>
-            <example>
-            Return a calculated value when the property is retrieved:
-            <code>
-            mock.SetupGet(x => x.Suspended)
-                .Returns(() => returnValues[0]);
-            </code>
-            The lambda expression to retrieve the return value is lazy-executed, 
-            meaning that its value may change depending on the moment the property  
-            is retrieved and the value the <c>returnValues</c> array has at 
-            that moment.
-            </example>
-        </member>
-        <member name="T:Moq.Language.ICallbackGetter`2">
-            <summary>
-            Defines the <c>Callback</c> verb for property getter setups.
-            </summary>
-            <seealso cref="M:Moq.Mock`1.SetupGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"/>
-            <typeparam name="TMock">Mocked type.</typeparam>
-            <typeparam name="TProperty">Type of the property.</typeparam>
-        </member>
-        <member name="M:Moq.Language.ICallbackGetter`2.Callback(System.Action)">
-            <summary>
-            Specifies a callback to invoke when the property is retrieved.
-            </summary>
-            <param name="action">Callback method to invoke.</param>
-            <example>
-            Invokes the given callback with the property value being set. 
-            <code>
-            mock.SetupGet(x => x.Suspended)
-                .Callback(() => called = true)
-                .Returns(true);
-            </code>
-            </example>
-        </member>
-        <member name="T:Moq.Language.Flow.IThrowsResult">
-            <summary>
-            Implements the fluent API.
-            </summary>
-        </member>
-        <member name="T:Moq.Language.Flow.IReturnsThrows`2">
-            <summary>
-            Implements the fluent API.
-            </summary>
-        </member>
-        <member name="T:Moq.Language.IReturns`2">
-            <summary>
-            Defines the <c>Returns</c> verb.
-            </summary>
-            <typeparam name="TMock">Mocked type.</typeparam>
-            <typeparam name="TResult">Type of the return value from the expression.</typeparam>
-        </member>
-        <member name="M:Moq.Language.IReturns`2.Returns(`1)">
-            <summary>
-            Specifies the value to return.
-            </summary>
-            <param name="value">The value to return, or <see langword="null"/>.</param>
-            <example>
-            Return a <c>true</c> value from the method call:
-            <code>
-            mock.Setup(x => x.Execute("ping"))
-                .Returns(true);
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Language.IReturns`2.Returns(System.Func{`1})">
-            <summary>
-            Specifies a function that will calculate the value to return from the method.
-            </summary>
-            <param name="valueFunction">The function that will calculate the return value.</param>
-            <example group="returns">
-            Return a calculated value when the method is called:
-            <code>
-            mock.Setup(x => x.Execute("ping"))
-                .Returns(() => returnValues[0]);
-            </code>
-            The lambda expression to retrieve the return value is lazy-executed, 
-            meaning that its value may change depending on the moment the method 
-            is executed and the value the <c>returnValues</c> array has at 
-            that moment.
-            </example>
-        </member>
-        <member name="M:Moq.Language.IReturns`2.Returns``1(System.Func{``0,`1})">
-            <summary>
-            Specifies a function that will calculate the value to return from the method, 
-            retrieving the arguments for the invocation.
-            </summary>
-            <typeparam name="T">Type of the argument of the invoked method.</typeparam>
-            <param name="valueFunction">The function that will calculate the return value.</param>
-            <example group="returns">
-            Return a calculated value which is evaluated lazily at the time of the invocation.
-            <para>
-            The lookup list can change between invocations and the setup 
-            will return different values accordingly. Also, notice how the specific 
-            string argument is retrieved by simply declaring it as part of the lambda 
-            expression:
-            </para>
-            <code>
-            mock.Setup(x => x.Execute(It.IsAny&lt;string&gt;()))
-                .Returns((string command) => returnValues[command]);
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Language.IReturns`2.Returns``2(System.Func{``0,``1,`1})">
-            <summary>
-            Specifies a function that will calculate the value to return from the method, 
-            retrieving the arguments for the invocation.
-            </summary>
-            <typeparam name="T1">Type of the first argument of the invoked method.</typeparam>
-            <typeparam name="T2">Type of the second argument of the invoked method.</typeparam>
-            <param name="valueFunction">The function that will calculate the return value.</param>
-            <example group="returns">
-            Return a calculated value which is evaluated lazily at the time of the invocation.
-            <para>
-            The return value is calculated from the value of the actual method invocation arguments. 
-            Notice how the arguments are retrieved by simply declaring them as part of the lambda 
-            expression:
-            </para>
-            <code>
-            mock.Setup(x => x.Execute(
-                                It.IsAny&lt;string&gt;(), 
-                                It.IsAny&lt;string&gt;()))
-                .Returns((string arg1, string arg2) => arg1 + arg2);
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Language.IReturns`2.Returns``3(System.Func{``0,``1,``2,`1})">
-            <summary>
-            Specifies a function that will calculate the value to return from the method, 
-            retrieving the arguments for the invocation.
-            </summary>
-            <typeparam name="T1">Type of the first argument of the invoked method.</typeparam>
-            <typeparam name="T2">Type of the second argument of the invoked method.</typeparam>
-            <typeparam name="T3">Type of the third argument of the invoked method.</typeparam>
-            <param name="valueFunction">The function that will calculate the return value.</param>
-            <example group="returns">
-            Return a calculated value which is evaluated lazily at the time of the invocation.
-            <para>
-            The return value is calculated from the value of the actual method invocation arguments. 
-            Notice how the arguments are retrieved by simply declaring them as part of the lambda 
-            expression:
-            </para>
-            <code>
-            mock.Setup(x => x.Execute(
-                                 It.IsAny&lt;string&gt;(), 
-                                 It.IsAny&lt;string&gt;(), 
-                                 It.IsAny&lt;int&gt;()))
-                .Returns((string arg1, string arg2, int arg3) => arg1 + arg2 + arg3);
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Language.IReturns`2.Returns``4(System.Func{``0,``1,``2,``3,`1})">
-            <summary>
-            Specifies a function that will calculate the value to return from the method, 
-            retrieving the arguments for the invocation.
-            </summary>
-            <typeparam name="T1">Type of the first argument of the invoked method.</typeparam>
-            <typeparam name="T2">Type of the second argument of the invoked method.</typeparam>
-            <typeparam name="T3">Type of the third argument of the invoked method.</typeparam>
-            <typeparam name="T4">Type of the fourth argument of the invoked method.</typeparam>
-            <param name="valueFunction">The function that will calculate the return value.</param>
-            <example group="returns">
-            Return a calculated value which is evaluated lazily at the time of the invocation.
-            <para>
-            The return value is calculated from the value of the actual method invocation arguments. 
-            Notice how the arguments are retrieved by simply declaring them as part of the lambda 
-            expression:
-            </para>
-            <code>
-            mock.Setup(x => x.Execute(
-                                  It.IsAny&lt;string&gt;(), 
-                                  It.IsAny&lt;string&gt;(), 
-                                  It.IsAny&lt;int&gt;(), 
-                                  It.IsAny&lt;bool&gt;()))
-                .Returns((string arg1, string arg2, int arg3, bool arg4) => arg1 + arg2 + arg3 + arg4);
-            </code>
-            </example>
-        </member>
-        <member name="T:Moq.Language.IThrows">
-            <summary>
-            Defines the <c>Throws</c> verb.
-            </summary>
-        </member>
-        <member name="M:Moq.Language.IThrows.Throws(System.Exception)">
-            <summary>
-            Specifies the exception to throw when the method is invoked.
-            </summary>
-            <param name="exception">Exception instance to throw.</param>
-            <example>
-            This example shows how to throw an exception when the method is 
-            invoked with an empty string argument:
-            <code>
-            mock.Setup(x =&gt; x.Execute(""))
-                .Throws(new ArgumentException());
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Language.IThrows.Throws``1">
-            <summary>
-            Specifies the type of exception to throw when the method is invoked.
-            </summary>
-            <typeparam name="TException">Type of exception to instantiate and throw when the setup is matched.</typeparam>
-            <example>
-            This example shows how to throw an exception when the method is 
-            invoked with an empty string argument:
-            <code>
-            mock.Setup(x =&gt; x.Execute(""))
-                .Throws&lt;ArgumentException&gt;();
-            </code>
-            </example>
-        </member>
-        <member name="T:Moq.Language.Flow.IReturnsThrowsGetter`2">
-            <summary>
-            Implements the fluent API.
-            </summary>
-        </member>
-        <member name="T:Moq.Language.Flow.ICallbackResult">
-            <summary>
-            Implements the fluent API.
-            </summary>
-        </member>
-        <member name="T:Moq.Language.ICallback`2">
-            <summary>
-            Defines the <c>Callback</c> verb and overloads for callbacks on 
-            setups that return a value.
-            </summary>
-            <typeparam name="TMock">Mocked type.</typeparam>
-            <typeparam name="TResult">Type of the return value of the setup.</typeparam>
-        </member>
-        <member name="M:Moq.Language.ICallback`2.Callback(System.Action)">
-            <summary>
-            Specifies a callback to invoke when the method is called.
-            </summary>
-            <param name="action">Callback method to invoke.</param>
-            <example>
-            The following example specifies a callback to set a boolean 
-            value that can be used later:
-            <code>
-            bool called = false;
-            mock.Setup(x => x.Execute())
-                .Callback(() => called = true)
-                .Returns(true);
-            </code>
-            Note that in the case of value-returning methods, after the <c>Callback</c> 
-            call you can still specify the return value.
-            </example>
-        </member>
-        <member name="M:Moq.Language.ICallback`2.Callback``1(System.Action{``0})">
-            <summary>
-            Specifies a callback to invoke when the method is called that receives the original
-            arguments.
-            </summary>
-            <typeparam name="T">Type of the argument of the invoked method.</typeparam>
-            <param name="action">Callback method to invoke.</param>
-            <example>
-            Invokes the given callback with the concrete invocation argument value. 
-            <para>
-            Notice how the specific string argument is retrieved by simply declaring 
-            it as part of the lambda expression for the callback:
-            </para>
-            <code>
-            mock.Setup(x => x.Execute(It.IsAny&lt;string&gt;()))
-                .Callback((string command) => Console.WriteLine(command))
-                .Returns(true);
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Language.ICallback`2.Callback``2(System.Action{``0,``1})">
-            <summary>
-            Specifies a callback to invoke when the method is called that receives the original
-            arguments.
-            </summary>
-            <typeparam name="T1">Type of the first argument of the invoked method.</typeparam>
-            <typeparam name="T2">Type of the second argument of the invoked method.</typeparam>
-            <param name="action">Callback method to invoke.</param>
-            <example>
-            Invokes the given callback with the concrete invocation arguments values. 
-            <para>
-            Notice how the specific arguments are retrieved by simply declaring 
-            them as part of the lambda expression for the callback:
-            </para>
-            <code>
-            mock.Setup(x => x.Execute(
-                                 It.IsAny&lt;string&gt;(), 
-                                 It.IsAny&lt;string&gt;()))
-                .Callback((string arg1, string arg2) => Console.WriteLine(arg1 + arg2))
-                .Returns(true);
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Language.ICallback`2.Callback``3(System.Action{``0,``1,``2})">
-            <summary>
-            Specifies a callback to invoke when the method is called that receives the original
-            arguments.
-            </summary>
-            <typeparam name="T1">Type of the first argument of the invoked method.</typeparam>
-            <typeparam name="T2">Type of the second argument of the invoked method.</typeparam>
-            <typeparam name="T3">Type of the third argument of the invoked method.</typeparam>
-            <param name="action">Callback method to invoke.</param>
-            <example>
-            Invokes the given callback with the concrete invocation arguments values. 
-            <para>
-            Notice how the specific arguments are retrieved by simply declaring 
-            them as part of the lambda expression for the callback:
-            </para>
-            <code>
-            mock.Setup(x => x.Execute(
-                                 It.IsAny&lt;string&gt;(), 
-                                 It.IsAny&lt;string&gt;(), 
-                                 It.IsAny&lt;int&gt;()))
-                .Callback((string arg1, string arg2, int arg3) => Console.WriteLine(arg1 + arg2 + arg3))
-                .Returns(true);
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Language.ICallback`2.Callback``4(System.Action{``0,``1,``2,``3})">
-            <summary>
-            Specifies a callback to invoke when the method is called that receives the original
-            arguments.
-            </summary>
-            <typeparam name="T1">Type of the first argument of the invoked method.</typeparam>
-            <typeparam name="T2">Type of the second argument of the invoked method.</typeparam>
-            <typeparam name="T3">Type of the third argument of the invoked method.</typeparam>
-            <typeparam name="T4">Type of the fourth argument of the invoked method.</typeparam>
-            <param name="action">Callback method to invoke.</param>
-            <example>
-            Invokes the given callback with the concrete invocation arguments values. 
-            <para>
-            Notice how the specific arguments are retrieved by simply declaring 
-            them as part of the lambda expression for the callback:
-            </para>
-            <code>
-            mock.Setup(x => x.Execute(
-                                 It.IsAny&lt;string&gt;(), 
-                                 It.IsAny&lt;string&gt;(), 
-                                 It.IsAny&lt;int&gt;(),
-                                 It.IsAny&lt;bool&gt;()))
-                .Callback((string arg1, string arg2, int arg3, bool arg4) => Console.WriteLine(arg1 + arg2 + arg3 + arg4))
-                .Returns(true);
-            </code>
-            </example>
-        </member>
-        <member name="T:Moq.IMocked`1">
-            <summary>
-            Implemented by all generated mock object instances.
-            </summary>
-        </member>
-        <member name="T:Moq.IMocked">
-            <summary>
-            Implemented by all generated mock object instances.
-            </summary>
-        </member>
-        <member name="P:Moq.IMocked.Mock">
-            <summary>
-            Reference the Mock that contains this as the <c>mock.Object</c> value.
-            </summary>
-        </member>
-        <member name="P:Moq.IMocked`1.Mock">
-            <summary>
-            Reference the Mock that contains this as the <c>mock.Object</c> value.
-            </summary>
-        </member>
-        <member name="T:Moq.Interceptor">
-            <summary>
-            Implements the actual interception and method invocation for 
-            all mocks.
-            </summary>
-        </member>
-        <member name="M:Moq.Interceptor.GetEventFromName(System.String)">
-            <summary>
-            Get an eventInfo for a given event name.  Search type ancestors depth first if necessary.
-            </summary>
-            <param name="eventName">Name of the event, with the set_ or get_ prefix already removed</param>
-        </member>
-        <member name="M:Moq.Interceptor.GetAncestorTypes(System.Type)">
-            <summary>
-            Given a type return all of its ancestors, both types and interfaces.
-            </summary>
-            <param name="initialType">The type to find immediate ancestors of</param>
-        </member>
-        <member name="T:Moq.Language.Flow.ISetup`1">
-            <summary>
-            Implements the fluent API.
-            </summary>
-        </member>
-        <member name="T:Moq.Language.INever">
-            <summary>
-            Defines the <c>Never</c> verb.
-            </summary>
-        </member>
-        <member name="M:Moq.Language.INever.Never">
-            <summary>
-            The expected invocation is never expected to happen.
-            </summary>
-            <example>
-            <code>
-            var mock = new Mock&lt;ICommand&gt;();
-            mock.Setup(foo =&gt; foo.Execute("ping"))
-                .Never();
-            </code>
-            </example>
-            <remarks>
-            <see cref="M:Moq.Language.INever.Never"/> is always verified inmediately as 
-            the invocations are performed, like strict mocks do 
-            with unexpected invocations.
-            </remarks>
-        </member>
-        <member name="T:Moq.Language.Flow.ISetup`2">
-            <summary>
-            Implements the fluent API.
-            </summary>
-        </member>
-        <member name="T:Moq.Language.Flow.ISetupGetter`2">
-            <summary>
-            Implements the fluent API.
-            </summary>
-        </member>
-        <member name="T:Moq.Language.Flow.ISetupSetter`2">
-            <summary>
-            Implements the fluent API.
-            </summary>
-        </member>
-        <member name="T:Moq.Language.ICallbackSetter`1">
-            <summary>
-            Defines the <c>Callback</c> verb for property setter setups.
-            </summary>
-            <typeparam name="TProperty">Type of the property.</typeparam>
-        </member>
-        <member name="M:Moq.Language.ICallbackSetter`1.Callback(System.Action{`0})">
-            <summary>
-            Specifies a callback to invoke when the property is set that receives the 
-            property value being set.
-            </summary>
-            <param name="action">Callback method to invoke.</param>
-            <example>
-            Invokes the given callback with the property value being set. 
-            <code>
-            mock.SetupSet(x => x.Suspended)
-                .Callback((bool state) => Console.WriteLine(state));
-            </code>
-            </example>
-        </member>
-        <member name="T:Moq.It">
-            <summary>
-			Allows the specification of a matching condition for an
-			argument in a method invocation, rather than a specific
-			argument value. "It" refers to the argument being matched.
-		</summary><remarks>
-			This class allows the setup to match a method invocation
-			with an arbitrary value, with a value in a specified range, or
-			even one that matches a given predicate.
-		</remarks>
-        </member>
-        <member name="M:Moq.It.IsAny``1">
-            <summary>
-			Matches any value of the given <paramref name="TValue"/> type.
-		</summary><remarks>
-			Typically used when the actual argument value for a method
-			call is not relevant.
-		</remarks><example>
-			<code>
-				// Throws an exception for a call to Remove with any string value.
-				mock.Setup(x =&gt; x.Remove(It.IsAny&lt;string&gt;())).Throws(new InvalidOperationException());
-			</code>
-		</example><typeparam name="TValue">Type of the value.</typeparam>
-        </member>
-        <member name="M:Moq.It.Is``1(System.Linq.Expressions.Expression{System.Predicate{``0}})">
-            <summary>
-			Matches any value that satisfies the given predicate.
-		</summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="match">The predicate used to match the method argument.</param><remarks>
-			Allows the specification of a predicate to perform matching
-			of method call arguments.
-		</remarks><example>
-			This example shows how to return the value <c>1</c> whenever the argument to the
-			<c>Do</c> method is an even number.
-			<code>
-				mock.Setup(x =&gt; x.Do(It.Is&lt;int&gt;(i =&gt; i % 2 == 0)))
-				.Returns(1);
-			</code>
-			This example shows how to throw an exception if the argument to the
-			method is a negative number:
-			<code>
-				mock.Setup(x =&gt; x.GetUser(It.Is&lt;int&gt;(i =&gt; i &lt; 0)))
-				.Throws(new ArgumentException());
-			</code>
-		</example>
-        </member>
-        <member name="M:Moq.It.IsInRange``1(``0,``0,Moq.Range)">
-            <summary>
-			Matches any value that is in the range specified.
-		</summary><typeparam name="TValue">Type of the argument to check.</typeparam><param name="from">The lower bound of the range.</param><param name="to">The upper bound of the range.</param><param name="rangeKind">
-			The kind of range. See <see cref="T:Moq.Range"/>.
-		</param><example>
-			The following example shows how to expect a method call
-			with an integer argument within the 0..100 range.
-			<code>
-				mock.Setup(x =&gt; x.HasInventory(
-				It.IsAny&lt;string&gt;(),
-				It.IsInRange(0, 100, Range.Inclusive)))
-				.Returns(false);
-			</code>
-		</example>
-        </member>
-        <member name="M:Moq.It.IsRegex(System.String)">
-            <summary>
-			Matches a string argument if it matches the given regular expression pattern.
-		</summary><param name="regex">The pattern to use to match the string argument value.</param><example>
-			The following example shows how to expect a call to a method where the
-			string argument matches the given regular expression:
-			<code>
-				mock.Setup(x =&gt; x.Check(It.IsRegex("[a-z]+"))).Returns(1);
-			</code>
-		</example>
-        </member>
-        <member name="M:Moq.It.IsRegex(System.String,System.Text.RegularExpressions.RegexOptions)">
-            <summary>
-			Matches a string argument if it matches the given regular expression pattern.
-		</summary><param name="regex">The pattern to use to match the string argument value.</param><param name="options">The options used to interpret the pattern.</param><example>
-			The following example shows how to expect a call to a method where the
-			string argument matches the given regular expression, in a case insensitive way:
-			<code>
-				mock.Setup(x =&gt; x.Check(It.IsRegex("[a-z]+", RegexOptions.IgnoreCase))).Returns(1);
-			</code>
-		</example>
-        </member>
-        <member name="T:Moq.Matchers.MatcherAttributeMatcher">
-            <summary>
-            Matcher to treat static functions as matchers.
-            
-            mock.Setup(x => x.StringMethod(A.MagicString()));
-            
-            pbulic static class A 
-            {
-                [Matcher]
-                public static string MagicString() { return null; }
-                public static bool MagicString(string arg)
-                {
-                    return arg == "magic";
-                }
-            }
-            
-            Will success if: mock.Object.StringMethod("magic");
-            and fail with any other call.
-            </summary>
-        </member>
-        <member name="T:Moq.MethodCallReturn">
-            <devdoc>
-            We need this non-generics base class so that 
-            we can use <see cref="P:Moq.MethodCallReturn.HasReturnValue"/> from 
-            generic code.
-            </devdoc>
-        </member>
-        <member name="T:Moq.Mock">
-            <summary>
-			Base class for mocks and static helper class with methods that
-			apply to mocked objects, such as <see cref="M:Moq.Mock.Get``1(``0)"/> to
-			retrieve a <see cref="T:Moq.Mock`1"/> from an object instance.
-		</summary>
-        </member>
-        <member name="M:Moq.Mock.Get``1(``0)">
-            <summary>
-			Retrieves the mock object for the given object instance.
-		</summary><typeparam name="T">
-			Type of the mock to retrieve. Can be omitted as it's inferred
-			from the object instance passed in as the <paramref name="mocked"/> instance.
-		</typeparam><param name="mocked">The instance of the mocked object.</param><returns>The mock associated with the mocked object.</returns><exception cref="T:System.ArgumentException">
-			The received <paramref name="mocked"/> instance
-			was not created by Moq.
-		</exception><example group="advanced">
-			The following example shows how to add a new setup to an object
-			instance which is not the original <see cref="T:Moq.Mock`1"/> but rather
-			the object associated with it:
-			<code>
-				// Typed instance, not the mock, is retrieved from some test API.
-				HttpContextBase context = GetMockContext();
-
-				// context.Request is the typed object from the "real" API
-				// so in order to add a setup to it, we need to get
-				// the mock that "owns" it
-				Mock&lt;HttpRequestBase&gt; request = Mock.Get(context.Request);
-				mock.Setup(req =&gt; req.AppRelativeCurrentExecutionFilePath)
-					 .Returns(tempUrl);
-			</code>
-		</example>
-        </member>
-        <member name="M:Moq.Mock.GetObject">
-            <summary>
-			Returns the mocked object value.
-		</summary>
-        </member>
-        <member name="M:Moq.Mock.Verify">
-            <summary>
-			Verifies that all verifiable expectations have been met.
-		</summary><example group="verification">
-			This example sets up an expectation and marks it as verifiable. After
-			the mock is used, a <c>Verify()</c> call is issued on the mock
-			to ensure the method in the setup was invoked:
-			<code>
-				var mock = new Mock&lt;IWarehouse&gt;();
-				this.Setup(x =&gt; x.HasInventory(TALISKER, 50)).Verifiable().Returns(true);
-				...
-				// other test code
-				...
-				// Will throw if the test code has didn't call HasInventory.
-				this.Verify();
-			</code>
-		</example><exception cref="T:Moq.MockException">Not all verifiable expectations were met.</exception>
-        </member>
-        <member name="M:Moq.Mock.VerifyAll">
-            <summary>
-			Verifies all expectations regardless of whether they have
-			been flagged as verifiable.
-		</summary><example group="verification">
-			This example sets up an expectation without marking it as verifiable. After
-			the mock is used, a <see cref="M:Moq.Mock.VerifyAll"/> call is issued on the mock
-			to ensure that all expectations are met:
-			<code>
-				var mock = new Mock&lt;IWarehouse&gt;();
-				this.Setup(x =&gt; x.HasInventory(TALISKER, 50)).Returns(true);
-				...
-				// other test code
-				...
-				// Will throw if the test code has didn't call HasInventory, even
-				// that expectation was not marked as verifiable.
-				this.VerifyAll();
-			</code>
-		</example><exception cref="T:Moq.MockException">At least one expectation was not met.</exception>		
-        </member>
-        <member name="M:Moq.Mock.GetInterceptor(System.Linq.Expressions.LambdaExpression,Moq.Mock)">
-            <summary>
-            Gets the interceptor target for the given expression and root mock, 
-            building the intermediate hierarchy of mock objects if necessary.
-            </summary>
-        </member>
-        <member name="M:Moq.Mock.CreateEventHandler``1">
-            <summary>
-			Creates a handler that can be associated to an event receiving
-			the given <typeparamref name="TEventArgs"/> and can be used
-			to raise the event.
-		</summary><typeparam name="TEventArgs">
-			Type of <see cref="T:System.EventArgs"/>
-			data passed in to the event.
-		</typeparam><example>
-			This example shows how to invoke an event with a custom event arguments
-			class in a view that will cause its corresponding presenter to
-			react by changing its state:
-			<code>
-				var mockView = new Mock&lt;IOrdersView&gt;();
-				var mockedEvent = mockView.CreateEventHandler&lt;OrderEventArgs&gt;();
-
-				var presenter = new OrdersPresenter(mockView.Object);
-
-				// Check that the presenter has no selection by default
-				Assert.Null(presenter.SelectedOrder);
-
-				// Create a mock event handler of the appropriate type
-				var handler = mockView.CreateEventHandler&lt;OrderEventArgs&gt;();
-				// Associate it with the event we want to raise
-				mockView.Object.Cancel += handler;
-				// Finally raise the event with a specific arguments data
-				handler.Raise(new OrderEventArgs { Order = new Order("moq", 500) });
-
-				// Now the presenter reacted to the event, and we have a selected order
-				Assert.NotNull(presenter.SelectedOrder);
-				Assert.Equal("moq", presenter.SelectedOrder.ProductName);
-			</code>
-		</example>
-        </member>
-        <member name="M:Moq.Mock.CreateEventHandler">
-            <summary>
-			Creates a handler that can be associated to an event receiving
-			a generic <see cref="T:System.EventArgs"/> and can be used
-			to raise the event.
-		</summary><example>
-			This example shows how to invoke a generic event in a view that will
-			cause its corresponding presenter to react by changing its state:
-			<code>
-				var mockView = new Mock&lt;IOrdersView&gt;();
-				var mockedEvent = mockView.CreateEventHandler();
-
-				var presenter = new OrdersPresenter(mockView.Object);
-
-				// Check that the presenter is not in the "Canceled" state
-				Assert.False(presenter.IsCanceled);
-
-				// Create a mock event handler of the appropriate type
-				var handler = mockView.CreateEventHandler();
-				// Associate it with the event we want to raise
-				mockView.Object.Cancel += handler;
-				// Finally raise the event
-				handler.Raise(EventArgs.Empty);
-
-				// Now the presenter reacted to the event, and changed its state
-				Assert.True(presenter.IsCanceled);
-			</code>
-		</example>
-        </member>
-        <member name="M:Moq.Mock.Moq#IHideObjectMembers#GetType">
-            <summary>
-			Base class for mocks and static helper class with methods that
-			apply to mocked objects, such as <see cref="M:Moq.Mock.Get``1(``0)"/> to
-			retrieve a <see cref="T:Moq.Mock`1"/> from an object instance.
-		</summary>
-        </member>
-        <member name="P:Moq.Mock.Behavior">
-            <summary>
-			Behavior of the mock, according to the value set in the constructor.
-		</summary>
-        </member>
-        <member name="P:Moq.Mock.CallBase">
-            <summary>
-			Whether the base member virtual implementation will be called
-			for mocked classes if no setup is matched. Defaults to <see langword="false"/>.
-		</summary>
-        </member>
-        <member name="P:Moq.Mock.DefaultValue">
-            <summary>
-			Specifies the behavior to use when returning default values for
-			unexpected invocations on loose mocks.
-		</summary>
-        </member>
-        <member name="P:Moq.Mock.Object">
-            <summary>
-			Gets the mocked object instance, which is of the mocked type <typeparamref name="T"/>.
-		</summary>
-        </member>
-        <member name="P:Moq.Mock.MockedType">
-            <summary>
-            Retrieves the type of the mocked object, its generic type argument.
-            This is used in the auto-mocking of hierarchy access.
-            </summary>
-        </member>
-        <member name="P:Moq.Mock.DefaultValueProvider">
-            <summary>
-            Specifies the class that will determine the default 
-            value to return when invocations are made that 
-            have no setups and need to return a default 
-            value (for loose mocks).
-            </summary>
-        </member>
-        <member name="P:Moq.Mock.ImplementedInterfaces">
-            <summary>
-            Exposes the list of extra interfaces implemented by the mock.
-            </summary>
-        </member>
-        <member name="T:Moq.MockBehavior">
-            <summary>
-            Options to customize the behavior of the mock. 
-            </summary>
-        </member>
-        <member name="F:Moq.MockBehavior.Strict">
-            <summary>
-            Causes the mock to always throw 
-            an exception for invocations that don't have a 
-            corresponding setup.
-            </summary>
-        </member>
-        <member name="F:Moq.MockBehavior.Loose">
-            <summary>
-            Will never throw exceptions, returning default  
-            values when necessary (null for reference types, 
-            zero for value types or empty enumerables and arrays).
-            </summary>
-        </member>
-        <member name="F:Moq.MockBehavior.Default">
-            <summary>
-            Default mock behavior, which equals <see cref="F:Moq.MockBehavior.Loose"/>.
-            </summary>
-        </member>
-        <member name="T:Moq.MockedEvent">
-            <summary>
-            Represents a generic event that has been mocked and can 
-            be rised.
-            </summary>
-        </member>
-        <member name="M:Moq.MockedEvent.Handle(System.Object,System.EventArgs)">
-            <summary>
-            Provided solely to allow the interceptor to determine when the attached 
-            handler is coming from this mocked event so we can assign the 
-            corresponding EventInfo for it.
-            </summary>
-        </member>
-        <member name="M:Moq.MockedEvent.DoRaise(System.EventArgs)">
-            <summary>
-            Raises the associated event with the given 
-            event argument data.
-            </summary>
-        </member>
-        <member name="M:Moq.MockedEvent.DoRaise(System.Object[])">
-            <summary>
-            Raises the associated event with the given 
-            event argument data.
-            </summary>
-        </member>
-        <member name="M:Moq.MockedEvent.op_Implicit(Moq.MockedEvent)~System.EventHandler">
-            <summary>
-            Provides support for attaching a <see cref="T:Moq.MockedEvent"/> to 
-            a generic <see cref="T:System.EventHandler"/> event.
-            </summary>
-            <param name="mockEvent">Event to convert.</param>
-        </member>
-        <member name="E:Moq.MockedEvent.Raised">
-            <summary>
-            Event raised whenever the mocked event is rised.
-            </summary>
-        </member>
-        <member name="T:Moq.MockException">
-            <summary>
-            Exception thrown by mocks when setups are not matched, 
-            the mock is not properly setup, etc.
-            </summary>
-            <remarks>
-            A distinct exception type is provided so that exceptions 
-            thrown by the mock can be differentiated in tests that 
-            expect other exceptions to be thrown (i.e. ArgumentException).
-            <para>
-            Richer exception hierarchy/types are not provided as 
-            tests typically should <b>not</b> catch or expect exceptions 
-            from the mocks. These are typically the result of changes 
-            in the tested class or its collaborators implementation, and 
-            result in fixes in the mock setup so that they dissapear and 
-            allow the test to pass.
-            </para>
-            </remarks>
-        </member>
-        <member name="M:Moq.MockException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
-            <summary>
-            Supports the serialization infrastructure.
-            </summary>
-            <param name="info">Serialization information.</param>
-            <param name="context">Streaming context.</param>
-        </member>
-        <member name="M:Moq.MockException.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
-            <summary>
-            Supports the serialization infrastructure.
-            </summary>
-            <param name="info">Serialization information.</param>
-            <param name="context">Streaming context.</param>
-        </member>
-        <member name="T:Moq.MockException.ExceptionReason">
-            <summary>
-            Made internal as it's of no use for 
-            consumers, but it's important for 
-            our own tests.
-            </summary>
-        </member>
-        <member name="T:Moq.MockVerificationException">
-            <devdoc>
-            Used by the mock factory to accumulate verification 
-            failures.
-            </devdoc>
-        </member>
-        <member name="M:Moq.MockVerificationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
-            <summary>
-            Supports the serialization infrastructure.
-            </summary>
-        </member>
-        <member name="T:Moq.MockFactory">
-            <summary>
-            Utility factory class to use to construct multiple 
-            mocks when consistent verification is 
-            desired for all of them.
-            </summary>
-            <remarks>
-            If multiple mocks will be created during a test, passing 
-            the desired <see cref="T:Moq.MockBehavior"/> (if different than the 
-            <see cref="F:Moq.MockBehavior.Default"/> or the one 
-            passed to the factory constructor) and later verifying each
-            mock can become repetitive and tedious.
-            <para>
-            This factory class helps in that scenario by providing a 
-            simplified creation of multiple mocks with a default 
-            <see cref="T:Moq.MockBehavior"/> (unless overriden by calling 
-            <see cref="M:Moq.MockFactory.Create``1(Moq.MockBehavior)"/>) and posterior verification.
-            </para>
-            </remarks>
-            <example group="factory">
-            The following is a straightforward example on how to 
-            create and automatically verify strict mocks using a <see cref="T:Moq.MockFactory"/>:
-            <code>
-            var factory = new MockFactory(MockBehavior.Strict);
-            
-            var foo = factory.Create&lt;IFoo&gt;();
-            var bar = factory.Create&lt;IBar&gt;();
-            
-            // no need to call Verifiable() on the setup 
-            // as we'll be validating all of them anyway.
-            foo.Setup(f =&gt; f.Do());
-            bar.Setup(b =&gt; b.Redo());
-            
-            // exercise the mocks here
-            
-            factory.VerifyAll(); 
-            // At this point all setups are already checked 
-            // and an optional MockException might be thrown. 
-            // Note also that because the mocks are strict, any invocation 
-            // that doesn't have a matching setup will also throw a MockException.
-            </code>
-            The following examples shows how to setup the factory 
-            to create loose mocks and later verify only verifiable setups:
-            <code>
-            var factory = new MockFactory(MockBehavior.Loose);
-            
-            var foo = factory.Create&lt;IFoo&gt;();
-            var bar = factory.Create&lt;IBar&gt;();
-            
-            // this setup will be verified when we verify the factory
-            foo.Setup(f =&gt; f.Do()).Verifiable();
-            	
-            // this setup will NOT be verified 
-            foo.Setup(f =&gt; f.Calculate());
-            	
-            // this setup will be verified when we verify the factory
-            bar.Setup(b =&gt; b.Redo()).Verifiable();
-            
-            // exercise the mocks here
-            // note that because the mocks are Loose, members 
-            // called in the interfaces for which no matching
-            // setups exist will NOT throw exceptions, 
-            // and will rather return default values.
-            
-            factory.Verify();
-            // At this point verifiable setups are already checked 
-            // and an optional MockException might be thrown.
-            </code>
-            The following examples shows how to setup the factory with a 
-            default strict behavior, overriding that default for a 
-            specific mock:
-            <code>
-            var factory = new MockFactory(MockBehavior.Strict);
-            
-            // this particular one we want loose
-            var foo = factory.Create&lt;IFoo&gt;(MockBehavior.Loose);
-            var bar = factory.Create&lt;IBar&gt;();
-            
-            // specify setups
-            
-            // exercise the mocks here
-            
-            factory.Verify();
-            </code>
-            </example>
-            <seealso cref="T:Moq.MockBehavior"/>
-        </member>
-        <member name="M:Moq.MockFactory.#ctor(Moq.MockBehavior)">
-            <summary>
-            Initializes the factory with the given <paramref name="defaultBehavior"/> 
-            for newly created mocks from the factory.
-            </summary>
-            <param name="defaultBehavior">The behavior to use for mocks created 
-            using the <see cref="M:Moq.MockFactory.Create``1"/> factory method if not overriden 
-            by using the <see cref="M:Moq.MockFactory.Create``1(Moq.MockBehavior)"/> overload.</param>
-        </member>
-        <member name="M:Moq.MockFactory.Create``1">
-            <summary>
-            Creates a new mock with the default <see cref="T:Moq.MockBehavior"/> 
-            specified at factory construction time.
-            </summary>
-            <typeparam name="T">Type to mock.</typeparam>
-            <returns>A new <see cref="T:Moq.Mock`1"/>.</returns>
-            <example ignore="true">
-            <code>
-            var factory = new MockFactory(MockBehavior.Strict);
-            
-            var foo = factory.Create&lt;IFoo&gt;();
-            // use mock on tests
-            
-            factory.VerifyAll();
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.MockFactory.Create``1(System.Object[])">
-            <summary>
-            Creates a new mock with the default <see cref="T:Moq.MockBehavior"/> 
-            specified at factory construction time and with the 
-            the given constructor arguments for the class.
-            </summary>
-            <remarks>
-            The mock will try to find the best match constructor given the 
-            constructor arguments, and invoke that to initialize the instance. 
-            This applies only to classes, not interfaces.
-            </remarks>
-            <typeparam name="T">Type to mock.</typeparam>
-            <param name="args">Constructor arguments for mocked classes.</param>
-            <returns>A new <see cref="T:Moq.Mock`1"/>.</returns>
-            <example ignore="true">
-            <code>
-            var factory = new MockFactory(MockBehavior.Default);
-            
-            var mock = factory.Create&lt;MyBase&gt;("Foo", 25, true);
-            // use mock on tests
-            
-            factory.Verify();
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.MockFactory.Create``1(Moq.MockBehavior)">
-            <summary>
-            Creates a new mock with the given <paramref name="behavior"/>.
-            </summary>
-            <typeparam name="T">Type to mock.</typeparam>
-            <param name="behavior">Behavior to use for the mock, which overrides 
-            the default behavior specified at factory construction time.</param>
-            <returns>A new <see cref="T:Moq.Mock`1"/>.</returns>
-            <example group="factory">
-            The following example shows how to create a mock with a different 
-            behavior to that specified as the default for the factory:
-            <code>
-            var factory = new MockFactory(MockBehavior.Strict);
-            
-            var foo = factory.Create&lt;IFoo&gt;(MockBehavior.Loose);
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.MockFactory.Create``1(Moq.MockBehavior,System.Object[])">
-            <summary>
-            Creates a new mock with the given <paramref name="behavior"/> 
-            and with the the given constructor arguments for the class.
-            </summary>
-            <remarks>
-            The mock will try to find the best match constructor given the 
-            constructor arguments, and invoke that to initialize the instance. 
-            This applies only to classes, not interfaces.
-            </remarks>
-            <typeparam name="T">Type to mock.</typeparam>
-            <param name="behavior">Behavior to use for the mock, which overrides 
-            the default behavior specified at factory construction time.</param>
-            <param name="args">Constructor arguments for mocked classes.</param>
-            <returns>A new <see cref="T:Moq.Mock`1"/>.</returns>
-            <example group="factory">
-            The following example shows how to create a mock with a different 
-            behavior to that specified as the default for the factory, passing 
-            constructor arguments:
-            <code>
-            var factory = new MockFactory(MockBehavior.Default);
-            
-            var mock = factory.Create&lt;MyBase&gt;(MockBehavior.Strict, "Foo", 25, true);
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.MockFactory.CreateMock``1(Moq.MockBehavior,System.Object[])">
-            <summary>
-            Implements creation of a new mock within the factory.
-            </summary>
-            <typeparam name="T">Type to mock.</typeparam>
-            <param name="behavior">The behavior for the new mock.</param>
-            <param name="args">Optional arguments for the construction of the mock.</param>
-        </member>
-        <member name="M:Moq.MockFactory.Verify">
-            <summary>
-            Verifies all verifiable expectations on all mocks created 
-            by this factory.
-            </summary>
-            <seealso cref="M:Moq.Mock.Verify"/>
-            <exception cref="T:Moq.MockException">One or more mocks had expectations that were not satisfied.</exception>
-        </member>
-        <member name="M:Moq.MockFactory.VerifyAll">
-            <summary>
-            Verifies all verifiable expectations on all mocks created 
-            by this factory.
-            </summary>
-            <seealso cref="M:Moq.Mock.Verify"/>
-            <exception cref="T:Moq.MockException">One or more mocks had expectations that were not satisfied.</exception>
-        </member>
-        <member name="M:Moq.MockFactory.VerifyMocks(System.Action{Moq.Mock})">
-            <summary>
-            Invokes <paramref name="verifyAction"/> for each mock 
-            in <see cref="P:Moq.MockFactory.Mocks"/>, and accumulates the resulting 
-            <see cref="T:Moq.MockVerificationException"/> that might be 
-            thrown from the action.
-            </summary>
-            <param name="verifyAction">The action to execute against 
-            each mock.</param>
-        </member>
-        <member name="P:Moq.MockFactory.CallBase">
-            <summary>
-            Whether the base member virtual implementation will be called 
-            for mocked classes if no setup is matched. Defaults to <see langword="false"/>.
-            </summary>
-        </member>
-        <member name="P:Moq.MockFactory.DefaultValue">
-            <summary>
-            Specifies the behavior to use when returning default values for 
-            unexpected invocations on loose mocks.
-            </summary>
-        </member>
-        <member name="P:Moq.MockFactory.Mocks">
-            <summary>
-            Gets the mocks that have been created by this factory and 
-            that will get verified together.
-            </summary>
-        </member>
-        <member name="T:Moq.Properties.Resources">
-            <summary>
-              A strongly-typed resource class, for looking up localized strings, etc.
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.ResourceManager">
-            <summary>
-              Returns the cached ResourceManager instance used by this class.
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.Culture">
-            <summary>
-              Overrides the current thread's CurrentUICulture property for all
-              resource lookups using this strongly typed resource class.
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.AlreadyInitialized">
-            <summary>
-              Looks up a localized string similar to Mock type has already been initialized by accessing its Object property. Adding interfaces must be done before that..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.ArgumentCannotBeEmpty">
-            <summary>
-              Looks up a localized string similar to Value cannot be an empty string..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.AsMustBeInterface">
-            <summary>
-              Looks up a localized string similar to Can only add interfaces to the mock..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.CantSetReturnValueForVoid">
-            <summary>
-              Looks up a localized string similar to Can&apos;t set return value for void method {0}..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.ConstructorArgsForInterface">
-            <summary>
-              Looks up a localized string similar to Constructor arguments cannot be passed for interface mocks..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.ConstructorNotFound">
-            <summary>
-              Looks up a localized string similar to A matching constructor for the given arguments was not found on the mocked type..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.FieldsNotSupported">
-            <summary>
-              Looks up a localized string similar to Expression {0} involves a field access, which is not supported. Use properties instead..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.InvalidMockClass">
-            <summary>
-              Looks up a localized string similar to Type to mock must be an interface or an abstract or non-sealed class. .
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.InvalidMockGetType">
-             <summary>
-               Looks up a localized string similar to Cannot retrieve a mock with the given object type {0} as it&apos;s not the main type of the mock or any of its additional interfaces.
-            Please cast the argument to one of the supported types: {1}.
-            Remember that there&apos;s no generics covariance in the CLR, so your object must be one of these types in order for the call to succeed..
-             </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.MemberMissing">
-            <summary>
-              Looks up a localized string similar to Member {0}.{1} does not exist..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.MethodIsPublic">
-             <summary>
-               Looks up a localized string similar to Method {0}.{1} is public. Use strong-typed Expect overload instead:
-            mock.Setup(x =&gt; x.{1}());
-            .
-             </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.MockExceptionMessage">
-             <summary>
-               Looks up a localized string similar to {0} invocation failed with mock behavior {1}.
-            {2}.
-             </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.MoreThanNCalls">
-            <summary>
-              Looks up a localized string similar to Expected only {0} calls to {1}..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.MoreThanOneCall">
-            <summary>
-              Looks up a localized string similar to Expected only one call to {0}..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.NoMatchingCallsAtLeast">
-             <summary>
-               Looks up a localized string similar to {0}
-            Invocation was performed on the mock less than {2} times: {1}.
-             </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.NoMatchingCallsAtLeastOnce">
-             <summary>
-               Looks up a localized string similar to {0}
-            Invocation was not performed on the mock: {1}.
-             </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.NoMatchingCallsAtMost">
-             <summary>
-               Looks up a localized string similar to {0}
-            Invocation was performed on the mock more than {3} times: {1}.
-             </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.NoMatchingCallsAtMostOnce">
-             <summary>
-               Looks up a localized string similar to {0}
-            Invocation was performed on the mock more than once: {1}.
-             </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.NoMatchingCallsBetweenExclusive">
-             <summary>
-               Looks up a localized string similar to {0}
-            Invocation was performed on the mock less or equal than {2} times or more or equal than {3} times: {1}.
-             </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.NoMatchingCallsBetweenInclusive">
-             <summary>
-               Looks up a localized string similar to {0}
-            Invocation was performed on the mock less than {2} times or more than {3} times: {1}.
-             </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.NoMatchingCallsExactly">
-             <summary>
-               Looks up a localized string similar to {0}
-            Invocation was not performed on the mock {2} times: {1}.
-             </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.NoMatchingCallsNever">
-             <summary>
-               Looks up a localized string similar to {0}
-            Invocation should not have been performed on the mock: {1}.
-             </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.NoMatchingCallsOnce">
-             <summary>
-               Looks up a localized string similar to {0}
-            Invocation was performed more than once on the mock: {1}.
-             </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.NoSetup">
-            <summary>
-              Looks up a localized string similar to All invocations on the mock must have a corresponding setup..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.ObjectInstanceNotMock">
-            <summary>
-              Looks up a localized string similar to Object instance was not created by Moq..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.PropertyMissing">
-            <summary>
-              Looks up a localized string similar to Property {0}.{1} does not exist..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.PropertyNotReadable">
-            <summary>
-              Looks up a localized string similar to Property {0}.{1} is write-only..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.PropertyNotWritable">
-            <summary>
-              Looks up a localized string similar to Property {0}.{1} is read-only..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.RaisedUnassociatedEvent">
-            <summary>
-              Looks up a localized string similar to Cannot raise a mocked event unless it has been associated (attached) to a concrete event in a mocked object..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.ReturnValueRequired">
-            <summary>
-              Looks up a localized string similar to Invocation needs to return a value and therefore must have a corresponding setup that provides it..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.SetupLambda">
-            <summary>
-              Looks up a localized string similar to A lambda expression is expected as the argument to It.Is&lt;T&gt;..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.SetupNever">
-            <summary>
-              Looks up a localized string similar to Invocation {0} should not have been made..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.SetupNotMethod">
-            <summary>
-              Looks up a localized string similar to Expression is not a method invocation: {0}.
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.SetupNotProperty">
-            <summary>
-              Looks up a localized string similar to Expression is not a property access: {0}.
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.SetupNotSetter">
-            <summary>
-              Looks up a localized string similar to Expression is not a property setter invocation..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.SetupOnNonOverridableMember">
-             <summary>
-               Looks up a localized string similar to Invalid setup on a non-overridable member:
-            {0}.
-             </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.TypeNotImplementInterface">
-            <summary>
-              Looks up a localized string similar to Type {0} does not implement required interface {1}.
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.TypeNotInheritFromType">
-            <summary>
-              Looks up a localized string similar to Type {0} does not from required type {1}.
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.UnexpectedPublicProperty">
-             <summary>
-               Looks up a localized string similar to To specify a setup for public property {0}.{1}, use the typed overloads, such as:
-            mock.Setup(x =&gt; x.{1}).Returns(value);
-            mock.SetupGet(x =&gt; x.{1}).Returns(value); //equivalent to previous one
-            mock.SetupSet(x =&gt; x.{1}).Callback(callbackDelegate);
-            .
-             </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.UnsupportedExpression">
-            <summary>
-              Looks up a localized string similar to Expression {0} is not supported..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.UnsupportedIntermediateExpression">
-            <summary>
-              Looks up a localized string similar to Only property accesses are supported in intermediate invocations on a setup. Unsupported expression {0}..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.UnsupportedIntermediateType">
-            <summary>
-              Looks up a localized string similar to Expression contains intermediate property access {0}.{1} which is of type {2} and cannot be mocked. Unsupported expression {3}..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.UnsupportedMatcherParamsForSetter">
-            <summary>
-              Looks up a localized string similar to Setter expression cannot use argument matchers that receive parameters..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.UnsupportedMember">
-            <summary>
-              Looks up a localized string similar to Member {0} is not supported for protected mocking..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.UnsupportedNonStaticMatcherForSetter">
-            <summary>
-              Looks up a localized string similar to Setter expression can only use static custom matchers..
-            </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.UnsupportedProtectedProperty">
-             <summary>
-               Looks up a localized string similar to To specify a setup for protected property {0}.{1}, use:
-            mock.Setup&lt;{2}&gt;(x =&gt; x.{1}).Returns(value);
-            mock.SetupGet(x =&gt; x.{1}).Returns(value); //equivalent to previous one
-            mock.SetupSet(x =&gt; x.{1}).Callback(callbackDelegate);.
-             </summary>
-        </member>
-        <member name="P:Moq.Properties.Resources.VerficationFailed">
-             <summary>
-               Looks up a localized string similar to The following setups were not matched:
-            {0}.
-             </summary>
-        </member>
-        <member name="T:Moq.Protected.IProtectedMock`1">
-            <summary>
-            Allows setups to be specified for protected members by using their 
-            name as a string, rather than strong-typing them which is not possible 
-            due to their visibility.
-            </summary>
-        </member>
-        <member name="M:Moq.Protected.IProtectedMock`1.Setup(System.String,System.Object[])">
-            <summary>
-            Specifies a setup for a void method invocation with the given 
-            <paramref name="voidMethodName"/>, optionally specifying 
-            arguments for the method call.
-            </summary>
-            <param name="voidMethodName">Name of the void method to be invoke.</param>
-            <param name="args">Optional arguments for the invocation. If argument matchers are used, 
-            remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</param>
-        </member>
-        <member name="M:Moq.Protected.IProtectedMock`1.Setup``1(System.String,System.Object[])">
-            <summary>
-            Specifies a setup for an invocation on a property or a non void method with the given 
-            <paramref name="methodOrPropertyName"/>, optionally specifying 
-            arguments for the method call.
-            </summary>
-            <param name="methodOrPropertyName">Name of the method or property to be invoke.</param>
-            <param name="args">Optional arguments for the invocation. If argument matchers are used, 
-            remember to use <see cref="T:Moq.Protected.ItExpr"/> rather than <see cref="T:Moq.It"/>.</param>
-            <typeparam name="TResult">Return type of the method or property.</typeparam>
-        </member>
-        <member name="M:Moq.Protected.IProtectedMock`1.SetupGet``1(System.String)">
-            <summary>
-            Specifies a setup for an invocation on a property getter with the given 
-            <paramref name="propertyName"/>.
-            </summary>
-            <param name="propertyName">Name of the property.</param>
-            <typeparam name="TProperty">Type of the property.</typeparam>
-        </member>
-        <member name="M:Moq.Protected.IProtectedMock`1.SetupSet``1(System.String)">
-            <summary>
-            Specifies a setup for an invocation on a property setter with the given 
-            <paramref name="propertyName"/>.
-            </summary>
-            <param name="propertyName">Name of the property.</param>
-            <typeparam name="TProperty">Type of the property.</typeparam>
-        </member>
-        <member name="T:Moq.Protected.ItExpr">
-            <summary>
-            Allows the specification of a matching condition for an 
-            argument in a protected member setup, rather than a specific 
-            argument value. "ItExpr" refers to the argument being matched.
-            </summary>
-            <remarks>
-            <para>Use this variant of argument matching instead of 
-            <see cref="T:Moq.It"/> for protected setups.</para>
-            This class allows the setup to match a method invocation 
-            with an arbitrary value, with a value in a specified range, or 
-            even one that matches a given predicate, or null.
-            </remarks>
-        </member>
-        <member name="M:Moq.Protected.ItExpr.IsNull``1">
-            <summary>
-            Matches a null value of the given <paramref name="TValue"/> type.
-            </summary>
-            <remarks>
-            Required for protected mocks as the null value cannot be used 
-            directly as it prevents proper method overload selection.
-            </remarks>
-            <example>
-            <code>
-            // Throws an exception for a call to Remove with a null string value.
-            mock.Protected()
-                .Setup("Remove", ItExpr.IsNull&lt;string&gt;())
-                .Throws(new InvalidOperationException());
-            </code>
-            </example>
-            <typeparam name="TValue">Type of the value.</typeparam>
-        </member>
-        <member name="M:Moq.Protected.ItExpr.IsAny``1">
-            <summary>
-            Matches any value of the given <paramref name="TValue"/> type.
-            </summary>
-            <remarks>
-            Typically used when the actual argument value for a method 
-            call is not relevant.
-            </remarks>
-            <example>
-            <code>
-            // Throws an exception for a call to Remove with any string value.
-            mock.Protected()
-                .Setup("Remove", ItExpr.IsAny&lt;string&gt;())
-                .Throws(new InvalidOperationException());
-            </code>
-            </example>
-            <typeparam name="TValue">Type of the value.</typeparam>
-        </member>
-        <member name="M:Moq.Protected.ItExpr.Is``1(System.Linq.Expressions.Expression{System.Predicate{``0}})">
-            <summary>
-            Matches any value that satisfies the given predicate.
-            </summary>
-            <typeparam name="TValue">Type of the argument to check.</typeparam>
-            <param name="match">The predicate used to match the method argument.</param>
-            <remarks>
-            Allows the specification of a predicate to perform matching 
-            of method call arguments.
-            </remarks>
-            <example>
-            This example shows how to return the value <c>1</c> whenever the argument to the 
-            <c>Do</c> method is an even number.
-            <code>
-            mock.Protected()
-                .Setup("Do", ItExpr.Is&lt;int&gt;(i =&gt; i % 2 == 0))
-                .Returns(1);
-            </code>
-            This example shows how to throw an exception if the argument to the 
-            method is a negative number:
-            <code>
-            mock.Protected()
-                .Setup("GetUser", ItExpr.Is&lt;int&gt;(i =&gt; i &lt; 0))
-                .Throws(new ArgumentException());
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Protected.ItExpr.IsInRange``1(``0,``0,Moq.Range)">
-            <summary>
-            Matches any value that is in the range specified.
-            </summary>
-            <typeparam name="TValue">Type of the argument to check.</typeparam>
-            <param name="from">The lower bound of the range.</param>
-            <param name="to">The upper bound of the range.</param>
-            <param name="rangeKind">The kind of range. See <see cref="T:Moq.Range"/>.</param>
-            <example>
-            The following example shows how to expect a method call 
-            with an integer argument within the 0..100 range.
-            <code>
-            mock.Protected()
-                .Setup("HasInventory",
-                        ItExpr.IsAny&lt;string&gt;(),
-                        ItExpr.IsInRange(0, 100, Range.Inclusive))
-                .Returns(false);
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Protected.ItExpr.IsRegex(System.String)">
-            <summary>
-            Matches a string argument if it matches the given regular expression pattern.
-            </summary>
-            <param name="regex">The pattern to use to match the string argument value.</param>
-            <example>
-            The following example shows how to expect a call to a method where the 
-            string argument matches the given regular expression:
-            <code>
-            mock.Protected()
-                .Setup("Check", ItExpr.IsRegex("[a-z]+"))
-                .Returns(1);
-            </code>
-            </example>
-        </member>
-        <member name="M:Moq.Protected.ItExpr.IsRegex(System.String,System.Text.RegularExpressions.RegexOptions)">
-            <summary>
-            Matches a string argument if it matches the given regular expression pattern.
-            </summary>
-            <param name="regex">The pattern to use to match the string argument value.</param>
-            <param name="options">The options used to interpret the pattern.</param>
-            <example>
-            The following example shows how to expect a call to a method where the 
-            string argument matches the given regular expression, in a case insensitive way:
-            <code>
-            mock.Protected()
-                .Setup("Check", ItExpr.IsRegex("[a-z]+", RegexOptions.IgnoreCase))
-                .Returns(1);
-            </code>
-            </example>
-        </member>
-        <member name="T:Moq.Protected.ProtectedExtension">
-            <summary>
-            Enables the <c>Protected()</c> method on <see cref="T:Moq.Mock`1"/>, 
-            allowing setups to be set for protected members by using their 
-            name as a string, rather than strong-typing them which is not possible 
-            due to their visibility.
-            </summary>
-        </member>
-        <member name="M:Moq.Protected.ProtectedExtension.Protected``1(Moq.Mock{``0})">
-            <summary>
-            Enable protected setups for the mock.
-            </summary>
-            <typeparam name="T">Mocked object type. Typically omitted as it can be inferred from the mock instance.</typeparam>
-            <param name="mock">The mock to set the protected setups on.</param>
-        </member>
-        <member name="T:ThisAssembly">
-            <group name="overview" title="Overview" order="0" />
-            <group name="setups" title="Specifying setups" order="1" />
-            <group name="returns" title="Returning values from members" order="2" />
-            <group name="verification" title="Verifying setups" order="3" />
-            <group name="advanced" title="Advanced scenarios" order="99" />
-            <group name="factory" title="Using MockFactory for consistency across mocks" order="4" />
-        </member>
-        <member name="T:Moq.Range">
-            <summary>
-            Kind of range to use in a filter specified through 
-            <see cref="M:Moq.It.IsInRange``1(``0,``0,Moq.Range)"/>.
-            </summary>
-        </member>
-        <member name="F:Moq.Range.Inclusive">
-            <summary>
-            The range includes the <c>to</c> and 
-            <c>from</c> values.
-            </summary>
-        </member>
-        <member name="F:Moq.Range.Exclusive">
-            <summary>
-            The range does not include the <c>to</c> and 
-            <c>from</c> values.
-            </summary>
-        </member>
-        <member name="T:Moq.DefaultValue">
-            <summary>
-            Determines the way default values are generated 
-            calculated for loose mocks.
-            </summary>
-        </member>
-        <member name="F:Moq.DefaultValue.Empty">
-            <summary>
-            Default behavior, which generates empty values for 
-            value types (i.e. default(int)), empty array and 
-            enumerables, and nulls for all other reference types.
-            </summary>
-        </member>
-        <member name="F:Moq.DefaultValue.Mock">
-            <summary>
-            Whenever the default value generated by <see cref="F:Moq.DefaultValue.Empty"/> 
-            is null, replaces this value with a mock (if the type 
-            can be mocked). 
-            </summary>
-            <remarks>
-            For sealed classes, a null value will be generated.
-            </remarks>
-        </member>
-        <member name="T:Moq.Match">
-            <summary>
-			Allows creation custom value matchers that can be used on setups and verification,
-			completely replacing the built-in <see cref="T:Moq.It"/> class with your own argument
-			matching rules.
-		</summary>
-        </member>
-        <member name="M:Moq.Match.Matcher``1">
-            <devdoc>
-            Provided for the sole purpose of rendering the delegate passed to the 
-            matcher constructor if no friendly render lambda is provided.
-            </devdoc>
-        </member>
-        <member name="T:Moq.Match`1">
-            <summary>
-			Allows creation custom value matchers that can be used on setups and verification,
-			completely replacing the built-in <see cref="T:Moq.It"/> class with your own argument
-			matching rules.
-		</summary><typeparam name="T">Type of the value to match.</typeparam><remarks>
-			The argument matching is used to determine whether a concrete
-			invocation in the mock matches a given setup. This
-			matching mechanism is fully extensible.
-		</remarks><example>
-			Creating a custom matcher is straightforward. You just need to create a method
-			that returns a value from a call to <see cref="M:Moq.Match`1.Create(System.Predicate{`0})"/> with 
-			your matching condition and optional friendly render expression:
-			<code>
-				public Order IsBigOrder()
-				{
-					return Match&lt;Order&gt;.Create(
-						o =&gt; o.GrandTotal &gt;= 5000, 
-						/* a friendly expression to render on failures */
-						() =&gt; IsBigOrder());
-				}
-			</code>
-			This method can be used in any mock setup invocation:
-			<code>
-				mock.Setup(m =&gt; m.Submit(IsBigOrder()).Throws&lt;UnauthorizedAccessException&gt;();
-			</code>
-			At runtime, Moq knows that the return value was a matcher and
-			evaluates your predicate with the actual value passed into your predicate.
-			<para>
-				Another example might be a case where you want to match a lists of orders
-				that contains a particular one. You might create matcher like the following:
-			</para>
-			<code>
-				public static class Orders
-				{
-					public static IEnumerable&lt;Order&gt; Contains(Order order)
-					{
-						return Match&lt;IEnumerable&lt;Order&gt;&gt;.Create(orders =&gt; orders.Contains(order));
-					}
-				}
-			</code>
-			Now we can invoke this static method instead of an argument in an
-			invocation:
-			<code>
-				var order = new Order { ... };
-				var mock = new Mock&lt;IRepository&lt;Order&gt;&gt;();
-
-				mock.Setup(x =&gt; x.Save(Orders.Contains(order)))
-					 .Throws&lt;ArgumentException&gt;();
-			</code>
-		</example>
-        </member>
-        <member name="M:Moq.Match`1.Create(System.Predicate{`0})">
-            <summary>
-			Initializes the match with the condition that
-			will be checked in order to match invocation
-			values.
-		</summary><param name="condition">The condition to match against actual values.</param><remarks>
-			 <seealso cref="T:Moq.Match`1"/>
-		</remarks>
-        </member>
-        <member name="M:Moq.Match`1.Create(System.Predicate{`0},System.Linq.Expressions.Expression{System.Func{`0}})">
-            <!-- No matching elements were found for the following include tag --><include file="Match.xdoc" path="docs/doc[@for=&quot;Match{T}.Create(condition,renderExpression&quot;]/*"/>
-        </member>
-        <member name="M:Moq.Match`1.Convert">
-            <!-- No matching elements were found for the following include tag --><include file="Match.xdoc" path="docs/doc[@for=&quot;Match{T}.Convert&quot;]/*"/>
-        </member>
-        <member name="M:Moq.Match`1.SetLastMatch``1(Moq.Match{``0})">
-            <devdoc>
-            This method is used to set an expression as the last matcher invoked, 
-            which is used in the SetupSet to allow matchers in the prop = value 
-            delegate expression. This delegate is executed in "fluent" mode in 
-            order to capture the value being set, and construct the corresponding 
-            methodcall.
-            This is also used in the MatcherFactory for each argument expression.
-            This method ensures that when we execute the delegate, we 
-            also track the matcher that was invoked, so that when we create the 
-            methodcall we build the expression using it, rather than the null/default 
-            value returned from the actual invocation.
-            </devdoc>
-        </member>
-        <member name="T:Moq.Mock`1">
-            <summary>
-			Provides a mock implementation of <typeparamref name="T"/>.
-		</summary><remarks>
-			Any interface type can be used for mocking, but for classes, only abstract and virtual members can be mocked.
-			<para>
-				The behavior of the mock with regards to the setups and the actual calls is determined
-				by the optional <see cref="T:Moq.MockBehavior"/> that can be passed to the <see cref="M:Moq.Mock`1.#ctor(Moq.MockBehavior)"/>
-				constructor.
-			</para>
-		</remarks><typeparam name="T">Type to mock, which can be an interface or a class.</typeparam><example group="overview" order="0">
-			The following example shows establishing setups with specific values
-			for method invocations:
-			<code>
-				// Arrange
-				var order = new Order(TALISKER, 50);
-				var mock = new Mock&lt;IWarehouse&gt;();
-
-				mock.Setup(x =&gt; x.HasInventory(TALISKER, 50)).Returns(true);
-
-				// Act
-				order.Fill(mock.Object);
-
-				// Assert
-				Assert.True(order.IsFilled);
-			</code>
-			The following example shows how to use the <see cref="T:Moq.It"/> class
-			to specify conditions for arguments instead of specific values:
-			<code>
-				// Arrange
-				var order = new Order(TALISKER, 50);
-				var mock = new Mock&lt;IWarehouse&gt;();
-
-				// shows how to expect a value within a range
-				mock.Setup(x =&gt; x.HasInventory(
-							It.IsAny&lt;string&gt;(),
-							It.IsInRange(0, 100, Range.Inclusive)))
-					 .Returns(false);
-
-				// shows how to throw for unexpected calls.
-				mock.Setup(x =&gt; x.Remove(
-							It.IsAny&lt;string&gt;(),
-							It.IsAny&lt;int&gt;()))
-					 .Throws(new InvalidOperationException());
-
-				// Act
-				order.Fill(mock.Object);
-
-				// Assert
-				Assert.False(order.IsFilled);
-			</code>
-		</example>
-        </member>
-        <member name="M:Moq.Mock`1.#ctor(System.Boolean)">
-            <summary>
-            Ctor invoked by AsTInterface exclusively.
-            </summary>
-        </member>
-        <member name="M:Moq.Mock`1.#ctor">
-            <summary>
-			Initializes an instance of the mock with <see cref="F:Moq.MockBehavior.Default">default behavior</see>.
-		</summary><example>
-			<code>var mock = new Mock&lt;IFormatProvider&gt;();</code>
-		</example>
-        </member>
-        <member name="M:Moq.Mock`1.#ctor(System.Object[])">
-            <summary>
-			Initializes an instance of the mock with <see cref="F:Moq.MockBehavior.Default">default behavior</see> and with
-			the given constructor arguments for the class. (Only valid when <typeparamref name="T"/> is a class)
-		</summary><remarks>
-			The mock will try to find the best match constructor given the constructor arguments, and invoke that
-			to initialize the instance. This applies only for classes, not interfaces.
-		</remarks><example>
-			<code>var mock = new Mock&lt;MyProvider&gt;(someArgument, 25);</code>
-		</example><param name="args">Optional constructor arguments if the mocked type is a class.</param>
-        </member>
-        <member name="M:Moq.Mock`1.#ctor(Moq.MockBehavior)">
-            <summary>
-			Initializes an instance of the mock with the specified <see cref="T:Moq.MockBehavior">behavior</see>.
-		</summary><example>
-			<code>var mock = new Mock&lt;IFormatProvider&gt;(MockBehavior.Relaxed);</code>
-		</example><param name="behavior">Behavior of the mock.</param>
-        </member>
-        <member name="M:Moq.Mock`1.#ctor(Moq.MockBehavior,System.Object[])">
-            <summary>
-			Initializes an instance of the mock with a specific <see cref="T:Moq.MockBehavior">behavior</see> with
-			the given constructor arguments for the class.
-		</summary><remarks>
-			The mock will try to find the best match constructor given the constructor arguments, and invoke that
-			to initialize the instance. This applies only to classes, not interfaces.
-		</remarks><example>
-			<code>var mock = new Mock&lt;MyProvider&gt;(someArgument, 25);</code>
-		</example><param name="behavior">Behavior of the mock.</param><param name="args">Optional constructor arguments if the mocked type is a class.</param>
-        </member>
-        <member name="M:Moq.Mock`1.GetObject">
-            <summary>
-            Returns the mocked object value.
-            </summary>
-        </member>
-        <member name="M:Moq.Mock`1.Setup(System.Linq.Expressions.Expression{System.Action{`0}})">
-            <summary>
-			Specifies a setup on the mocked type for a call to
-			to a void method.
-		</summary><remarks>
-			If more than one setup is specified for the same method or property,
-			the latest one wins and is the one that will be executed.
-		</remarks><param name="expression">Lambda expression that specifies the expected method invocation.</param><example group="setups">
-			<code>
-				var mock = new Mock&lt;IProcessor&gt;();
-				mock.Setup(x =&gt; x.Execute("ping"));
-			</code>
-		</example>
-        </member>
-        <member name="M:Moq.Mock`1.Setup``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})">
-            <summary>
-			Specifies a setup on the mocked type for a call to
-			to a value returning method.
-		</summary><typeparam name="TResult">Type of the return value. Typically omitted as it can be inferred from the expression.</typeparam><remarks>
-			If more than one setup is specified for the same method or property,
-			the latest one wins and is the one that will be executed.
-		</remarks><param name="expression">Lambda expression that specifies the method invocation.</param><example group="setups">
-			<code>
-				mock.Setup(x =&gt; x.HasInventory("Talisker", 50)).Returns(true);
-			</code>
-		</example>
-        </member>
-        <member name="M:Moq.Mock`1.SetupGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})">
-            <summary>
-			Specifies a setup on the mocked type for a call to
-			to a property getter.
-		</summary><remarks>
-			If more than one setup is set for the same property getter,
-			the latest one wins and is the one that will be executed.
-		</remarks><typeparam name="TProperty">Type of the property. Typically omitted as it can be inferred from the expression.</typeparam><param name="expression">Lambda expression that specifies the property getter.</param><example group="setups">
-			<code>
-				mock.SetupGet(x =&gt; x.Suspended)
-					 .Returns(true);
-			</code>
-		</example>
-        </member>
-        <member name="M:Moq.Mock`1.SetupSet``1(System.Action{`0})">
-            <summary>
-			Specifies a setup on the mocked type for a call to
-			to a property setter.
-		</summary><remarks>
-			If more than one setup is set for the same property setter,
-			the latest one wins and is the one that will be executed.
-			<para>
-				This overloads allows the use of a callback already
-				typed for the property type.
-			</para>
-		</remarks><typeparam name="TProperty">Type of the property. Typically omitted as it can be inferred from the expression.</typeparam><param name="setterExpression">Lambda expression that sets a property to a value.</param><example group="setups">
-			<code>
-				mock.SetupSet(x =&gt; x.Suspended = true);
-			</code>
-		</example>
-        </member>
-        <member name="M:Moq.Mock`1.SetupSet(System.Action{`0})">
-            <summary>
-			Specifies a setup on the mocked type for a call to
-			to a property setter.
-		</summary><remarks>
-			If more than one setup is set for the same property setter,
-			the latest one wins and is the one that will be executed.
-		</remarks><param name="setterExpression">Lambda expression that sets a property to a value.</param><example group="setups">
-			<code>
-				mock.SetupSet(x =&gt; x.Suspended = true);
-			</code>
-		</example>
-        </member>
-        <member name="M:Moq.Mock`1.SetupProperty``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})">
-            <summary>
-			Specifies that the given property should have "property behavior",
-			meaning that setting its value will cause it to be saved and
-			later returned when the property is requested. (this is also
-			known as "stubbing").
-		</summary><typeparam name="TProperty">
-			Type of the property, inferred from the property
-			expression (does not need to be specified).
-		</typeparam><param name="property">Property expression to stub.</param><example>
-			If you have an interface with an int property <c>Value</c>, you might
-			stub it using the following straightforward call:
-			<code>
-				var mock = new Mock&lt;IHaveValue&gt;();
-				mock.Stub(v =&gt; v.Value);
-			</code>
-			After the <c>Stub</c> call has been issued, setting and
-			retrieving the object value will behave as expected:
-			<code>
-				IHaveValue v = mock.Object;
-
-				v.Value = 5;
-				Assert.Equal(5, v.Value);
-			</code>
-		</example>
-        </member>
-        <member name="M:Moq.Mock`1.SetupProperty``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},``0)">
-            <summary>
-			Specifies that the given property should have "property behavior",
-			meaning that setting its value will cause it to be saved and
-			later returned when the property is requested. This overload
-			allows setting the initial value for the property. (this is also
-			known as "stubbing").
-		</summary><typeparam name="TProperty">
-			Type of the property, inferred from the property
-			expression (does not need to be specified).
-		</typeparam><param name="property">Property expression to stub.</param><param name="initialValue">Initial value for the property.</param><example>
-			If you have an interface with an int property <c>Value</c>, you might
-			stub it using the following straightforward call:
-			<code>
-				var mock = new Mock&lt;IHaveValue&gt;();
-				mock.SetupProperty(v =&gt; v.Value, 5);
-			</code>
-			After the <c>SetupProperty</c> call has been issued, setting and
-			retrieving the object value will behave as expected:
-			<code>
-				IHaveValue v = mock.Object;
-				// Initial value was stored
-				Assert.Equal(5, v.Value);
-
-				// New value set which changes the initial value
-				v.Value = 6;
-				Assert.Equal(6, v.Value);
-			</code>
-		</example>
-        </member>
-        <member name="M:Moq.Mock`1.SetupAllProperties">
-            <summary>
-			Specifies that the all properties on the mock should have "property behavior",
-			meaning that setting its value will cause it to be saved and
-			later returned when the property is requested. (this is also
-			known as "stubbing"). The default value for each property will be the
-			one generated as specified by the <see cref="P:Moq.Mock.DefaultValue"/> property for the mock.
-		</summary><remarks>
-			If the mock <see cref="P:Moq.Mock.DefaultValue"/> is set to <see cref="F:Moq.DefaultValue.Mock"/>,
-			the mocked default values will also get all properties setup recursively.
-		</remarks>
-        </member>
-        <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}})">
-            <summary>
-			Verifies that a specific invocation matching the given expression was performed on the mock. Use
-			in conjuntion with the default <see cref="F:Moq.MockBehavior.Loose"/>.
-		</summary><example group="verification">
-			This example assumes that the mock has been used, and later we want to verify that a given
-			invocation with specific parameters was performed:
-			<code>
-				var mock = new Mock&lt;IProcessor&gt;();
-				// exercise mock
-				//...
-				// Will throw if the test code didn't call Execute with a "ping" string argument.
-				mock.Verify(proc =&gt; proc.Execute("ping"));
-			</code>
-		</example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param>
-        </member>
-        <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}},Moq.Times)">
-            <summary>
-			Verifies that a specific invocation matching the given expression was performed on the mock. Use
-			in conjuntion with the default <see cref="F:Moq.MockBehavior.Loose"/>.
-		</summary><exception cref="T:Moq.MockException">
-			The invocation was not call the times specified by
-			<paramref name="times"/>.
-		</exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param>
-        </member>
-        <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}},System.String)">
-            <summary>
-			Verifies that a specific invocation matching the given expression was performed on the mock,
-			specifying a failure error message. Use in conjuntion with the default
-			<see cref="F:Moq.MockBehavior.Loose"/>.
-		</summary><example group="verification">
-			This example assumes that the mock has been used, and later we want to verify that a given
-			invocation with specific parameters was performed:
-			<code>
-				var mock = new Mock&lt;IProcessor&gt;();
-				// exercise mock
-				//...
-				// Will throw if the test code didn't call Execute with a "ping" string argument.
-				mock.Verify(proc =&gt; proc.Execute("ping"));
-			</code>
-		</example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param>
-        </member>
-        <member name="M:Moq.Mock`1.Verify(System.Linq.Expressions.Expression{System.Action{`0}},Moq.Times,System.String)">
-            <summary>
-			Verifies that a specific invocation matching the given expression was performed on the mock,
-			specifying a failure error message. Use in conjuntion with the default
-			<see cref="F:Moq.MockBehavior.Loose"/>.
-		</summary><exception cref="T:Moq.MockException">
-			The invocation was not call the times specified by
-			<paramref name="times"/>.
-		</exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param><param name="failMessage">Message to show if verification fails.</param>
-        </member>
-        <member name="M:Moq.Mock`1.Verify``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})">
-            <summary>
-			Verifies that a specific invocation matching the given expression was performed on the mock. Use
-			in conjuntion with the default <see cref="F:Moq.MockBehavior.Loose"/>.
-		</summary><example group="verification">
-			This example assumes that the mock has been used, and later we want to verify that a given
-			invocation with specific parameters was performed:
-			<code>
-				var mock = new Mock&lt;IWarehouse&gt;();
-				// exercise mock
-				//...
-				// Will throw if the test code didn't call HasInventory.
-				mock.Verify(warehouse =&gt; warehouse.HasInventory(TALISKER, 50));
-			</code>
-		</example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><typeparam name="TResult">Type of return value from the expression.</typeparam>
-        </member>
-        <member name="M:Moq.Mock`1.Verify``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},Moq.Times)">
-            <summary>
-			Verifies that a specific invocation matching the given
-			expression was performed on the mock. Use in conjuntion
-			with the default <see cref="F:Moq.MockBehavior.Loose"/>.
-		</summary><exception cref="T:Moq.MockException">
-			The invocation was not call the times specified by
-			<paramref name="times"/>.
-		</exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param><typeparam name="TResult">Type of return value from the expression.</typeparam>
-        </member>
-        <member name="M:Moq.Mock`1.Verify``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},System.String)">
-            <summary>
-			Verifies that a specific invocation matching the given
-			expression was performed on the mock, specifying a failure
-			error message.
-		</summary><example group="verification">
-			This example assumes that the mock has been used,
-			and later we want to verify that a given invocation
-			with specific parameters was performed:
-			<code>
-				var mock = new Mock&lt;IWarehouse&gt;();
-				// exercise mock
-				//...
-				// Will throw if the test code didn't call HasInventory.
-				mock.Verify(warehouse =&gt; warehouse.HasInventory(TALISKER, 50), "When filling orders, inventory has to be checked");
-			</code>
-		</example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param><typeparam name="TResult">Type of return value from the expression.</typeparam>
-        </member>
-        <member name="M:Moq.Mock`1.Verify``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},Moq.Times,System.String)">
-            <summary>
-			Verifies that a specific invocation matching the given
-			expression was performed on the mock, specifying a failure
-			error message.
-		</summary><exception cref="T:Moq.MockException">
-			The invocation was not call the times specified by
-			<paramref name="times"/>.
-		</exception><param name="expression">Expression to verify.</param><param name="times">The number of times a method is allowed to be called.</param><param name="failMessage">Message to show if verification fails.</param><typeparam name="TResult">Type of return value from the expression.</typeparam>
-        </member>
-        <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})">
-            <summary>
-			Verifies that a property was read on the mock.
-		</summary><example group="verification">
-			This example assumes that the mock has been used,
-			and later we want to verify that a given property
-			was retrieved from it:
-			<code>
-				var mock = new Mock&lt;IWarehouse&gt;();
-				// exercise mock
-				//...
-				// Will throw if the test code didn't retrieve the IsClosed property.
-				mock.VerifyGet(warehouse =&gt; warehouse.IsClosed);
-			</code>
-		</example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><typeparam name="TProperty">
-			Type of the property to verify. Typically omitted as it can
-			be inferred from the expression's return type.
-		</typeparam>
-        </member>
-        <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},Moq.Times)">
-            <summary>
-			Verifies that a property was read on the mock.
-		</summary><exception cref="T:Moq.MockException">
-			The invocation was not call the times specified by
-			<paramref name="times"/>.
-		</exception><param name="times">The number of times a method is allowed to be called.</param><param name="expression">Expression to verify.</param><typeparam name="TProperty">
-			Type of the property to verify. Typically omitted as it can
-			be inferred from the expression's return type.
-		</typeparam>
-        </member>
-        <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},System.String)">
-            <summary>
-			Verifies that a property was read on the mock, specifying a failure
-			error message.
-		</summary><example group="verification">
-			This example assumes that the mock has been used,
-			and later we want to verify that a given property
-			was retrieved from it:
-			<code>
-				var mock = new Mock&lt;IWarehouse&gt;();
-				// exercise mock
-				//...
-				// Will throw if the test code didn't retrieve the IsClosed property.
-				mock.VerifyGet(warehouse =&gt; warehouse.IsClosed);
-			</code>
-		</example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="expression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param><typeparam name="TProperty">
-			Type of the property to verify. Typically omitted as it can
-			be inferred from the expression's return type.
-		</typeparam>
-        </member>
-        <member name="M:Moq.Mock`1.VerifyGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},Moq.Times,System.String)">
-            <summary>
-			Verifies that a property was read on the mock, specifying a failure
-			error message.
-		</summary><exception cref="T:Moq.MockException">
-			The invocation was not call the times specified by
-			<paramref name="times"/>.
-		</exception><param name="times">The number of times a method is allowed to be called.</param><param name="expression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param><typeparam name="TProperty">
-			Type of the property to verify. Typically omitted as it can
-			be inferred from the expression's return type.
-		</typeparam>
-        </member>
-        <member name="M:Moq.Mock`1.VerifySet(System.Action{`0})">
-            <summary>
-			Verifies that a property was set on the mock.
-		</summary><example group="verification">
-			This example assumes that the mock has been used,
-			and later we want to verify that a given property
-			was set on it:
-			<code>
-				var mock = new Mock&lt;IWarehouse&gt;();
-				// exercise mock
-				//...
-				// Will throw if the test code didn't set the IsClosed property.
-				mock.VerifySet(warehouse =&gt; warehouse.IsClosed = true);
-			</code>
-		</example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="setterExpression">Expression to verify.</param>
-        </member>
-        <member name="M:Moq.Mock`1.VerifySet(System.Action{`0},Moq.Times)">
-            <summary>
-			Verifies that a property was set on the mock.
-		</summary><exception cref="T:Moq.MockException">
-			The invocation was not call the times specified by
-			<paramref name="times"/>.
-		</exception><param name="times">The number of times a method is allowed to be called.</param><param name="setterExpression">Expression to verify.</param>
-        </member>
-        <member name="M:Moq.Mock`1.VerifySet(System.Action{`0},System.String)">
-            <summary>
-			Verifies that a property was set on the mock, specifying
-			a failure message.
-		</summary><example group="verification">
-			This example assumes that the mock has been used,
-			and later we want to verify that a given property
-			was set on it:
-			<code>
-				var mock = new Mock&lt;IWarehouse&gt;();
-				// exercise mock
-				//...
-				// Will throw if the test code didn't set the IsClosed property.
-				mock.VerifySet(warehouse =&gt; warehouse.IsClosed = true, "Warehouse should always be closed after the action");
-			</code>
-		</example><exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception><param name="setterExpression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param>
-        </member>
-        <member name="M:Moq.Mock`1.VerifySet(System.Action{`0},Moq.Times,System.String)">
-            <summary>
-			Verifies that a property was set on the mock, specifying
-			a failure message.
-		</summary><exception cref="T:Moq.MockException">
-			The invocation was not call the times specified by
-			<paramref name="times"/>.
-		</exception><param name="times">The number of times a method is allowed to be called.</param><param name="setterExpression">Expression to verify.</param><param name="failMessage">Message to show if verification fails.</param>
-        </member>
-        <member name="M:Moq.Mock`1.As``1">
-            <summary>
-			Adds an interface implementation to the mock,
-			allowing setups to be specified for it.
-		</summary><remarks>
-			This method can only be called before the first use
-			of the mock <see cref="P:Moq.Mock`1.Object"/> property, at which
-			point the runtime type has already been generated
-			and no more interfaces can be added to it.
-			<para>
-				Also, <typeparamref name="TInterface"/> must be an
-				interface and not a class, which must be specified
-				when creating the mock instead.
-			</para>
-		</remarks><exception cref="T:System.InvalidOperationException">
-			The mock type
-			has already been generated by accessing the <see cref="P:Moq.Mock`1.Object"/> property.
-		</exception><exception cref="T:System.ArgumentException">
-			The <typeparamref name="TInterface"/> specified
-			is not an interface.
-		</exception><example>
-			The following example creates a mock for the main interface
-			and later adds <see cref="T:System.IDisposable"/> to it to verify
-			it's called by the consumer code:
-			<code>
-				var mock = new Mock&lt;IProcessor&gt;();
-				mock.Setup(x =&gt; x.Execute("ping"));
-
-				// add IDisposable interface
-				var disposable = mock.As&lt;IDisposable&gt;();
-				disposable.Setup(d =&gt; d.Dispose()).Verifiable();
-			</code>
-		</example><typeparam name="TInterface">Type of interface to cast the mock to.</typeparam>
-        </member>
-        <member name="M:Moq.Mock`1.Raise(System.Action{`0},System.EventArgs)">
-            <summary>
-			Raises the event referenced in <paramref name="eventExpression"/> using
-			the given <paramref name="sender"/> and <paramref name="args"/> arguments.
-		</summary><exception cref="T:System.ArgumentException">
-			The <paramref name="args"/> argument is
-			invalid for the target event invocation, or the <paramref name="eventExpression"/> is
-			not an event attach or detach expression.
-		</exception><example>
-			The following example shows how to raise a <see cref="E:System.ComponentModel.INotifyPropertyChanged.PropertyChanged"/> event:
-			<code>
-				var mock = new Mock&lt;IViewModel&gt;();
-
-				mock.Raise(x =&gt; x.PropertyChanged -= null, new PropertyChangedEventArgs("Name"));
-			</code>
-		</example><example>
-			This example shows how to invoke an event with a custom event arguments
-			class in a view that will cause its corresponding presenter to
-			react by changing its state:
-			<code>
-				var mockView = new Mock&lt;IOrdersView&gt;();
-				var presenter = new OrdersPresenter(mockView.Object);
-
-				// Check that the presenter has no selection by default
-				Assert.Null(presenter.SelectedOrder);
-
-				// Raise the event with a specific arguments data
-				mockView.Raise(v =&gt; v.SelectionChanged += null, new OrderEventArgs { Order = new Order("moq", 500) });
-
-				// Now the presenter reacted to the event, and we have a selected order
-				Assert.NotNull(presenter.SelectedOrder);
-				Assert.Equal("moq", presenter.SelectedOrder.ProductName);
-			</code>
-		</example>
-        </member>
-        <member name="M:Moq.Mock`1.Raise(System.Action{`0},System.Object[])">
-            <summary>
-			Raises the event referenced in <paramref name="eventExpression"/> using
-			the given <paramref name="sender"/> and <paramref name="args"/> arguments 
-			for a non-EventHandler typed event.
-		</summary><exception cref="T:System.ArgumentException">
-			The <paramref name="args"/> arguments are
-			invalid for the target event invocation, or the <paramref name="eventExpression"/> is
-			not an event attach or detach expression.
-		</exception><example>
-			The following example shows how to raise a custom event that does not adhere to 
-			the standard <c>EventHandler</c>:
-			<code>
-				var mock = new Mock&lt;IViewModel&gt;();
-
-				mock.Raise(x =&gt; x.MyEvent -= null, "Name", bool, 25);
-			</code>
-		</example>
-        </member>
-        <member name="M:Moq.Mock`1.Expect(System.Linq.Expressions.Expression{System.Action{`0}})">
-            <summary>
-            Obsolete.
-            </summary>
-        </member>
-        <member name="M:Moq.Mock`1.Expect``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})">
-            <summary>
-            Obsolete.
-            </summary>
-        </member>
-        <member name="M:Moq.Mock`1.ExpectGet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})">
-            <summary>
-            Obsolete.
-            </summary>
-        </member>
-        <member name="M:Moq.Mock`1.ExpectSet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})">
-            <summary>
-            Obsolete.
-            </summary>
-        </member>
-        <member name="M:Moq.Mock`1.ExpectSet``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},``0)">
-            <summary>
-            Obsolete.
-            </summary>
-        </member>
-        <member name="P:Moq.Mock`1.Object">
-            <summary>
-			Exposes the mocked object instance.
-		</summary>
-        </member>
-        <member name="T:Moq.MockLegacyExtensions">
-            <summary>
-            Provides legacy API members as extensions so that 
-            existing code continues to compile, but new code 
-            doesn't see then.
-            </summary>
-        </member>
-        <member name="M:Moq.MockLegacyExtensions.SetupSet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},``1)">
-            <summary>
-            Obsolete.
-            </summary>
-        </member>
-        <member name="M:Moq.MockLegacyExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},``1)">
-            <summary>
-            Obsolete.
-            </summary>
-        </member>
-        <member name="M:Moq.MockLegacyExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},``1,System.String)">
-            <summary>
-            Obsolete.
-            </summary>
-        </member>
-        <member name="T:Moq.FluentMockContext">
-            <summary>
-            Tracks the current mock and interception context.
-            </summary>
-        </member>
-        <member name="P:Moq.FluentMockContext.IsActive">
-            <summary>
-            Having an active fluent mock context means that the invocation 
-            is being performed in "trial" mode, just to gather the 
-            target method and arguments that need to be matched later 
-            when the actual invocation is made.
-            </summary>
-        </member>
-        <member name="T:Moq.MockDefaultValueProvider">
-            <summary>
-            A <see cref="T:Moq.IDefaultValueProvider"/> that returns an empty default value 
-            for non-mockeable types, and mocks for all other types (interfaces and 
-            non-sealed classes) that can be mocked.
-            </summary>
-        </member>
-        <member name="T:Moq.MockedEvent`1">
-            <summary>
-            Provides a typed <see cref="T:Moq.MockedEvent"/> for a 
-            specific type of <see cref="T:System.EventArgs"/>.
-            </summary>
-            <typeparam name="TEventArgs">The type of event arguments required by the event.</typeparam>
-            <remarks>
-            The mocked event can either be a <see cref="T:System.EventHandler`1"/> or custom 
-            event handler which follows .NET practice of providing <c>object sender, EventArgs args</c> 
-            kind of signature.
-            </remarks>
-        </member>
-        <member name="M:Moq.MockedEvent`1.Raise(`0)">
-            <summary>
-            Raises the associated event with the given 
-            event argument data.
-            </summary>
-            <param name="args">Data to pass to the event.</param>
-        </member>
-        <member name="M:Moq.MockedEvent`1.op_Implicit(Moq.MockedEvent{`0})~System.EventHandler{`0}">
-            <summary>
-            Provides support for attaching a <see cref="T:Moq.MockedEvent`1"/> to 
-            a generic <see cref="T:System.EventHandler`1"/> event.
-            </summary>
-            <param name="mockEvent">Event to convert.</param>
-        </member>
-        <member name="M:Moq.MockedEvent`1.Handle(System.Object,`0)">
-            <summary>
-            Provided solely to allow the interceptor to determine when the attached 
-            handler is coming from this mocked event so we can assign the 
-            corresponding EventInfo for it.
-            </summary>
-        </member>
-        <member name="T:Moq.MockExtensions">
-            <summary>
-            Provides additional methods on mocks.
-            </summary>
-            <devdoc>
-            Provided as extension methods as they confuse the compiler 
-            with the overloads taking Action.
-            </devdoc>
-        </member>
-        <member name="M:Moq.MockExtensions.SetupSet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})">
-            <summary>
-            Specifies a setup on the mocked type for a call to 
-            to a property setter, regardless of its value.
-            </summary>
-            <remarks>
-            If more than one setup is set for the same property setter, 
-            the latest one wins and is the one that will be executed.
-            </remarks>
-            <typeparam name="TProperty">Type of the property. Typically omitted as it can be inferred from the expression.</typeparam>
-            <typeparam name="T">Type of the mock.</typeparam>
-            <param name="mock">The target mock for the setup.</param>
-            <param name="expression">Lambda expression that specifies the property setter.</param>
-            <example group="setups">
-            <code>
-            mock.SetupSet(x =&gt; x.Suspended);
-            </code>
-            </example>
-            <devdoc>
-            This method is not legacy, but must be on an extension method to avoid 
-            confusing the compiler with the new Action syntax.
-            </devdoc>
-        </member>
-        <member name="M:Moq.MockExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})">
-            <summary>
-            Verifies that a property has been set on the mock, regarless of its value.
-            </summary>
-            <example group="verification">
-            This example assumes that the mock has been used, 
-            and later we want to verify that a given invocation 
-            with specific parameters was performed:
-            <code>
-            var mock = new Mock&lt;IWarehouse&gt;();
-            // exercise mock
-            //...
-            // Will throw if the test code didn't set the IsClosed property.
-            mock.VerifySet(warehouse =&gt; warehouse.IsClosed);
-            </code>
-            </example>
-            <exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception>
-            <param name="expression">Expression to verify.</param>
-            <param name="mock">The mock instance.</param>
-            <typeparam name="T">Mocked type.</typeparam>
-            <typeparam name="TProperty">Type of the property to verify. Typically omitted as it can 
-            be inferred from the expression's return type.</typeparam>
-        </member>
-        <member name="M:Moq.MockExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},System.String)">
-            <summary>
-            Verifies that a property has been set on the mock, specifying a failure  
-            error message. 
-            </summary>
-            <example group="verification">
-            This example assumes that the mock has been used, 
-            and later we want to verify that a given invocation 
-            with specific parameters was performed:
-            <code>
-            var mock = new Mock&lt;IWarehouse&gt;();
-            // exercise mock
-            //...
-            // Will throw if the test code didn't set the IsClosed property.
-            mock.VerifySet(warehouse =&gt; warehouse.IsClosed);
-            </code>
-            </example>
-            <exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception>
-            <param name="expression">Expression to verify.</param>
-            <param name="failMessage">Message to show if verification fails.</param>
-            <param name="mock">The mock instance.</param>
-            <typeparam name="T">Mocked type.</typeparam>
-            <typeparam name="TProperty">Type of the property to verify. Typically omitted as it can 
-            be inferred from the expression's return type.</typeparam>
-        </member>
-        <member name="M:Moq.MockExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},Moq.Times)">
-            <summary>
-            Verifies that a property has been set on the mock, regardless 
-            of the value but only the specified number of times.
-            </summary>
-            <example group="verification">
-            This example assumes that the mock has been used, 
-            and later we want to verify that a given invocation 
-            with specific parameters was performed:
-            <code>
-            var mock = new Mock&lt;IWarehouse&gt;();
-            // exercise mock
-            //...
-            // Will throw if the test code didn't set the IsClosed property.
-            mock.VerifySet(warehouse =&gt; warehouse.IsClosed);
-            </code>
-            </example>
-            <exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception>
-            <exception cref="T:Moq.MockException">The invocation was not call the times specified by
-            <paramref name="times"/>.</exception>
-            <param name="mock">The mock instance.</param>
-            <typeparam name="T">Mocked type.</typeparam>
-            <param name="times">The number of times a method is allowed to be called.</param>
-            <param name="expression">Expression to verify.</param>
-            <typeparam name="TProperty">Type of the property to verify. Typically omitted as it can 
-            be inferred from the expression's return type.</typeparam>
-        </member>
-        <member name="M:Moq.MockExtensions.VerifySet``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},Moq.Times,System.String)">
-            <summary>
-            Verifies that a property has been set on the mock, regardless 
-            of the value but only the specified number of times, and specifying a failure  
-            error message. 
-            </summary>
-            <example group="verification">
-            This example assumes that the mock has been used, 
-            and later we want to verify that a given invocation 
-            with specific parameters was performed:
-            <code>
-            var mock = new Mock&lt;IWarehouse&gt;();
-            // exercise mock
-            //...
-            // Will throw if the test code didn't set the IsClosed property.
-            mock.VerifySet(warehouse =&gt; warehouse.IsClosed);
-            </code>
-            </example>
-            <exception cref="T:Moq.MockException">The invocation was not performed on the mock.</exception>
-            <exception cref="T:Moq.MockException">The invocation was not call the times specified by
-            <paramref name="times"/>.</exception>
-            <param name="mock">The mock instance.</param>
-            <typeparam name="T">Mocked type.</typeparam>
-            <param name="times">The number of times a method is allowed to be called.</param>
-            <param name="failMessage">Message to show if verification fails.</param>
-            <param name="expression">Expression to verify.</param>
-            <typeparam name="TProperty">Type of the property to verify. Typically omitted as it can 
-            be inferred from the expression's return type.</typeparam>
-        </member>
-        <member name="T:Moq.Stub.StubExtensions">
-            <summary>
-            Legacy Stub stuff, moved to the core API.
-            </summary>
-        </member>
-        <member name="M:Moq.Stub.StubExtensions.Stub``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})">
-            <summary>
-            Obsolete. Use <see cref="M:Moq.Mock`1.SetupProperty``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})"/>.
-            </summary>
-        </member>
-        <member name="M:Moq.Stub.StubExtensions.Stub``2(Moq.Mock{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}},``1)">
-            <summary>
-            Obsolete. Use <see cref="M:Moq.Mock`1.SetupProperty``1(System.Linq.Expressions.Expression{System.Func{`0,``0}},``0)"/>.
-            </summary>
-        </member>
-        <member name="M:Moq.Stub.StubExtensions.StubAll``1(Moq.Mock{``0})">
-            <summary>
-            Obsolete. Use <see cref="M:Moq.Mock`1.SetupAllProperties"/>.
-            </summary>
-        </member>
-        <member name="T:Moq.Times">
-            <summary>
-            Defines the number of invocations allowed by a mocked method.
-            </summary>
-        </member>
-        <member name="M:Moq.Times.AtLeast(System.Int32)">
-            <summary>
-            Specifies that a mocked method should be invoked <paramref name="times"/> times as minimum.
-            </summary>
-            <param name="callCount">The minimun number of times.</param>
-            <returns>An object defining the allowed number of invocations.</returns>
-        </member>
-        <member name="M:Moq.Times.AtLeastOnce">
-            <summary>
-            Specifies that a mocked method should be invoked one time as minimum.
-            </summary>
-            <returns>An object defining the allowed number of invocations.</returns>
-        </member>
-        <member name="M:Moq.Times.AtMost(System.Int32)">
-            <summary>
-            Specifies that a mocked method should be invoked <paramref name="times"/> time as maximun.
-            </summary>
-            <param name="callCount">The maximun number of times.</param>
-            <returns>An object defining the allowed number of invocations.</returns>
-        </member>
-        <member name="M:Moq.Times.AtMostOnce">
-            <summary>
-            Specifies that a mocked method should be invoked one time as maximun.
-            </summary>
-            <returns>An object defining the allowed number of invocations.</returns>
-        </member>
-        <member name="M:Moq.Times.Between(System.Int32,System.Int32,Moq.Range)">
-            <summary>
-            Specifies that a mocked method should be invoked between <paramref name="from"/> and
-            <paramref name="to"/> times.
-            </summary>
-            <param name="callCountFrom">The minimun number of times.</param>
-            <param name="callCountTo">The maximun number of times.</param>
-            <param name="rangeKind">The kind of range. See <see cref="T:Moq.Range"/>.</param>
-            <returns>An object defining the allowed number of invocations.</returns>
-        </member>
-        <member name="M:Moq.Times.Exactly(System.Int32)">
-            <summary>
-            Specifies that a mocked method should be invoked exactly <paramref name="times"/> times.
-            </summary>
-            <param name="callCount">The times that a method or property can be called.</param>
-            <returns>An object defining the allowed number of invocations.</returns>
-        </member>
-        <member name="M:Moq.Times.Never">
-            <summary>
-            Specifies that a mocked method should not be invoked.
-            </summary>
-            <returns>An object defining the allowed number of invocations.</returns>
-        </member>
-        <member name="M:Moq.Times.Once">
-            <summary>
-            Specifies that a mocked method should be invoked exactly one time.
-            </summary>
-            <returns>An object defining the allowed number of invocations.</returns>
-        </member>
-    </members>
-</doc>