Diff
Deleted: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ChannelVariables.cs
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ClassDiagram1.cd (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ClassDiagram1.cd (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ClassDiagram1.cd 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1 @@
+
\ No newline at end of file
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/CoreDelegates.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/CoreDelegates.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/CoreDelegates.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+namespace FreeSWITCH
+{
+ public static class CoreDelegates
+ {
+ // Thunks - defining the delegate format for interop with unmanaged code. See global delegates in mod_managed.cpp.
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ public delegate bool ExecuteDelegate(string cmd, IntPtr streamH, IntPtr eventH);
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ public delegate bool ExecuteBackgroundDelegate(string cmd);
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ public delegate bool RunDelegate(string cmd, IntPtr session);
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ public delegate bool ReloadDelegate(string cmd);
+
+ // Internal delegates to be references from unmanaged code. These directly pass through to the public delegates.
+ // FreeSWITCH core will dump if the public delegates are set to null.
+ private static readonly ExecuteDelegate execute = (cmd, streamH, eventH) => CoreDelegates.Execute(cmd, streamH, eventH);
+ private static readonly ExecuteBackgroundDelegate executeBackground = (cmd) => CoreDelegates.ExecuteBackground(cmd);
+ private static readonly RunDelegate run = (cmd, session) => CoreDelegates.Run(cmd, session);
+ private static readonly ReloadDelegate reload = (cmd) => CoreDelegates.Reload(cmd);
+
+ // Public delegates. These are the core extension points to allow managed code to be executed from FreeSWITCH.
+ public static ExecuteDelegate Execute { get; set; }
+ public static ExecuteBackgroundDelegate ExecuteBackground { get; set; }
+ public static RunDelegate Run { get; set; }
+ public static ReloadDelegate Reload { get; set; }
+
+ // Extern InitManagedDelegates - executes function fo the same name in mod_managed.cpp.
+ //SWITCH_MOD_DECLARE_NONSTD(void) InitManagedDelegates(runFunction run, executeFunction execute, executeBackgroundFunction executeBackground, reloadFunction reload)
+ [DllImport("mod_managed", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ private static extern void InitManagedDelegates(RunDelegate run, ExecuteDelegate execute, ExecuteBackgroundDelegate executeBackground, ReloadDelegate reload);
+
+ public static void InitializeCoreDelegates()
+ {
+ CoreDelegates.InitManagedDelegates(CoreDelegates.run, CoreDelegates.execute, CoreDelegates.executeBackground, CoreDelegates.reload);
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/DefaultLoader.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/DefaultLoader.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/DefaultLoader.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace FreeSWITCH.Managed
+{
+ public class DefaultLoader
+ {
+ private DefaultModuleDirectorySupervisor directorySupervisor;
+ private ExecuteBackgroundCommandOnCollection executeBackgroundCommand;
+ private ExecuteCommandOnCollection executeCommand;
+ private ILoggerContainer logger;
+ private ReloadCommandOnCollection reloadCommand;
+ private AssemblyResolver resolver;
+ private RunCommandOnCollection runCommand;
+ // Thread-safe singleton implementation from: http://www.yoda.arachsys.com/csharp/singleton.html
+ static DefaultLoader() { DefaultLoader.Loader = DefaultServiceLocator.Container.Create<DefaultLoader>(); }
+
+ public static DefaultLoader Loader { get; private set; }
+
+ public DefaultLoader(RunCommandOnCollection runCommand,
+ ExecuteCommandOnCollection executeCommand,
+ ExecuteBackgroundCommandOnCollection executeBackgroundCommand,
+ ReloadCommandOnCollection reloadCommand,
+ AssemblyResolver resolver,
+ DefaultModuleDirectorySupervisor directorySupervisor,
+ ILoggerContainer logger)
+ {
+ this.logger = logger;
+ this.directorySupervisor = directorySupervisor;
+ this.resolver = resolver;
+ this.reloadCommand = reloadCommand;
+ this.executeBackgroundCommand = executeBackgroundCommand;
+ this.executeCommand = executeCommand;
+ this.runCommand = runCommand;
+ }
+
+ public bool Load()
+ {
+ CoreDelegates.Run = this.runCommand.Run;
+ CoreDelegates.Execute = this.executeCommand.Execute;
+ CoreDelegates.ExecuteBackground = this.executeBackgroundCommand.ExecuteBackground;
+ CoreDelegates.Reload = this.reloadCommand.Reload;
+
+ this.logger.Info("Load completed.");
+ this.resolver.AttachDefaultAssemblyResolver();
+ return this.directorySupervisor.Initialize();
+ }
+ }
+}
Deleted: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Demo.csx
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Diagrams/ModuleAppdomain.cd (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Diagrams/ModuleAppdomain.cd (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Diagrams/ModuleAppdomain.cd 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,138 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ClassDiagram MajorVersion="1" MinorVersion="1">
+ <Class Name="FreeSWITCH.ModuleRegistry" Collapsed="true">
+ <Position X="2" Y="6" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>AAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAA=</HashCode>
+ <FileName>ModuleAppdomains\ModuleRegistry.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.DefaultPluginExecutor" Collapsed="true">
+ <Position X="7.5" Y="4" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>ABAAAAAABAAEAAACAAEIAAQBAEAGAAAAAAAAABQAEAA=</HashCode>
+ <FileName>ModuleAppdomains\PluginTypes\DefaultPluginExecutor.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.AppPluginExecutor" Collapsed="true">
+ <Position X="8.5" Y="5.25" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>AAAAAAAAAAAAAAQAAAAAAAAAAAAAQAAAAAAAAAAAAAA=</HashCode>
+ <FileName>ModuleAppdomains\PluginTypes\AppPluginExecutor.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.ModuleAssemblyLoader" Collapsed="true">
+ <Position X="2.25" Y="2.5" Width="2" />
+ <TypeIdentifier>
+ <HashCode>AAAEgAAECAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode>
+ <FileName>ModuleAppdomains\ModuleAssemblyLoader.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.ScriptApiWrapper" Collapsed="true">
+ <Position X="6.75" Y="6.75" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>AAAAAAAIAAAAAAQAAAAAAAAAAAAAAAEAAAAAAAAAAAA=</HashCode>
+ <FileName>ModuleAppdomains\PluginTypes\ScriptApiWrapper.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.RunNotifyPluginHandler" Collapsed="true">
+ <Position X="5" Y="1.25" Width="2" />
+ <TypeIdentifier>
+ <HashCode>EAAAAACIAAAAAAQAgAAAAAAAAAAAAAAAAAAAAAAAAAI=</HashCode>
+ <FileName>ModuleAppdomains\PluginHandlers\RunNotifyPluginHandler.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.DefaultPluginHandler" Collapsed="true">
+ <Position X="5" Y="0.5" Width="2" />
+ <TypeIdentifier>
+ <HashCode>EAAAAACYAAgAAAQChEAAAAAQAAAAAAACAAQEACICAAI=</HashCode>
+ <FileName>ModuleAppdomains\PluginHandlers\DefaultPluginHandler.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.ScriptAppWrapper" Collapsed="true">
+ <Position X="6.75" Y="7.5" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAI=</HashCode>
+ <FileName>ModuleAppdomains\PluginTypes\ScriptAppWrapper.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.ModuleProxy" Collapsed="true">
+ <Position X="0.5" Y="1.75" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>AAAAAAAAAoIAAAAQAAAIAAAAAAAAAACAAAAAAAAAAAA=</HashCode>
+ <FileName>ModuleAppdomains\ModuleProxy.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.AssemblyCompiler" Collapsed="true">
+ <Position X="4.5" Y="4" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>gAAAAAAEAAAAAAACAAAAAABAIAAAAAAAAAAAAAAAAAA=</HashCode>
+ <FileName>ModuleAppdomains\AssemblyCompiler.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.ApiPluginExecutor" Collapsed="true">
+ <Position X="6.25" Y="5.25" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>AAAAAAAAAAAAAAAAAAAAAgAAAAAAQAAAAAAAAAAAABA=</HashCode>
+ <FileName>ModuleAppdomains\PluginTypes\ApiPluginExecutor.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.PluginHandlerOrchestrator" Collapsed="true">
+ <Position X="2.25" Y="1.25" Width="2.5" />
+ <TypeIdentifier>
+ <HashCode>EAAAAACIAAAAAAQAgAAAAAAAAAAAAABAAAAAAABAAAI=</HashCode>
+ <FileName>ModuleAppdomains\PluginHandlers\PluginHandlerOrchestrator.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.Script" Collapsed="true">
+ <Position X="8.75" Y="7" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>AAACAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAQAAAggEA=</HashCode>
+ <FileName>ModuleAppdomains\PluginTypes\Script.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.AppContext" Collapsed="true">
+ <Position X="9" Y="6" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>AAAAAAAAAAAAAQAAAAEAAAAAAAAgAAAAIAAAAAAAAAA=</HashCode>
+ <FileName>ModuleAppdomains\PluginTypes\AppContext.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.DllAssemblyComposer" Collapsed="true" BaseTypeListCollapsed="true">
+ <Position X="4.5" Y="2.5" Width="1.75" />
+ <TypeIdentifier>
+ <HashCode>AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAA=</HashCode>
+ <FileName>ModuleAppdomains\AssemblyComposers\DllAssemblyComposer.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.ScriptAssemblyComposer" Collapsed="true" BaseTypeListCollapsed="true">
+ <Position X="4.5" Y="3.25" Width="2" />
+ <TypeIdentifier>
+ <HashCode>AAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAACAA=</HashCode>
+ <FileName>ModuleAppdomains\AssemblyComposers\ScriptAssemblyComposer.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.ApiContext" Collapsed="true">
+ <Position X="5.75" Y="6" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>AgAAAAAAAAAAAAAAAAAAAAAAAgAoAAAAKAAAAAAAAAA=</HashCode>
+ <FileName>ModuleAppdomains\PluginTypes\ApiContext.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.ModuleServiceLocator" Collapsed="true">
+ <Position X="1.25" Y="5.25" Width="2.25" />
+ <TypeIdentifier>
+ <HashCode>AAAAAAQAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode>
+ <FileName>ModuleAppdomains\ModuleServiceLocator.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Font Name="Tahoma" Size="8.25" />
+</ClassDiagram>
\ No newline at end of file
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Diagrams/PrimaryAppdomain.cd (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Diagrams/PrimaryAppdomain.cd (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Diagrams/PrimaryAppdomain.cd 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,193 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ClassDiagram MajorVersion="1" MinorVersion="1" MembersFormat="FullSignature">
+ <Class Name="FreeSWITCH.Loader" Collapsed="true">
+ <Position X="0.5" Y="1.5" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>AAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode>
+ <FileName>Loader.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.CoreDelegates" Collapsed="true">
+ <Position X="0.5" Y="2.25" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>AAAAIgAIAAAgCAQAAAAEAAAAAAAIAAAACAAAAAAAAAI=</HashCode>
+ <FileName>CoreDelegates.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.Managed.DefaultLoader" Collapsed="true">
+ <Position X="2.25" Y="1.5" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>AAAAgBAAAAEAAAACACAAAAAAAAAAAAAAACAIAAiAAAA=</HashCode>
+ <FileName>DefaultLoader.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.Managed.DefaultRegistry" Collapsed="true">
+ <Position X="4.5" Y="2.5" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>AAIAAAAAAAAAAIAAAAAAAAAAAAABAAAAAAAAAAAAAAA=</HashCode>
+ <FileName>PrimaryAppdomain\DefaultRegistry.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.Managed.DefaultServiceLocator" Collapsed="true">
+ <Position X="4.25" Y="1.75" Width="1.75" />
+ <TypeIdentifier>
+ <HashCode>AAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode>
+ <FileName>PrimaryAppdomain\DefaultServiceLocator.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.Managed.AssemblyResolver" Collapsed="true">
+ <Position X="3" Y="6.25" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>AAAQAAAAAAAAAAACEAAAAAAAAAAAAAAIAAAEAAAAAEA=</HashCode>
+ <FileName>PrimaryAppdomain\Utility\AssemblyResolver.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.Managed.DefaultDirectoryController" Collapsed="true">
+ <Position X="8" Y="0.5" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>AAAAAEAAACAACAAAAAAAAAAAAAAAAACAAAAAAAAAAAA=</HashCode>
+ <FileName>PrimaryAppdomain\ModuleDirectory\DefaultDirectoryController.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.Managed.DefaultLogger" Collapsed="true">
+ <Position X="3.5" Y="5.25" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>AAAIAAAAAAAAAYAAAAAAABCAAAAAAAAAAAAAAEAAAAI=</HashCode>
+ <FileName>Logging\DefaultLogger.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.Managed.LoggerContainer" Collapsed="true">
+ <Position X="3" Y="4.5" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>AAIIAAABAAAAAYAAAAAABBCgAAAAAAAAAAAAAEAAAAI=</HashCode>
+ <FileName>Logging\LoggerContainer.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.Managed.DefaultModuleDirectorySupervisor" Collapsed="true">
+ <Position X="6.25" Y="1.25" Width="2.5" />
+ <TypeIdentifier>
+ <HashCode>AAAQAAAAAAAAAQACAAAAAAAAAAAAAAAIgAAAAAAAAAA=</HashCode>
+ <FileName>PrimaryAppdomain\ModuleDirectory\DefaultModuleDirectorySupervisor.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.Managed.ModuleFileLoadTimer" Collapsed="true">
+ <Position X="6.5" Y="1.75" Width="2" />
+ <TypeIdentifier>
+ <HashCode>AAACgAAAACAAAgAAAACAAAAAAAAACAAAIAAAAAAAAAA=</HashCode>
+ <FileName>PrimaryAppdomain\ModuleDirectory\ModuleFileLoadTimer.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.Managed.ModuleFileLoadQueue" Collapsed="true">
+ <Position X="6.75" Y="2.25" Width="1.75" />
+ <TypeIdentifier>
+ <HashCode>AAAQAAAAAAAAAQAAAAAAAAAAAAAAAgAAAgAAAAAAAIA=</HashCode>
+ <FileName>PrimaryAppdomain\ModuleDirectory\PluginFileLoadQueue.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.Managed.DefaultModuleLoader" Collapsed="true">
+ <Position X="6.75" Y="3" Width="1.75" />
+ <TypeIdentifier>
+ <HashCode>AAAAACAAAAAAAAACAAAAAAAAAQAAAAAEAAAAAAAAAAA=</HashCode>
+ <FileName>PrimaryAppdomain\ModuleDirectory\DefaultModuleLoader.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.Managed.ModuleList" Collapsed="true">
+ <Position X="7" Y="3.5" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>AAIAAAAAAAAACAAACAAABAAAAAAAAAAAIAAAAABAAAA=</HashCode>
+ <FileName>PrimaryAppdomain\ModuleDirectory\ModuleList.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.Managed.Module" Collapsed="true">
+ <Position X="7" Y="4.25" Width="1.5" />
+ <TypeIdentifier>
+ <HashCode>IAAQAAAACAAAASAAAAAABAAAAgAIAAAAAABAAAAAAAA=</HashCode>
+ <FileName>PrimaryAppdomain\ModuleDirectory\Module.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.Managed.DefaultAppDomainFactory" Collapsed="true">
+ <Position X="8.5" Y="4.25" Width="2.5" />
+ <TypeIdentifier>
+ <HashCode>AAAQAAAAAAAAAAAAABAAAACAAAAAAAAAAAAQAAAAAAA=</HashCode>
+ <FileName>PrimaryAppdomain\ModuleDirectory\DefaultAppDomainFactory.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.Managed.ManagedDirectoryWatcher" Collapsed="true">
+ <Position X="8.5" Y="2.25" Width="2.25" />
+ <TypeIdentifier>
+ <HashCode>AAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIA=</HashCode>
+ <FileName>PrimaryAppdomain\ModuleDirectory\ManagedDirectoryWatcher.cs</FileName>
+ </TypeIdentifier>
+ </Class>
+ <Class Name="FreeSWITCH.Managed.ExecuteBackgroundCommandOnCollection" Collapsed="true">
+ <Position X="6.25" Y="6.5" Width="3" />
+ <TypeIdentifier>
+ <HashCode>AAAAAgAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAA=</HashCode>
+ <FileName>PrimaryAppdomain\Commands\ExecuteBackgroundCommandOnCollection.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.Managed.ExecuteCommandOnCollection" Collapsed="true">
+ <Position X="6.25" Y="5.25" Width="2.5" />
+ <TypeIdentifier>
+ <HashCode>AAAAAgAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAgAAAAAA=</HashCode>
+ <FileName>PrimaryAppdomain\Commands\ExecuteCommandOnCollection.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.Managed.ReloadCommandOnCollection" Collapsed="true">
+ <Position X="6.25" Y="7.75" Width="2.25" />
+ <TypeIdentifier>
+ <HashCode>AAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAACAAAgAAAAAA=</HashCode>
+ <FileName>PrimaryAppdomain\Commands\ReloadCommandDirector.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.Managed.RunCommandOnCollection" Collapsed="true">
+ <Position X="6.25" Y="9" Width="2.25" />
+ <TypeIdentifier>
+ <HashCode>AAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAI=</HashCode>
+ <FileName>PrimaryAppdomain\Commands\RunCommandOnCollection.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.Managed.ExecuteBackgroundCommandOnModuleList" Collapsed="true">
+ <Position X="6.5" Y="7" Width="3" />
+ <TypeIdentifier>
+ <HashCode>AAAAAAAIAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAA=</HashCode>
+ <FileName>PrimaryAppdomain\Commands\ExecuteBackgroundCommandOnModuleList.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.Managed.ReloadCommandOnModuleList" Collapsed="true">
+ <Position X="6.5" Y="8.25" Width="2.25" />
+ <TypeIdentifier>
+ <HashCode>AAASAAAAAAAAAAAAAAAAAAAAAQAAAAAACAAAAAAAAAA=</HashCode>
+ <FileName>PrimaryAppdomain\Commands\ReloadCommandOnModuleList.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.Managed.ExecuteCommandOnModuleList" Collapsed="true">
+ <Position X="6.5" Y="5.75" Width="2.5" />
+ <TypeIdentifier>
+ <HashCode>AAAAAAAAAAAAAAQAAAAAAAAAAQAAAAAAAAAAAAAAAAA=</HashCode>
+ <FileName>PrimaryAppdomain\Commands\DefaultExecuteCommand.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Class Name="FreeSWITCH.Managed.RunCommandOnModuleList" Collapsed="true">
+ <Position X="6.5" Y="9.5" Width="2.25" />
+ <TypeIdentifier>
+ <HashCode>AAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAI=</HashCode>
+ <FileName>PrimaryAppdomain\Commands\RunCommandOnModuleList.cs</FileName>
+ </TypeIdentifier>
+ <Lollipop Position="0.2" />
+ </Class>
+ <Font Name="Tahoma" Size="8.25" />
+</ClassDiagram>
\ No newline at end of file
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ExtensionMethods/CommandStringExtensions.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ExtensionMethods/CommandStringExtensions.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ExtensionMethods/CommandStringExtensions.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+using System.Reflection;
+
+namespace FreeSWITCH.Managed
+{
+ public static class CommandStringExtensions
+ {
+ public static string[] FreeSWITCHCommandParse(this string command)
+ {
+ char[] spaceArray = new[] { ' ' };
+ if (string.IsNullOrEmpty(command))
+ {
+ return null;
+ }
+ var args = command.Split(spaceArray, 2, StringSplitOptions.RemoveEmptyEntries);
+ if (args.Length == 0 || string.IsNullOrEmpty(args[0]) || string.IsNullOrEmpty(args[0].Trim()))
+ {
+ return null;
+ }
+ if (args.Length == 1)
+ {
+ return new[] { args[0], "" };
+ }
+ else
+ {
+ return args;
+ }
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ExtensionMethods/EntryPointExtensionMethods.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ExtensionMethods/EntryPointExtensionMethods.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ExtensionMethods/EntryPointExtensionMethods.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.CodeDom;
+using System.CodeDom.Compiler;
+using System.IO;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace FreeSWITCH
+{
+ public static class EntryPointExtensionMethods
+ {
+ public static void CallEntryPoint(this MethodInfo entryPoint)
+ {
+ try
+ {
+ var internalDelegate = entryPoint.GetEntryDelegate();
+ internalDelegate();
+ }
+ catch { }
+ }
+
+ public static Action GetEntryDelegate(this MethodInfo entryPoint)
+ {
+ if (!entryPoint.IsPublic || !entryPoint.DeclaringType.IsPublic)
+ {
+ Log.WriteLine(LogLevel.Error, "Entry point: {0}.{1} is not public. This may cause errors with Mono.",
+ entryPoint.DeclaringType.FullName, entryPoint.Name);
+ }
+ var dm = new DynamicMethod(entryPoint.DeclaringType.Assembly.GetName().Name + "_entrypoint_" + entryPoint.DeclaringType.FullName + entryPoint.Name, null, null, true);
+ var il = dm.GetILGenerator();
+ var args = entryPoint.GetParameters();
+ if (args.Length > 1) throw new ArgumentException("Cannot handle entry points with more than 1 parameter.");
+ if (args.Length == 1)
+ {
+ if (args[0].ParameterType != typeof(string[])) throw new ArgumentException("Entry point paramter must be a string array.");
+ il.Emit(OpCodes.Ldc_I4_0);
+ il.Emit(OpCodes.Newarr, typeof(string));
+ }
+ il.EmitCall(OpCodes.Call, entryPoint, null);
+ if (entryPoint.ReturnType != typeof(void))
+ {
+ il.Emit(OpCodes.Pop);
+ }
+ il.Emit(OpCodes.Ret);
+ return (Action)dm.CreateDelegate(typeof(Action));
+ }
+
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ExtensionMethods/Extensions.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ExtensionMethods/Extensions.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ExtensionMethods/Extensions.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,47 @@
+/*
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_managed
+ * Copyright (C) 2008, Michael Giagnocavo <mgg@giagnocavo.net>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_managed
+ *
+ * The Initial Developer of the Original Code is
+ * Michael Giagnocavo <mgg@giagnocavo.net>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Michael Giagnocavo <mgg@giagnocavo.net>
+ *
+ * Extensions.cs -- Helper extensions
+ *
+ */
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace System.Linq
+{
+ internal static class EnumerableExtensions
+ {
+ public static void ForEach<T>(this IEnumerable<T> source, Action<T> f)
+ {
+ foreach (var item in source) {
+ f(item);
+ }
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ExtensionMethods/PathExtensions.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ExtensionMethods/PathExtensions.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ExtensionMethods/PathExtensions.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.CodeDom;
+using System.CodeDom.Compiler;
+using System.IO;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace FreeSWITCH
+{
+ public static class PathExtensions
+ {
+ public static string GetLoweredFileExtension(this string path)
+ {
+ return Path.GetExtension(path).ToLowerInvariant();
+ }
+ }
+}
Deleted: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Extensions.cs
Modified: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/FreeSWITCH.Managed.csproj (15280 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/FreeSWITCH.Managed.csproj 2009-10-29 23:35:08 UTC (rev 15280)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/FreeSWITCH.Managed.csproj 2009-10-30 00:09:12 UTC (rev 15281)
@@ -47,19 +47,103 @@
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
+ <Compile Include="ExtensionMethods\Extensions.cs" />
+ <Compile Include="Logging\ILoggerContainer.cs" />
+ <Compile Include="ModuleAppdomains\AssemblyComposers\DllAssemblyComposer.cs" />
+ <Compile Include="ModuleAppdomains\AssemblyComposers\ScriptAssemblyComposer.cs" />
+ <Compile Include="ExtensionMethods\PathExtensions.cs" />
+ <Compile Include="ModuleAppdomains\IAssemblyCompiler.cs" />
+ <Compile Include="ModuleAppdomains\IModuleAssemblyLoader.cs" />
+ <Compile Include="ModuleAppdomains\IModuleProxy.cs" />
+ <Compile Include="ModuleAppdomains\PluginHandlers\IPluginHandlerOrchestrator.cs" />
+ <Compile Include="Native\FSUtil.cs" />
+ <Compile Include="PrimaryAppdomain\ModuleDirectory\IDefaultAppDomainFactory.cs" />
+ <Compile Include="PrimaryAppdomain\ModuleDirectory\IModuleList.cs" />
+ <Compile Include="PrimaryAppdomain\ModuleDirectory\IPrimaryAppdomainExtension.cs" />
+ <Compile Include="PrimaryAppdomain\ModuleDirectory\ModuleProxyTypeDictionary.cs" />
+ <Compile Include="PrimaryAppdomain\ModuleDirectory\PrimaryDomainExtensionModuleLoader.cs" />
+ <Compile Include="PrimaryAppdomain\ModuleDirectory\SelectiveModuleLoader.cs" />
+ <Compile Include="PrimaryAppdomain\Utility\AssemblyResolver.cs" />
+ <Compile Include="PrimaryAppdomain\ModuleDirectory\DefaultModuleLoader.cs" />
+ <Compile Include="PrimaryAppdomain\DefaultRegistry.cs" />
+ <Compile Include="PrimaryAppdomain\DefaultServiceLocator.cs" />
+ <Compile Include="PrimaryAppdomain\ModuleDirectory\IModuleLoader.cs" />
+ <Compile Include="Types\Interfaces\IObjectContainer.cs" />
+ <Compile Include="Types\Interfaces\ISynchronizedDictionary.cs" />
+ <Compile Include="Types\Interfaces\ISynchronizedList.cs" />
+ <Compile Include="Types\ObjectContainer.cs" />
+ <Compile Include="ModuleAppdomains\PluginTypes\ApiBackgroundContext.cs" />
+ <Compile Include="ModuleAppdomains\PluginTypes\ApiContext.cs" />
+ <Compile Include="ModuleAppdomains\PluginTypes\ApiPluginExecutor.cs" />
+ <Compile Include="ModuleAppdomains\PluginTypes\AppContext.cs" />
+ <Compile Include="ModuleAppdomains\PluginTypes\AppPluginExecutor.cs" />
<Compile Include="AssemblyInfo.cs" />
- <Compile Include="ChannelVariables.cs" />
- <Compile Include="ManagedSession.cs" />
+ <Compile Include="ModuleAppdomains\AssemblyCompiler.cs" />
+ <Compile Include="ModuleAppdomains\AssemblyComposers\AssemblyComposerDictionary.cs" />
+ <Compile Include="Native\ChannelVariables.cs" />
+ <Compile Include="ExtensionMethods\CommandStringExtensions.cs" />
+ <Compile Include="PrimaryAppdomain\ModuleDirectory\DefaultAppDomainFactory.cs" />
+ <Compile Include="PrimaryAppdomain\ModuleDirectory\DefaultDirectoryController.cs" />
+ <Compile Include="PrimaryAppdomain\Commands\ExecuteBackgroundCommandOnModuleList.cs" />
+ <Compile Include="PrimaryAppdomain\Commands\DefaultExecuteCommand.cs" />
+ <Compile Include="Logging\DefaultLogger.cs" />
+ <Compile Include="PrimaryAppdomain\Commands\ReloadCommandOnModuleList.cs" />
+ <Compile Include="PrimaryAppdomain\Commands\RunCommandOnModuleList.cs" />
+ <Compile Include="PrimaryAppdomain\ModuleDirectory\IDirectoryController.cs" />
+ <Compile Include="PrimaryAppdomain\ModuleDirectory\ManagedDirectoryWatcher.cs">
+ <SubType>Component</SubType>
+ </Compile>
+ <Compile Include="PrimaryAppdomain\ModuleDirectory\PluginFileLoadQueue.cs" />
+ <Compile Include="PrimaryAppdomain\ModuleDirectory\ModuleFileLoadTimer.cs" />
+ <Compile Include="PrimaryAppdomain\Commands\ExecuteBackgroundCommandOnCollection.cs" />
+ <Compile Include="PrimaryAppdomain\Commands\ExecuteCommandOnCollection.cs" />
+ <Compile Include="PrimaryAppdomain\Commands\IExecuteBackgroundCommand.cs" />
+ <Compile Include="PrimaryAppdomain\Commands\IExecuteCommand.cs" />
+ <Compile Include="Logging\ILogger.cs" />
+ <Compile Include="PrimaryAppdomain\Commands\IReloadCommand.cs" />
+ <Compile Include="PrimaryAppdomain\Commands\IRunCommand.cs" />
+ <Compile Include="Logging\LoggerContainer.cs" />
+ <Compile Include="PrimaryAppdomain\Commands\ReloadCommandDirector.cs" />
+ <Compile Include="PrimaryAppdomain\Commands\RunCommandOnCollection.cs" />
+ <Compile Include="CoreDelegates.cs" />
+ <Compile Include="DefaultLoader.cs" />
+ <Compile Include="ExtensionMethods\EntryPointExtensionMethods.cs" />
+ <Compile Include="ModuleAppdomains\PluginHandlers\DefaultPluginHandler.cs" />
+ <Compile Include="ModuleAppdomains\PluginTypes\IApiPlugin.cs" />
+ <Compile Include="ModuleAppdomains\PluginTypes\IAppPlugin.cs" />
+ <Compile Include="ModuleAppdomains\AssemblyComposers\IAssemblyComposer.cs" />
+ <Compile Include="ModuleAppdomains\PluginTypes\ILoadNotificationPlugin.cs" />
+ <Compile Include="ModuleAppdomains\ModuleServiceLocator.cs" />
+ <Compile Include="ModuleAppdomains\ModuleRegistry.cs" />
+ <Compile Include="ModuleAppdomains\PluginHandlers\IPluginHandler.cs" />
+ <Compile Include="ModuleAppdomains\ModuleAssemblyLoader.cs" />
+ <Compile Include="ModuleAppdomains\PluginHandlers\PluginHandlerOrchestrator.cs" />
+ <Compile Include="ModuleAppdomains\PluginHandlers\RunNotifyPluginHandler.cs" />
+ <Compile Include="Types\Exceptions\ModuleDoesNotReferenceFreeswitchManagedDllException.cs" />
+ <Compile Include="ModuleAppdomains\PluginTypes\DefaultPluginExecutor.cs" />
+ <Compile Include="ModuleAppdomains\PluginTypes\Script.cs" />
+ <Compile Include="ModuleAppdomains\PluginTypes\ScriptApiWrapper.cs" />
+ <Compile Include="ModuleAppdomains\PluginTypes\ScriptAppWrapper.cs" />
+ <Compile Include="ModuleAppdomains\PluginTypes\ScriptContextType.cs" />
+ <Compile Include="PrimaryAppdomain\ModuleDirectory\Module.cs" />
+ <Compile Include="ModuleAppdomains\PluginTypes\PluginOptions.cs" />
+ <Compile Include="PrimaryAppdomain\ModuleDirectory\ModuleList.cs" />
+ <Compile Include="Types\Exceptions\RunNotifyException.cs" />
+ <Compile Include="Types\Exceptions\ScriptDoesNotCompileException.cs" />
+ <Compile Include="Types\SynchronizedDictionary.cs" />
+ <Compile Include="Types\SynchronizedList.cs" />
+ <Compile Include="PrimaryAppdomain\ModuleDirectory\DefaultModuleDirectorySupervisor.cs" />
+ <Compile Include="Native\ManagedSession.cs" />
<Compile Include="Loader.cs" />
- <Compile Include="Extensions.cs" />
- <Compile Include="Log.cs" />
- <None Include="Demo.csx" />
- <Compile Include="PluginInterfaces.cs" />
- <Compile Include="PluginManager.cs" />
- <Compile Include="ScriptPluginManager.cs" />
+ <Compile Include="Native\Log.cs" />
+ <Compile Include="ModuleAppdomains\PluginTypes\IPluginOptionsProvider.cs" />
+ <Compile Include="ModuleAppdomains\ModuleProxy.cs" />
<Compile Include="swig.cs" />
- <Compile Include="Util.cs" />
</ItemGroup>
+ <ItemGroup>
+ <None Include="Diagrams\ModuleAppdomain.cd" />
+ <None Include="Diagrams\PrimaryAppdomain.cd" />
+ </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.
Modified: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/FreeSWITCH.Managed.dll
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/FreeSWITCH.Managed.pcpnet
(Binary files differ)
Modified: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/FreeSWITCH.Managed.pdb
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/FreeSWITCH.Managed.suo
(Binary files differ)
Modified: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Loader.cs (15280 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Loader.cs 2009-10-29 23:35:08 UTC (rev 15280)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Loader.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -38,374 +38,20 @@
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
+using FreeSWITCH.Managed;
-namespace FreeSWITCH {
- internal static class Loader {
-
- // Thunks
- [UnmanagedFunctionPointer(CallingConvention.Cdecl)] delegate bool ExecuteDelegate(string cmd, IntPtr streamH, IntPtr eventH);
- [UnmanagedFunctionPointer(CallingConvention.Cdecl)] delegate bool ExecuteBackgroundDelegate(string cmd);
- [UnmanagedFunctionPointer(CallingConvention.Cdecl)] delegate bool RunDelegate(string cmd, IntPtr session);
- [UnmanagedFunctionPointer(CallingConvention.Cdecl)] delegate bool ReloadDelegate(string cmd);
- static readonly ExecuteDelegate _execute = Execute;
- static readonly ExecuteBackgroundDelegate _executeBackground = ExecuteBackground;
- static readonly RunDelegate _run = Run;
- static readonly ReloadDelegate _reload = Reload;
- //SWITCH_MOD_DECLARE_NONSTD(void) InitManagedDelegates(runFunction run, executeFunction execute, executeBackgroundFunction executeBackground, reloadFunction reload)
- [DllImport("mod_managed", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
- static extern void InitManagedDelegates(RunDelegate run, ExecuteDelegate execute, ExecuteBackgroundDelegate executeBackground, ReloadDelegate reload);
-
- static readonly object loaderLock = new object();
-
- static string managedDir;
- static string shadowDir;
-
- public static bool Load() {
- managedDir = Path.Combine(Native.freeswitch.SWITCH_GLOBAL_dirs.mod_dir, "managed");
- shadowDir = Path.Combine(managedDir, "shadow");
- if (Directory.Exists(shadowDir)) {
- Directory.Delete(shadowDir, true);
- Directory.CreateDirectory(shadowDir);
- }
-
- Log.WriteLine(LogLevel.Debug, "FreeSWITCH.Managed loader is starting with directory '{0}'.", managedDir);
- if (!Directory.Exists(managedDir)) {
- Log.WriteLine(LogLevel.Error, "Managed directory not found: {0}", managedDir);
- return false;
- }
-
- AppDomain.CurrentDomain.AssemblyResolve += (_, rargs) => {
- Log.WriteLine(LogLevel.Info, "Resolving assembly '{0}'.", rargs.Name);
- if (rargs.Name == Assembly.GetExecutingAssembly().FullName) return Assembly.GetExecutingAssembly();
- var parts = rargs.Name.Split(',');
- var path = Path.Combine(managedDir, parts[0] + ".dll");
- Log.WriteLine(LogLevel.Info, "Resolving to: '" + path + "'.");
- return File.Exists(path) ? Assembly.LoadFile(path) : null;
- };
-
- InitManagedDelegates(_run, _execute, _executeBackground, _reload);
-
- configureWatcher();
-
- // Initial load
- var allFiles = Directory.GetFiles(managedDir);
- foreach (var file in allFiles) {
- try {
- loadFile(file);
- } catch (Exception ex) {
- Log.WriteLine(LogLevel.Error, "Exception loading file {0}: " + ex.ToString(), file);
- }
- }
- initialLoadComplete = true;
- return true;
+namespace FreeSWITCH
+{
+ public static class Loader
+ {
+ // Load() method is found by reflection and run from mod_managed.cpp on module load. The only purpose of this method
+ // is to pass pointers to the internal delegates to the unmanaged code and to instantiate a managed class to handle
+ // calls to those delegates.
+ public static bool Load()
+ {
+ //Log.WriteLine(LogLevel.Alert, "Starting Loader");
+ CoreDelegates.InitializeCoreDelegates();
+ return DefaultLoader.Loader.Load();
}
-
-
- // *** File watcher for changes
- // Cheap queue hack is used because multiple related files can generate a bunch of changes
- // and a single file can also trigger a few notifications. With a simple queue, these get batched
- static readonly object watcherLock = new object();
- static FileSystemWatcher watcher;
- static System.Threading.Timer watcherTimer;
- static HashSet<string> watcherFiles = new HashSet<string>();
- static void configureWatcher() {
- watcher = new FileSystemWatcher(managedDir);
- watcher.IncludeSubdirectories = false;
- watcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite;
- watcher.EnableRaisingEvents = true;
- watcher.Changed += watcher_Changed;
- watcher.Created += watcher_Changed;
- watcher.Deleted += watcher_Changed;
- watcher.Renamed += watcher_Changed;
- watcherTimer = new System.Threading.Timer(_ => {
- lock (watcherLock) {
- foreach (var file in watcherFiles) {
- try {
- loadFile(file);
- } catch (Exception ex) {
- Log.WriteLine(LogLevel.Error, "Exception loading change from {0}: {1}", file, ex.ToString());
- }
- }
- watcherFiles.Clear();
- }
- });
- watcherTimer.Change(1000, 1000);
- }
-
- static void watcher_Changed(object sender, FileSystemEventArgs e) {
- Action<string> queueFile = fileName => {
- var currentPi = pluginInfos.FirstOrDefault(p => string.Compare(fileName, p.FileName, StringComparison.OrdinalIgnoreCase) == 0);
- if (currentPi != null) {
- var noReload = currentPi.Manager.ApiExecutors.Any(x => (x.PluginOptions & PluginOptions.NoAutoReload) == PluginOptions.NoAutoReload) ||
- currentPi.Manager.AppExecutors.Any(x => (x.PluginOptions & PluginOptions.NoAutoReload) == PluginOptions.NoAutoReload);
- if (noReload) return;
- }
- lock (watcherLock) {
- watcherFiles.Add(fileName);
- }
- };
- try {
- if (!initialLoadComplete) return;
- var file = e.FullPath;
- var isConfig = Path.GetExtension(file).ToLowerInvariant() == ".config";
- if (isConfig) {
- queueFile(Path.ChangeExtension(file, null));
- } else {
- queueFile(file);
- }
- } catch (Exception ex) {
- Log.WriteLine(LogLevel.Critical, "Unhandled exception watching for changes: " + ex.ToString());
- }
- }
-
- static volatile bool initialLoadComplete = false;
- static readonly List<PluginInfo> pluginInfos = new List<PluginInfo>();
- // Volatile cause we haven't streamlined all the locking
- // These dictionaries are never mutated; the reference is changed instead
- static volatile Dictionary<string, AppPluginExecutor> appExecs = new Dictionary<string, AppPluginExecutor>(StringComparer.OrdinalIgnoreCase);
- static volatile Dictionary<string, ApiPluginExecutor> apiExecs = new Dictionary<string, ApiPluginExecutor>(StringComparer.OrdinalIgnoreCase);
-
- static Dictionary<string, AppPluginExecutor> getAppExecs() {
- lock (loaderLock) {
- return appExecs;
- }
- }
- static Dictionary<string, ApiPluginExecutor> getApiExecs() {
- lock (loaderLock) {
- return apiExecs;
- }
- }
-
- class PluginInfo {
- public string FileName { get; set; }
- public AppDomain Domain { get; set; }
- public PluginManager Manager { get; set; }
- }
-
- static int appDomainCount = 0;
- static void loadFile(string fileName) {
- // Attempts to load the file. On failure, it will call unload.
- // Loading part does not take out a lock.
- // Lock is only done after loading is finished and dictionaries need updating.
-
- // We might get a load for a file that's no longer there. Just unload the old one.
- if (!File.Exists(fileName)) {
- unloadFile(fileName);
- return;
- }
-
- Type pmType;
- switch (Path.GetExtension(fileName).ToLowerInvariant()) {
- case ".dll":
- pmType = typeof(AsmPluginManager);
- break;
- case ".exe": // TODO these need to come from config
- case ".fsx":
- case ".vbx":
- case ".csx":
- case ".jsx":
- pmType = typeof(ScriptPluginManager);
- break;
- default:
- pmType = null;
- break;
- }
- if (pmType == null) return;
-
- // App domain setup
- var setup = new AppDomainSetup();
- if (File.Exists(fileName + ".config")) {
- setup.ConfigurationFile = fileName + ".config";
- }
- setup.ApplicationBase = Native.freeswitch.SWITCH_GLOBAL_dirs.mod_dir;
- setup.ShadowCopyDirectories = managedDir + ";";
- setup.LoaderOptimization = LoaderOptimization.MultiDomainHost; // TODO: would MultiDomain work better since FreeSWITCH.Managed isn't gac'd?
- setup.CachePath = shadowDir;
- setup.ShadowCopyFiles = "true";
- setup.PrivateBinPath = "managed";
-
- // Create domain and load PM inside
- System.Threading.Interlocked.Increment(ref appDomainCount);
- setup.ApplicationName = Path.GetFileName(fileName) + "_" + appDomainCount;
- var domain = AppDomain.CreateDomain(setup.ApplicationName, null, setup);
-
- PluginManager pm;
- try {
- pm = (PluginManager)domain.CreateInstanceAndUnwrap(pmType.Assembly.FullName, pmType.FullName, null);
- if (!pm.Load(fileName)) {
- AppDomain.Unload(domain);
- unloadFile(fileName);
- return;
- }
- } catch (Exception ex) {
- // On an exception, we will unload the current file so an old copy doesnt stay active
- Log.WriteLine(LogLevel.Alert, "Exception loading {0}: {1}", fileName, ex.ToString());
- AppDomain.Unload(domain);
- unloadFile(fileName);
- return;
- }
-
- // Update dictionaries atomically
- lock (loaderLock) {
- unloadFile(fileName);
-
- var pi = new PluginInfo { FileName = fileName, Domain = domain, Manager = pm };
- pluginInfos.Add(pi);
- var newAppExecs = new Dictionary<string, AppPluginExecutor>(appExecs, StringComparer.OrdinalIgnoreCase);
- var newApiExecs = new Dictionary<string, ApiPluginExecutor>(apiExecs, StringComparer.OrdinalIgnoreCase);
- pm.AppExecutors.ForEach(x => x.Aliases.ForEach(y => newAppExecs[y] = x));
- pm.ApiExecutors.ForEach(x => x.Aliases.ForEach(y => newApiExecs[y] = x));
- appExecs = newAppExecs;
- apiExecs = newApiExecs;
- Action<PluginExecutor, string> printLoaded = (pe, type) => {
- var aliases = pe.Aliases.Aggregate((acc, x) => acc += ", " + x);
- Log.WriteLine(LogLevel.Notice, "Loaded {3} {0}, aliases '{1}', into domain {2}.", pe.Name, aliases, pi.Domain.FriendlyName, type);
- };
- pm.AppExecutors.ForEach(x => printLoaded(x, "App"));
- pm.ApiExecutors.ForEach(x => printLoaded(x, "Api"));
- Log.WriteLine(LogLevel.Info, "Finished loading {0} into domain {1}.", pi.FileName, pi.Domain.FriendlyName);
- }
- }
-
- static void unloadFile(string fileName) {
- List<PluginInfo> pisToRemove;
- lock (loaderLock) {
- pisToRemove = pluginInfos.Where(x => string.Compare(fileName, x.FileName, StringComparison.OrdinalIgnoreCase) == 0).ToList();
- if (pisToRemove.Count == 0) return; // Done
-
- var apisToRemove = pisToRemove.SelectMany(x => x.Manager.ApiExecutors).ToList();
- var appsToRemove = pisToRemove.SelectMany(x => x.Manager.AppExecutors).ToList();
- pluginInfos.RemoveAll(pisToRemove.Contains);
- appExecs = appExecs.Where(x => !appsToRemove.Contains(x.Value)).ToDictionary(x => x.Key, x => x.Value, StringComparer.OrdinalIgnoreCase);
- apiExecs = apiExecs.Where(x => !apisToRemove.Contains(x.Value)).ToDictionary(x => x.Key, x => x.Value, StringComparer.OrdinalIgnoreCase);
-
- Action<PluginExecutor, string> printRemoved = (pe, type) => {
- Log.WriteLine(LogLevel.Notice, "Unloaded {0} {1} (file {2}).", type, pe.Name, fileName);
- };
- apisToRemove.ForEach(x => printRemoved(x, "API"));
- appsToRemove.ForEach(x => printRemoved(x, "App"));
- }
-
- pisToRemove.ForEach(pi => {
- var t = new System.Threading.Thread(() => {
- var friendlyName = pi.Domain.FriendlyName;
- Log.WriteLine(LogLevel.Info, "Starting to unload {0}, domain {1}.", pi.FileName, friendlyName);
- try {
- var d = pi.Domain;
- pi.Manager.BlockUntilUnloadIsSafe();
- pi.Manager = null;
- pi.Domain = null;
- // This can crash if there is still sessions in the appdomain. Plugin code should use dispose properly.
- AppDomain.Unload(d);
- Log.WriteLine(LogLevel.Info, "Unloaded {0}, domain {1}.", pi.FileName, friendlyName);
- } catch (Exception ex) {
- Log.WriteLine(LogLevel.Alert, "Could not unload {0}, domain {1}: {2}", pi.FileName, friendlyName, ex.ToString());
- }
- });
- t.Priority = System.Threading.ThreadPriority.BelowNormal;
- t.IsBackground = true;
- t.Start();
- });
- }
-
- static bool Reload(string cmd) {
- try {
- if (Path.IsPathRooted(cmd)) {
- loadFile(cmd);
- } else {
- loadFile(Path.Combine(managedDir, cmd));
- }
- return true;
- } catch (Exception ex) {
- Log.WriteLine(LogLevel.Error, "Error reloading {0}: {1}", cmd, ex.ToString());
- return false;
- }
- }
-
- // ******* Execution
-
- static readonly char[] spaceArray = new[] { ' ' };
- /// <summary>Returns a string couple containing the module name and arguments</summary>
- static string[] parseCommand(string command) {
- if (string.IsNullOrEmpty(command)) {
- Log.WriteLine(LogLevel.Error, "No arguments supplied.");
- return null;
- }
- var args = command.Split(spaceArray, 2, StringSplitOptions.RemoveEmptyEntries);
- if (args.Length == 0 || string.IsNullOrEmpty(args[0]) || string.IsNullOrEmpty(args[0].Trim())) {
- Log.WriteLine(LogLevel.Error, "Module name not supplied.");
- return null;
- }
- if (args.Length == 1) {
- return new[] { args[0], "" };
- } else {
- return args;
- }
- }
-
- public static bool ExecuteBackground(string command) {
- try {
- var parsed = parseCommand(command);
- if (parsed == null) return false;
- var fullName = parsed[0];
- var args = parsed[1];
- var execs = getApiExecs();
- ApiPluginExecutor exec;
- if (!execs.TryGetValue(fullName, out exec)) {
- Log.WriteLine(LogLevel.Error, "API plugin {0} not found.", fullName);
- return false;
- }
- return exec.ExecuteApiBackground(args);
- } catch (Exception ex) {
- Log.WriteLine(LogLevel.Error, "Exception in ExecuteBackground({0}): {1}", command, ex.ToString());
- return false;
- }
- }
-
- public static bool Execute(string command, IntPtr streamHandle, IntPtr eventHandle) {
- try {
- System.Diagnostics.Debug.Assert(streamHandle != IntPtr.Zero, "streamHandle is null.");
- var parsed = parseCommand(command);
- if (parsed == null) return false;
- var fullName = parsed[0];
- var args = parsed[1];
-
- var execs = getApiExecs();
- ApiPluginExecutor exec;
- if (!execs.TryGetValue(fullName, out exec)) {
- Log.WriteLine(LogLevel.Error, "API plugin {0} not found.", fullName);
- return false;
- }
- var res = exec.ExecuteApi(args, streamHandle, eventHandle);
- return res;
- } catch (Exception ex) {
- Log.WriteLine(LogLevel.Error, "Exception in Execute({0}): {1}", command, ex.ToString());
- return false;
- }
- }
-
- public static bool Run(string command, IntPtr sessionHandle) {
- try {
- Log.WriteLine(LogLevel.Debug, "FreeSWITCH.Managed: attempting to run application '{0}'.", command);
- System.Diagnostics.Debug.Assert(sessionHandle != IntPtr.Zero, "sessionHandle is null.");
- var parsed = parseCommand(command);
- if (parsed == null) return false;
- var fullName = parsed[0];
- var args = parsed[1];
-
- AppPluginExecutor exec;
- var execs = getAppExecs();
- if (!execs.TryGetValue(fullName, out exec)) {
- Log.WriteLine(LogLevel.Error, "App plugin {0} not found.", fullName);
- return false;
- }
- return exec.Execute(args, sessionHandle);
- } catch (Exception ex) {
- Log.WriteLine(LogLevel.Error, "Exception in Run({0}): {1}", command, ex.ToString());
- return false;
- }
- }
}
-
}
-
\ No newline at end of file
Deleted: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Log.cs
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Logging/DefaultLogger.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Logging/DefaultLogger.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Logging/DefaultLogger.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace FreeSWITCH.Managed
+{
+ public class DefaultLogger : ILogger
+ {
+ public void Debug(string message)
+ {
+ Log.WriteLine(LogLevel.Debug, message);
+ }
+
+ public void Info(string message)
+ {
+ Log.WriteLine(LogLevel.Info, message);
+ }
+
+ public void Error(string message)
+ {
+ Log.WriteLine(LogLevel.Error, message);
+ }
+
+ public void Critical(string message)
+ {
+ Log.WriteLine(LogLevel.Critical, message);
+ }
+
+ public void Alert(string message)
+ {
+ Log.WriteLine(LogLevel.Alert, message);
+ }
+
+ public void Warning(string message)
+ {
+ Log.WriteLine(LogLevel.Warning, message);
+ }
+
+ public void Notice(string message)
+ {
+ Log.WriteLine(LogLevel.Notice, message);
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Logging/ILogger.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Logging/ILogger.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Logging/ILogger.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace FreeSWITCH.Managed
+{
+ public interface ILogger
+ {
+ void Debug(string message);
+ void Info(string message);
+ void Error(string message);
+ void Critical(string message);
+ void Alert(string message);
+ void Warning(string message);
+ void Notice(string message);
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Logging/ILoggerContainer.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Logging/ILoggerContainer.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Logging/ILoggerContainer.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace FreeSWITCH.Managed
+{
+ public interface ILoggerContainer : ILogger
+ {
+ SynchronizedList<ILogger> Loggers { get; }
+ void Add(ILogger logger);
+ void Remove(ILogger logger);
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Logging/LoggerContainer.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Logging/LoggerContainer.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Logging/LoggerContainer.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace FreeSWITCH.Managed
+{
+ public class LoggerContainer : MarshalByRefObject, ILogger, ILoggerContainer
+ {
+ public SynchronizedList<ILogger> Loggers { get; private set; }
+
+ public LoggerContainer()
+ {
+ this.Loggers = new SynchronizedList<ILogger>();
+ }
+
+ public void Add(ILogger logger)
+ {
+ this.Loggers.Add(logger);
+ }
+
+ public void Remove(ILogger logger)
+ {
+ this.Loggers.Remove(logger);
+ }
+
+ private void sendMessage(Action<ILogger> action)
+ {
+ foreach (var logger in Loggers.Items)
+ {
+ try
+ {
+ action(logger);
+ }
+ catch { }
+ }
+ }
+ public void Debug(string message)
+ {
+ this.sendMessage((logger) => logger.Debug(message));
+ }
+
+ public void Info(string message)
+ {
+ this.sendMessage((logger) => logger.Info(message));
+ }
+
+ public void Error(string message)
+ {
+ this.sendMessage((logger) => logger.Error(message));
+ }
+
+ public void Critical(string message)
+ {
+ this.sendMessage((logger) => logger.Critical(message));
+ }
+
+ public void Alert(string message)
+ {
+ this.sendMessage((logger) => logger.Alert(message));
+ }
+
+ public void Warning(string message)
+ {
+ this.sendMessage((logger) => logger.Warning(message));
+ }
+
+ public void Notice(string message)
+ {
+ this.sendMessage((logger) => logger.Notice(message));
+ }
+ }
+}
Deleted: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ManagedSession.cs
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/AssemblyCompiler.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/AssemblyCompiler.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/AssemblyCompiler.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,127 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.CodeDom;
+using System.CodeDom.Compiler;
+using System.IO;
+using System.Reflection;
+using System.Reflection.Emit;
+using FreeSWITCH.Managed;
+
+namespace FreeSWITCH
+{
+ public class AssemblyCompiler : IAssemblyCompiler
+ {
+ private ILogger logger;
+ public AssemblyCompiler(ILogger logger)
+ {
+ this.logger = logger;
+
+ }
+
+ public Assembly CompileAssembly(string fileName)
+ {
+ var fileExtension = fileName.GetLoweredFileExtension();
+ CodeDomProvider codeDom = GetCodeDomProvider(fileExtension);
+ CompilerParameters parameters = GetCompilerParameters(fileExtension);
+ logger.Info(string.Format("Compiling {0}", fileName));
+ var compilerResult = codeDom.CompileAssemblyFromFile(parameters, fileName);
+
+ var errors = compilerResult.Errors.Cast<CompilerError>().Where(x => !x.IsWarning).ToList();
+ if (errors.Count > 0)
+ {
+ LogErrors(fileName, errors);
+ throw new ScriptDoesNotCompileException(fileName);
+ }
+ logger.Info(string.Format( "File {0} compiled successfully.", fileName));
+ return compilerResult.CompiledAssembly;
+ }
+
+ private void LogErrors(string fileName, List<CompilerError> errors)
+ {
+ Log.WriteLine(LogLevel.Error, "There were {0} errors compiling {1}.", errors.Count, fileName);
+ foreach (var err in errors)
+ {
+ if (string.IsNullOrEmpty(err.FileName))
+ {
+ this.logger.Error(string.Format( "{0}: {1}", err.ErrorNumber, err.ErrorText));
+ }
+ else
+ {
+ this.logger.Error(string.Format("{0}: {1}:{2}:{3} {4}", err.ErrorNumber, err.FileName, err.Line, err.Column, err.ErrorText));
+ }
+ }
+ }
+ private static CodeDomProvider GetCodeDomProvider(string fileExtension)
+ {
+ CodeDomProvider cdp;
+ switch (fileExtension)
+ {
+ case ".fsx":
+ cdp = CodeDomProvider.CreateProvider("f#");
+ break;
+ case ".csx":
+ cdp = new Microsoft.CSharp.CSharpCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v3.5" } });
+ break;
+ case ".vbx":
+ cdp = new Microsoft.VisualBasic.VBCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v3.5" } });
+ break;
+ case ".jsx":
+ // Have to figure out better JS support
+ cdp = CodeDomProvider.CreateProvider("js");
+ break;
+ default:
+ if (CodeDomProvider.IsDefinedExtension(fileExtension))
+ {
+ cdp = CodeDomProvider.CreateProvider(CodeDomProvider.GetLanguageFromExtension(fileExtension));
+ }
+ else
+ {
+ throw new ScriptDoesNotCompileException("Unknown extension.");
+ }
+ break;
+ }
+ return cdp;
+ }
+
+ private static CompilerParameters GetCompilerParameters(string fileExtension)
+ {
+ var comp = new CompilerParameters();
+ var mainRefs = new List<string> {
+ Path.Combine(Native.freeswitch.SWITCH_GLOBAL_dirs.mod_dir, "FreeSWITCH.Managed.dll"),
+ "System.dll", "System.Xml.dll", "System.Data.dll"
+ };
+ var extraRefs = new List<string> {
+ "System.Core.dll",
+ "System.Xml.Linq.dll",
+ };
+ comp.ReferencedAssemblies.AddRange(mainRefs.ToArray());
+ comp.ReferencedAssemblies.AddRange(extraRefs.ToArray());
+ switch (fileExtension)
+ {
+ case ".fsx":
+ comp.ReferencedAssemblies.AddRange(mainRefs.ToArray());
+ comp.ReferencedAssemblies.AddRange(extraRefs.ToArray());
+ break;
+ case ".csx":
+ comp.ReferencedAssemblies.AddRange(mainRefs.ToArray());
+ comp.ReferencedAssemblies.AddRange(extraRefs.ToArray());
+ break;
+ case ".vbx":
+ comp.ReferencedAssemblies.AddRange(extraRefs.ToArray());
+ break;
+ case ".jsx":
+ comp.ReferencedAssemblies.AddRange(mainRefs.ToArray());
+ break;
+ default:
+ comp.ReferencedAssemblies.AddRange(mainRefs.ToArray());
+ comp.ReferencedAssemblies.AddRange(extraRefs.ToArray());
+ break;
+ }
+ comp.GenerateInMemory = true;
+ comp.GenerateExecutable = true;
+ return comp;
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/AssemblyComposers/AssemblyComposerDictionary.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/AssemblyComposers/AssemblyComposerDictionary.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/AssemblyComposers/AssemblyComposerDictionary.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.CodeDom;
+using System.CodeDom.Compiler;
+using System.IO;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace FreeSWITCH
+{
+ public class AssemblyComposerDictionary : Dictionary<string, Func<IAssemblyComposer>>
+ {
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/AssemblyComposers/DllAssemblyComposer.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/AssemblyComposers/DllAssemblyComposer.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/AssemblyComposers/DllAssemblyComposer.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.CodeDom;
+using System.CodeDom.Compiler;
+using System.IO;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace FreeSWITCH
+{
+ public class DllAssemblyComposer : IAssemblyComposer
+ {
+ public Assembly GetAssembly(string filePath)
+ {
+ Assembly asm = Assembly.LoadFrom(filePath);
+ return asm;
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/AssemblyComposers/IAssemblyComposer.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/AssemblyComposers/IAssemblyComposer.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/AssemblyComposers/IAssemblyComposer.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.CodeDom;
+using System.CodeDom.Compiler;
+using System.IO;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace FreeSWITCH
+{
+ public interface IAssemblyComposer
+ {
+ Assembly GetAssembly(string filePath);
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/AssemblyComposers/ScriptAssemblyComposer.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/AssemblyComposers/ScriptAssemblyComposer.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/AssemblyComposers/ScriptAssemblyComposer.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.CodeDom;
+using System.CodeDom.Compiler;
+using System.IO;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace FreeSWITCH
+{
+ public class ScriptAssemblyComposer : IAssemblyComposer
+ {
+ private IAssemblyCompiler compiler;
+ public ScriptAssemblyComposer(IAssemblyCompiler compiler)
+ {
+ this.compiler = compiler;
+
+ }
+ public Assembly GetAssembly(string filePath)
+ {
+ Assembly asm;
+ if (Path.GetExtension(filePath).ToLowerInvariant() == ".exe")
+ {
+ asm = Assembly.LoadFrom(filePath);
+ }
+ else
+ {
+ asm = this.compiler.CompileAssembly(filePath);
+ }
+ return asm;
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/IAssemblyCompiler.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/IAssemblyCompiler.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/IAssemblyCompiler.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.CodeDom;
+using System.CodeDom.Compiler;
+using System.IO;
+using System.Reflection;
+using System.Reflection.Emit;
+using FreeSWITCH.Managed;
+
+namespace FreeSWITCH
+{
+ public interface IAssemblyCompiler
+ {
+ Assembly CompileAssembly(string fileName);
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/IModuleAssemblyLoader.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/IModuleAssemblyLoader.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/IModuleAssemblyLoader.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.IO;
+using FreeSWITCH.Managed;
+
+namespace FreeSWITCH
+{
+ public interface IModuleAssemblyLoader
+ {
+ bool Load(string filePath);
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/IModuleProxy.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/IModuleProxy.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/IModuleProxy.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.IO;
+using FreeSWITCH.Managed;
+
+namespace FreeSWITCH
+{
+ public interface IModuleProxy
+ {
+ object InitializeLifetimeService();
+ IPluginHandlerOrchestrator PluginHandlerOrchestrator { get; }
+ ILoggerContainer LogDirector { get; }
+ ILoggerContainer Logger { get; }
+ IModuleAssemblyLoader AssemblyLoader { get; }
+ string MasterAssemblyPath { get; set; }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/ModuleAssemblyLoader.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/ModuleAssemblyLoader.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/ModuleAssemblyLoader.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.IO;
+using FreeSWITCH.Managed;
+
+namespace FreeSWITCH
+{
+ public class ModuleAssemblyLoader : MarshalByRefObject, IModuleAssemblyLoader
+ {
+ private AssemblyComposerDictionary assemblyComposers;
+ private IPluginHandlerOrchestrator orchestrator;
+ private ILogger logger;
+ public ModuleAssemblyLoader(ILogger logger,
+ AssemblyComposerDictionary assemblyComposers,
+ IPluginHandlerOrchestrator orchestrator)
+ {
+ this.orchestrator = orchestrator;
+ this.assemblyComposers = assemblyComposers;
+ this.logger = logger;
+ }
+
+ public bool Load(string filePath)
+ {
+ this.logger.Info(string.Format("Loading {0} from domain {1}", filePath, AppDomain.CurrentDomain.FriendlyName));
+ if (string.IsNullOrEmpty(filePath)) throw new ArgumentNullException("Path parameter cannot be null or empty.");
+ if (AppDomain.CurrentDomain.IsDefaultAppDomain()) throw new InvalidOperationException("Module must load in its own AppDomain.");
+ bool result;
+ try
+ {
+ var assemblyComposer = this.assemblyComposers[filePath.GetLoweredFileExtension()].Invoke();
+ Assembly assembly = assemblyComposer.GetAssembly(filePath);
+ this.ThrowExceptionIfNotPlugin(assembly);
+ assembly.EntryPoint.CallEntryPoint();
+ this.orchestrator.LoadPlugins(assembly);
+ result = true;
+ }
+ catch (Exception ex)
+ {
+ this.logger.Info(string.Format("Couldn't load {0}: {1}", filePath, ex.Message));
+ result = false;
+ }
+ return result;
+ }
+
+ protected void ThrowExceptionIfNotPlugin(Assembly assembly)
+ {
+ var ourName = Assembly.GetExecutingAssembly().GetName().Name;
+ if (!assembly.GetReferencedAssemblies().Any(n => n.Name == ourName))
+ {
+ throw new
+ ModuleDoesNotReferenceFreeswitchManagedDllException("Assembly {0} doesn't reference FreeSWITCH.Managed, not loading.");
+ }
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/ModuleProxy.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/ModuleProxy.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/ModuleProxy.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,63 @@
+/*
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_managed
+ * Copyright (C) 2008, Michael Giagnocavo <mgg@giagnocavo.net>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_managed
+ *
+ * The Initial Developer of the Original Code is
+ * Michael Giagnocavo <mgg@giagnocavo.net>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Michael Giagnocavo <mgg@giagnocavo.net>
+ * Jeff Lenk <jeff@jefflenk.com>
+ *
+ * PluginManager.cs -- Plugin execution code
+ *
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.IO;
+using FreeSWITCH.Managed;
+
+namespace FreeSWITCH
+{
+ public class ModuleProxy : MarshalByRefObject, IModuleProxy
+ {
+ public override object InitializeLifetimeService()
+ {
+ return null;
+ }
+ public IPluginHandlerOrchestrator PluginHandlerOrchestrator { get { return ModuleServiceLocator.Container.Create<IPluginHandlerOrchestrator>(); } }
+ public ILoggerContainer LogDirector { get { return ModuleServiceLocator.Container.Create<LoggerContainer>() as ILoggerContainer; } }
+ public ILoggerContainer Logger { get { return ModuleServiceLocator.Container.Create<ILogger>() as ILoggerContainer; } }
+ public IModuleAssemblyLoader AssemblyLoader { get { return ModuleServiceLocator.Container.Create<IModuleAssemblyLoader>(); } }
+ public string MasterAssemblyPath
+ {
+ get { return ModuleServiceLocator.MasterAssemblyPath; }
+ set
+ {
+ ModuleServiceLocator.MasterAssemblyPath = value;
+ }
+ }
+
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/ModuleRegistry.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/ModuleRegistry.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/ModuleRegistry.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.IO;
+using FreeSWITCH.Managed;
+
+namespace FreeSWITCH
+{
+ public class ModuleRegistry
+ {
+ public void Register(ModuleServiceLocator registry)
+ {
+ registry.Register<AssemblyComposerDictionary>(container =>
+ {
+ var dictionary = new AssemblyComposerDictionary();
+ Func<IAssemblyComposer> factory1 = () => { return container.Create<DllAssemblyComposer>(); };
+ Func<IAssemblyComposer> factory2 = () => { return container.Create<ScriptAssemblyComposer>(); };
+ dictionary.Add(".dll", factory1);
+ dictionary.Add(".exe", factory1);
+ dictionary.Add(".fsx", factory2);
+ dictionary.Add(".csx", factory2);
+ dictionary.Add(".vbx", factory2);
+ dictionary.Add(".jsx", factory2);
+ return dictionary;
+ });
+ registry.Register<IAssemblyCompiler>(container => { return container.Create<AssemblyCompiler>(); });
+ registry.RegisterSingleton<IPluginHandlerOrchestrator>(container => { return container.Create<PluginHandlerOrchestrator>(); });
+ registry.DeclareSingleton(typeof(LoggerContainer));
+ registry.RegisterSingleton<ILoggerContainer>(container => { return container.Create<LoggerContainer>(); });
+ registry.RegisterSingleton<ILogger>(container => { return new LoggerContainer(); });
+ //registry.RegisterSingleton<PluginHandlerOrchestrator>(container => { return new PluginHandlerOrchestrator(); });
+ registry.Register<IModuleAssemblyLoader>(container => { return container.Create<ModuleAssemblyLoader>(); });
+ registry.Register<List<IPluginHandler>>(container =>
+ {
+ var list = new List<IPluginHandler>();
+ list.Add(container.Create<RunNotifyPluginHandler>());
+ list.Add(container.Create<DefaultPluginHandler>());
+ return list;
+ });
+
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/ModuleServiceLocator.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/ModuleServiceLocator.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/ModuleServiceLocator.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.IO;
+using FreeSWITCH.Managed;
+
+namespace FreeSWITCH
+{
+ public class ModuleServiceLocator : ObjectContainer
+ {
+ public static ModuleServiceLocator Container { get; private set; }
+ public static string MasterAssemblyPath { get; set; }
+ static ModuleServiceLocator()
+ {
+ ModuleServiceLocator.Container = new ModuleServiceLocator();
+ var registry = new ModuleRegistry();
+ registry.Register(ModuleServiceLocator.Container);
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginHandlers/DefaultPluginHandler.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginHandlers/DefaultPluginHandler.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginHandlers/DefaultPluginHandler.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,190 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.IO;
+using FreeSWITCH.Managed;
+using System.Text.RegularExpressions;
+
+namespace FreeSWITCH
+{
+ public class DefaultPluginHandler : IPluginHandler
+ {
+ private ILogger logger;
+ public bool NoReload { get; private set; }
+ public DefaultPluginHandler(ILogger logger)
+ {
+ this.logger = logger;
+ this.NoReload = false;
+ }
+ public List<ApiPluginExecutor> ApiExecutors { get { return _apiExecutors; } }
+ readonly List<ApiPluginExecutor> _apiExecutors = new List<ApiPluginExecutor>();
+
+ public List<AppPluginExecutor> AppExecutors { get { return _appExecutors; } }
+ readonly List<AppPluginExecutor> _appExecutors = new List<AppPluginExecutor>();
+
+ public bool Execute(string command, IntPtr streamHandle, IntPtr eventHandle)
+ {
+ try
+ {
+ System.Diagnostics.Debug.Assert(streamHandle != IntPtr.Zero, "streamHandle is null.");
+ var parsed = command.FreeSWITCHCommandParse();
+ if (parsed == null) return false;
+ var fullName = parsed[0];
+ var args = parsed[1];
+ ApiPluginExecutor exec = ApiExecutors.Where(app => app.Aliases.Contains(fullName)).FirstOrDefault();
+ if (exec == null) { return false; }
+
+ //logger.Error(string.Format( "API plugin {0} not found.", fullName));
+
+ var res = exec.ExecuteApi(args, streamHandle, eventHandle);
+ return res;
+ }
+ catch (Exception ex)
+ {
+ logger.Error(string.Format( "Exception in Execute({0}): {1}", command, ex.ToString()));
+ return false;
+ }
+ }
+
+ public bool ExecuteBackground(string command)
+ {
+ try
+ {
+ var parsed = command.FreeSWITCHCommandParse();
+ if (parsed == null) return false;
+ var fullName = parsed[0];
+ var args = parsed[1];
+ ApiPluginExecutor exec = ApiExecutors.Where(app => app.Aliases.Contains(fullName)).FirstOrDefault();
+ if (exec == null) { return false; }
+
+ //logger.Error(string.Format( "API plugin {0} not found.", fullName));
+
+ return exec.ExecuteApiBackground(args);
+ }
+ catch (Exception ex)
+ {
+ logger.Error(string.Format( "Exception in ExecuteBackground({0}): {1}", command, ex.ToString()));
+ return false;
+ }
+ }
+
+ public void LoadPlugins(Assembly assembly)
+ {
+ logger.Info("Default Plugin Loader Operating");
+ var allTypes = assembly.GetExportedTypes();
+ var opts = GetOptions(allTypes);
+ if ((opts & PluginOptions.NoAutoReload) == PluginOptions.NoAutoReload)
+ {
+ this.NoReload = true;
+ }
+ AddApiPlugins(allTypes, opts);
+ AddAppPlugins(allTypes, opts);
+
+ // Add the script executors
+ var name = Regex.Split(AppDomain.CurrentDomain.FriendlyName, ";")[0];
+ var aliases = new List<string> { name };
+ this.ApiExecutors.Add(new ApiPluginExecutor(name, aliases, () => new ScriptApiWrapper(assembly.EntryPoint.GetEntryDelegate()), opts));
+ this.AppExecutors.Add(new AppPluginExecutor(name, aliases, () => new ScriptAppWrapper(assembly.EntryPoint.GetEntryDelegate()), opts));
+ }
+
+
+ protected PluginOptions GetOptions(Type[] allTypes)
+ {
+ var ty = typeof(IPluginOptionsProvider);
+ var pluginTypes = allTypes.Where(x => ty.IsAssignableFrom(x) && !x.IsAbstract).ToList();
+ return pluginTypes.Aggregate(PluginOptions.None, (opts, t) =>
+ {
+ var x = ((IPluginOptionsProvider)Activator.CreateInstance(t, true));
+ return opts | x.GetOptions();
+ });
+ }
+
+ protected void AddApiPlugins(Type[] allTypes, PluginOptions pluginOptions)
+ {
+ var iApiTy = typeof(IApiPlugin);
+ foreach (var ty in allTypes.Where(x => iApiTy.IsAssignableFrom(x) && !x.IsAbstract))
+ {
+ var del = CreateConstructorDelegate<IApiPlugin>(ty);
+ var exec = new ApiPluginExecutor(ty.FullName, new List<string> { ty.FullName, ty.Name }, del, pluginOptions);
+ this.ApiExecutors.Add(exec);
+ }
+ }
+
+ protected void AddAppPlugins(Type[] allTypes, PluginOptions pluginOptions)
+ {
+ var iAppTy = typeof(IAppPlugin);
+ foreach (var ty in allTypes.Where(x => iAppTy.IsAssignableFrom(x) && !x.IsAbstract))
+ {
+ var del = CreateConstructorDelegate<IAppPlugin>(ty);
+ var exec = new AppPluginExecutor(ty.FullName, new List<string> { ty.FullName, ty.Name }, del, pluginOptions);
+ this.AppExecutors.Add(exec);
+ }
+ }
+
+ public static Func<T> CreateConstructorDelegate<T>(Type ty)
+ {
+ var destTy = typeof(T);
+ if (!destTy.IsAssignableFrom(ty)) throw new ArgumentException(string.Format("Type {0} is not assignable from {1}.", destTy.FullName, ty.FullName));
+ var con = ty.GetConstructor(Type.EmptyTypes);
+ if (con == null) throw new ArgumentException(string.Format("Type {0} doesn't have an accessible parameterless constructor.", ty.FullName));
+
+ var rand = Guid.NewGuid().ToString().Replace("-", "");
+ var dm = new DynamicMethod("CREATE_" + ty.FullName.Replace('.', '_') + rand, ty, null, true);
+ var il = dm.GetILGenerator();
+ il.Emit(OpCodes.Newobj, ty.GetConstructor(Type.EmptyTypes));
+ il.Emit(OpCodes.Ret);
+
+ return (Func<T>)dm.CreateDelegate(typeof(Func<T>));
+ }
+ public bool Run(string command, IntPtr sessionHandle)
+ {
+ try
+ {
+ logger.Debug(string.Format( "FreeSWITCH.Managed: attempting to run application '{0}'.", command));
+ System.Diagnostics.Debug.Assert(sessionHandle != IntPtr.Zero, "sessionHandle is null.");
+ var parsed = command.FreeSWITCHCommandParse();
+ if (parsed == null) return false;
+ var fullName = parsed[0];
+ var args = parsed[1];
+
+ AppPluginExecutor exec = AppExecutors.Where(app => app.Aliases.Contains(fullName)).FirstOrDefault();
+ //logger.Error(string.Format( "App plugin {0} not found.", fullName));
+ if (exec == null) { return false; }
+ return exec.Execute(args, sessionHandle);
+ }
+ catch (Exception ex)
+ {
+ logger.Error(string.Format( "Exception in Run({0}): {1}", command, ex.ToString()));
+ return false;
+ }
+ }
+ public void Unload()
+ {
+ this.BlockUntilUnloadIsSafe();
+ }
+
+ bool isUnloading = false;
+ int unloadCount;
+ System.Threading.ManualResetEvent unloadSignal = new System.Threading.ManualResetEvent(false);
+ void decreaseUnloadCount()
+ {
+ if (System.Threading.Interlocked.Decrement(ref unloadCount) == 0)
+ {
+ unloadSignal.Set();
+ }
+ }
+
+ public void BlockUntilUnloadIsSafe()
+ {
+ if (isUnloading) throw new InvalidOperationException("PluginManager is already unloading.");
+ isUnloading = true;
+ unloadCount = ApiExecutors.Count + AppExecutors.Count;
+ ApiExecutors.ForEach(x => x.SetZeroUseNotification(decreaseUnloadCount));
+ AppExecutors.ForEach(x => x.SetZeroUseNotification(decreaseUnloadCount));
+ unloadSignal.WaitOne();
+ }
+
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginHandlers/IPluginHandler.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginHandlers/IPluginHandler.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginHandlers/IPluginHandler.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.IO;
+using FreeSWITCH.Managed;
+
+namespace FreeSWITCH
+{
+ public interface IPluginHandler : IRunCommand, IExecuteBackgroundCommand, IExecuteCommand
+ {
+ bool NoReload { get; }
+ void LoadPlugins(Assembly assembly);
+ void Unload();
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginHandlers/IPluginHandlerOrchestrator.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginHandlers/IPluginHandlerOrchestrator.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginHandlers/IPluginHandlerOrchestrator.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.IO;
+using FreeSWITCH.Managed;
+
+namespace FreeSWITCH
+{
+ public interface IPluginHandlerOrchestrator : IPluginHandler
+ {
+ string FileName { get; set; }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginHandlers/PluginHandlerOrchestrator.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginHandlers/PluginHandlerOrchestrator.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginHandlers/PluginHandlerOrchestrator.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.IO;
+using FreeSWITCH.Managed;
+
+namespace FreeSWITCH
+{
+ public class PluginHandlerOrchestrator : MarshalByRefObject, IPluginHandler, IPluginHandlerOrchestrator
+ {
+ public PluginHandlerOrchestrator()
+ {
+ }
+
+ public bool NoReload
+ {
+ get
+ {
+ foreach (var handler in handlers)
+ {
+ if (handler.NoReload) { return true; };
+ }
+ return false;
+ }
+ }
+ public string FileName { get; set; }
+ private List<IPluginHandler> handlers = new List<IPluginHandler>();
+
+ public void LoadPlugins(Assembly assembly)
+ {
+ var newHandlers = ModuleServiceLocator.Container.Create<List<IPluginHandler>>();
+ newHandlers.ForEach(h => h.LoadPlugins(assembly));
+ this.handlers.AddRange(newHandlers);
+ }
+
+ public void Unload()
+ {
+ foreach (var handler in handlers)
+ {
+ handler.Unload();
+ }
+ }
+
+ public bool Run(string command, IntPtr sessionHandle)
+ {
+ bool returnValue = false;
+ handlers.ForEach(handler =>
+ {
+ bool result = handler.Run(command, sessionHandle);
+ if (result == true) { returnValue = true; }
+ });
+ return returnValue;
+ }
+
+ public bool ExecuteBackground(string command)
+ {
+ bool returnValue = false;
+ handlers.ForEach(handler =>
+ {
+ bool result = handler.ExecuteBackground(command);
+ if (result == true) { returnValue = true; }
+ });
+ return returnValue;
+ }
+
+ public bool Execute(string command, IntPtr streamHandle, IntPtr eventHandle)
+ {
+ bool returnValue = false;
+ handlers.ForEach(handler =>
+ {
+ bool result = handler.Execute(command, streamHandle, eventHandle);
+ if (result == true) { returnValue = true; }
+ });
+ return returnValue;
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginHandlers/RunNotifyPluginHandler.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginHandlers/RunNotifyPluginHandler.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginHandlers/RunNotifyPluginHandler.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.IO;
+using FreeSWITCH.Managed;
+
+namespace FreeSWITCH
+{
+ public class RunNotifyPluginHandler : IPluginHandler
+ {
+ public bool NoReload {get{return false;}}
+ public void LoadPlugins(Assembly assembly)
+ {
+ var allTypes = assembly.GetExportedTypes();
+ // Run Load on all the load plugins
+ var ty = typeof(ILoadNotificationPlugin);
+ var pluginTypes = allTypes.Where(x => ty.IsAssignableFrom(x) && !x.IsAbstract).ToList();
+ if (pluginTypes.Count == 0) return;
+ foreach (var pt in pluginTypes)
+ {
+ var plugin = ((ILoadNotificationPlugin)Activator.CreateInstance(pt, true));
+ if (!plugin.Load())
+ {
+ throw new RunNotifyException(string.Format("Type {0} requested no loading. Assembly will not be loaded.", pt.FullName));
+ }
+ }
+ return;
+ }
+
+ public void Unload()
+ {
+ return;
+ }
+
+ public bool Run(string command, IntPtr sessionHandle)
+ {
+ return false;
+ }
+
+ public bool ExecuteBackground(string command)
+ {
+ return false;
+ }
+
+ public bool Execute(string command, IntPtr streamHandle, IntPtr eventHandle)
+ {
+ return false;
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ApiBackgroundContext.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ApiBackgroundContext.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ApiBackgroundContext.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace FreeSWITCH
+{
+ public class ApiBackgroundContext
+ {
+ readonly string arguments;
+
+ public ApiBackgroundContext(string arguments)
+ {
+ this.arguments = arguments;
+ }
+
+ public string Arguments { get { return arguments; } }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ApiContext.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ApiContext.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ApiContext.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace FreeSWITCH
+{
+ public class ApiContext
+ {
+ readonly string arguments;
+ readonly Native.Stream stream;
+ readonly Native.Event evt;
+
+ public ApiContext(string arguments, Native.Stream stream, Native.Event evt)
+ {
+ this.arguments = arguments;
+ this.stream = stream;
+ this.evt = evt;
+ }
+
+ public string Arguments { get { return arguments; } }
+ public Native.Stream Stream { get { return stream; } }
+ public Native.Event Event { get { return evt; } }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ApiPluginExecutor.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ApiPluginExecutor.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ApiPluginExecutor.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace FreeSWITCH
+{
+ public sealed class ApiPluginExecutor : DefaultPluginExecutor
+ {
+
+ readonly Func<IApiPlugin> createPlugin;
+
+ public ApiPluginExecutor(string name, List<string> aliases, Func<IApiPlugin> creator, PluginOptions pluginOptions)
+ : base(name, aliases, pluginOptions)
+ {
+ if (creator == null) throw new ArgumentNullException("Creator cannot be null.");
+ this.createPlugin = creator;
+ }
+
+ public bool ExecuteApi(string args, IntPtr streamHandle, IntPtr eventHandle)
+ {
+ IncreaseUse();
+ try
+ {
+ using (var stream = new Native.Stream(new Native.switch_stream_handle(streamHandle, false)))
+ using (var evt = eventHandle == IntPtr.Zero ? null : new Native.Event(new Native.switch_event(eventHandle, false), 0))
+ {
+ try
+ {
+ var context = new ApiContext(args, stream, evt);
+ var plugin = createPlugin();
+ plugin.Execute(context);
+ return true;
+ }
+ catch (Exception ex)
+ {
+ LogException("Execute", Name, ex);
+ return false;
+ }
+ }
+ }
+ finally
+ {
+ DecreaseUse();
+ }
+ }
+
+ public bool ExecuteApiBackground(string args)
+ {
+ // Background doesn't affect use count
+ new System.Threading.Thread(() =>
+ {
+ try
+ {
+ var context = new ApiBackgroundContext(args);
+ var plugin = createPlugin();
+ plugin.ExecuteBackground(context);
+ Log.WriteLine(LogLevel.Debug, "ExecuteBackground in {0} completed.", Name);
+ }
+ catch (Exception ex)
+ {
+ LogException("ExecuteBackground", Name, ex);
+ }
+ }).Start();
+ return true;
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/AppContext.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/AppContext.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/AppContext.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace FreeSWITCH
+{
+ public class AppContext
+ {
+ readonly string arguments;
+ readonly Native.ManagedSession session;
+
+ public AppContext(string arguments, Native.ManagedSession session)
+ {
+ this.arguments = arguments;
+ this.session = session;
+ }
+
+ public string Arguments { get { return arguments; } }
+ public Native.ManagedSession Session { get { return session; } }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/AppPluginExecutor.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/AppPluginExecutor.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/AppPluginExecutor.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace FreeSWITCH
+{
+ public sealed class AppPluginExecutor : DefaultPluginExecutor
+ {
+ readonly Func<IAppPlugin> createPlugin;
+
+ public AppPluginExecutor(string name, List<string> aliases, Func<IAppPlugin> creator, PluginOptions pluginOptions)
+ : base(name, aliases, pluginOptions)
+ {
+ if (creator == null) throw new ArgumentNullException("Creator cannot be null.");
+ this.createPlugin = creator;
+ }
+
+ public bool Execute(string args, IntPtr sessionHandle)
+ {
+ IncreaseUse();
+ try
+ {
+ using (var session = new Native.ManagedSession(new Native.SWIGTYPE_p_switch_core_session(sessionHandle, false)))
+ {
+ session.Initialize();
+ session.SetAutoHangup(false);
+ try
+ {
+ var plugin = createPlugin();
+ var context = new AppContext(args, session); ;
+ plugin.Run(context);
+ return true;
+ }
+ catch (Exception ex)
+ {
+ LogException("Run", Name, ex);
+ return false;
+ }
+ }
+ }
+ finally
+ {
+ DecreaseUse();
+ }
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/DefaultPluginExecutor.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/DefaultPluginExecutor.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/DefaultPluginExecutor.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using FreeSWITCH.Managed;
+
+namespace FreeSWITCH
+{
+ public abstract class DefaultPluginExecutor : MarshalByRefObject
+ {
+ public override object InitializeLifetimeService()
+ {
+ return null;
+ }
+ private ILogger logger;
+
+ /// <summary>Names by which this plugin may be executed.</summary>
+ public List<string> Aliases { get { return aliases; } }
+ readonly List<string> aliases = new List<string>();
+
+ /// <summary>The canonical name to identify this plugin (informative).</summary>
+ public string Name { get { return name; } }
+ readonly string name;
+
+ public PluginOptions PluginOptions { get { return pluginOptions; } }
+ readonly PluginOptions pluginOptions;
+
+ protected DefaultPluginExecutor(string name, List<string> aliases, PluginOptions pluginOptions)
+ {
+ if (string.IsNullOrEmpty(name)) throw new ArgumentException("No name provided.");
+ if (aliases == null || aliases.Count == 0) throw new ArgumentException("No aliases provided.");
+ this.name = name;
+ this.aliases = aliases.Distinct().ToList();
+ this.pluginOptions = pluginOptions;
+ // Hardwired because the container doesn't generate PluginExectors. May be a good place for a later refactoring.
+ this.logger = ModuleServiceLocator.Container.Create<ILogger>();
+ }
+
+ int useCount = 0;
+ protected void IncreaseUse()
+ {
+ System.Threading.Interlocked.Increment(ref useCount);
+ }
+ protected void DecreaseUse()
+ {
+ var count = System.Threading.Interlocked.Decrement(ref useCount);
+ if (count == 0 && onZeroUse != null)
+ {
+ onZeroUse();
+ }
+ }
+
+ Action onZeroUse;
+ public void SetZeroUseNotification(Action onZeroUse)
+ {
+ this.onZeroUse = onZeroUse;
+ if (useCount == 0) onZeroUse();
+ }
+
+ protected void LogException(string action, string moduleName, Exception ex)
+ {
+ this.logger.Error(string.Format("{0} exception in {1}: {2}", action, moduleName, ex.Message));
+ this.logger.Debug(string.Format("{0} exception: {1}", moduleName, ex.ToString()));
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/IApiPlugin.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/IApiPlugin.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/IApiPlugin.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace FreeSWITCH
+{
+ public interface IApiPlugin
+ {
+ void Execute(ApiContext context);
+ void ExecuteBackground(ApiBackgroundContext context);
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/IAppPlugin.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/IAppPlugin.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/IAppPlugin.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace FreeSWITCH
+{
+ public interface IAppPlugin
+ {
+ void Run(AppContext context);
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ILoadNotificationPlugin.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ILoadNotificationPlugin.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ILoadNotificationPlugin.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace FreeSWITCH
+{
+ public interface ILoadNotificationPlugin
+ {
+ bool Load();
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/IPluginOptionsProvider.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/IPluginOptionsProvider.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/IPluginOptionsProvider.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,43 @@
+/*
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_managed
+ * Copyright (C) 2008, Michael Giagnocavo <mgg@giagnocavo.net>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_managed
+ *
+ * The Initial Developer of the Original Code is
+ * Michael Giagnocavo <mgg@giagnocavo.net>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Michael Giagnocavo <mgg@giagnocavo.net>
+ * Jeff Lenk <jeff@jefflenk.com>
+ *
+ * PluginInterfaces.cs -- Public interfaces for plugins
+ *
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace FreeSWITCH {
+
+ public interface IPluginOptionsProvider {
+ PluginOptions GetOptions();
+ }
+
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/PluginOptions.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/PluginOptions.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/PluginOptions.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace FreeSWITCH
+{
+ [Flags]
+ public enum PluginOptions
+ {
+ None = 0,
+ NoAutoReload = 1,
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/Script.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/Script.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/Script.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.CodeDom;
+using System.CodeDom.Compiler;
+using System.IO;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace FreeSWITCH
+{
+ public static class Script
+ {
+
+ [ThreadStatic]
+ internal static ScriptContextType contextType;
+ [ThreadStatic]
+ internal static object context;
+
+ public static ScriptContextType ContextType { get { return contextType; } }
+
+ public static ApiContext GetApiContext()
+ {
+ return getContext<ApiContext>(ScriptContextType.Api);
+ }
+ public static ApiBackgroundContext GetApiBackgroundContext()
+ {
+ return getContext<ApiBackgroundContext>(ScriptContextType.ApiBackground);
+ }
+ public static AppContext GetAppContext()
+ {
+ return getContext<AppContext>(ScriptContextType.App);
+ }
+
+ public static T getContext<T>(ScriptContextType sct)
+ {
+ var ctx = context;
+ if (ctx == null) throw new InvalidOperationException("Current context is null.");
+ if (contextType != sct) throw new InvalidOperationException("Current ScriptContextType is not " + sct.ToString() + ".");
+ return (T)ctx;
+ }
+
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ScriptApiWrapper.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ScriptApiWrapper.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ScriptApiWrapper.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.CodeDom;
+using System.CodeDom.Compiler;
+using System.IO;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace FreeSWITCH
+{
+ public class ScriptApiWrapper : IApiPlugin
+ {
+
+ readonly Action entryPoint;
+ public ScriptApiWrapper(Action entryPoint)
+ {
+ this.entryPoint = entryPoint;
+ }
+
+ public void Execute(ApiContext context)
+ {
+ Script.contextType = ScriptContextType.Api;
+ Script.context = context;
+ try
+ {
+ entryPoint();
+ }
+ finally
+ {
+ Script.contextType = ScriptContextType.None;
+ Script.context = null;
+ }
+ }
+
+ public void ExecuteBackground(ApiBackgroundContext context)
+ {
+ Script.contextType = ScriptContextType.ApiBackground;
+ Script.context = context;
+ try
+ {
+ entryPoint();
+ }
+ finally
+ {
+ Script.contextType = ScriptContextType.None;
+ Script.context = null;
+ }
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ScriptAppWrapper.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ScriptAppWrapper.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ScriptAppWrapper.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.CodeDom;
+using System.CodeDom.Compiler;
+using System.IO;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace FreeSWITCH
+{
+ public class ScriptAppWrapper : IAppPlugin
+ {
+
+ readonly Action entryPoint;
+ public ScriptAppWrapper(Action entryPoint)
+ {
+ this.entryPoint = entryPoint;
+ }
+
+ public void Run(AppContext context)
+ {
+ Script.contextType = ScriptContextType.App;
+ Script.context = context;
+ try
+ {
+ entryPoint();
+ }
+ finally
+ {
+ Script.contextType = ScriptContextType.None;
+ Script.context = null;
+ }
+ }
+
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ScriptContextType.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ScriptContextType.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ModuleAppdomains/PluginTypes/ScriptContextType.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.CodeDom;
+using System.CodeDom.Compiler;
+using System.IO;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace FreeSWITCH
+{
+ public enum ScriptContextType
+ {
+ None,
+ App,
+ Api,
+ ApiBackground,
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Native/ChannelVariables.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Native/ChannelVariables.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Native/ChannelVariables.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,221 @@
+/*
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_managed
+ * Copyright (C) 2008, Michael Giagnocavo <mgg@giagnocavo.net>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_managed
+ *
+ * The Initial Developer of the Original Code is
+ * Michael Giagnocavo <mgg@giagnocavo.net>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Michael Giagnocavo <mgg@giagnocavo.net>
+ *
+ * ChannelVariables.cs -- Strongly typed channel variables for ManagedSession
+ *
+ */
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace FreeSWITCH.Native {
+ public class ChannelVariables {
+ readonly ManagedSession sess;
+ internal ChannelVariables(ManagedSession session) {
+ this.sess = session;
+ }
+
+ public IDictionary<string, string> GetAllVariables() {
+ var dic = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+ var evt = Native.freeswitch.switch_channel_variable_first(sess.channel);
+ while(evt != null) {
+ dic.Add(evt.name, evt.value);
+ evt = evt.next;
+ }
+ Native.freeswitch.switch_channel_variable_last(sess.channel);
+ return dic;
+ }
+
+ /*** Settings ***/
+ const string bypass_media = "bypass_media";
+ public bool BypassMedia {
+ get { return strToBool(sess.GetVariable(bypass_media)); }
+ set { sess.SetVariable(bypass_media, boolToStr(value)); }
+ }
+
+ /*** Times ***/
+ const string created_time = "created_time";
+ const string answered_time = "answered_time";
+ const string hangup_time = "hungup_time";
+ const string progress_time = "progress_time";
+ const string transfer_time = "transfer_time";
+
+ public DateTime CreatedTime {
+ get { return epochUsToDateTime(long.Parse(sess.GetVariable(created_time))); }
+ }
+
+ DateTime? readUsecsDateTime(string varName) {
+ var v = sess.GetVariable(varName);
+ if (string.IsNullOrEmpty(v)) return null;
+ else {
+ var d = epochUsToDateTime(long.Parse(v));
+ if (d == DateTime.MinValue) return null;
+ return d;
+ }
+ }
+
+ public DateTime? AnsweredTime {
+ get { return readUsecsDateTime(answered_time); }
+ }
+ public DateTime? HangupTime {
+ get { return readUsecsDateTime(hangup_time); }
+ }
+ public DateTime? ProgressTime {
+ get { return readUsecsDateTime(progress_time); }
+ }
+ public DateTime? TransferTime {
+ get { return readUsecsDateTime(transfer_time); }
+ }
+
+
+ /*** SIP Variables ***/
+ const string sofia_profile_name = "sofia_profile_name";
+ const string sip_received_ip = "sip_received_ip";
+ const string sip_received_port = "sip_received_port";
+ const string sip_via_protocol = "sip_via_protocol";
+ const string sip_from_user = "sip_from_user";
+ const string sip_from_uri = "sip_from_uri";
+ const string sip_from_host = "sip_from_host";
+ const string sip_req_user = "sip_req_user";
+ const string sip_req_uri = "sip_req_uri";
+ const string sip_req_host = "sip_req_host";
+ const string sip_to_user = "sip_to_user";
+ const string sip_to_uri = "sip_to_uri";
+ const string sip_to_host = "sip_to_host";
+ const string sip_contact_user = "sip_contact_user";
+ const string sip_contact_port = "sip_contact_port";
+ const string sip_contact_uri = "sip_contact_uri";
+ const string sip_contact_host = "sip_contact_host";
+ const string sip_call_id = "sip_call_id";
+ const string sip_destination_url = "sip_destination_url";
+ const string sip_term_status = "sip_term_status";
+ const string sip_term_cause = "sip_term_status";
+ const string switch_r_sdp = "switch_r_sdp";
+ const string switch_m_sdp = "switch_m_sdp";
+ const string sip_hangup_phrase = "sip_hangup_phrase";
+
+
+ short? readShort(string varName) {
+ var s = sess.GetVariable(varName);
+ if (string.IsNullOrEmpty(s)) return null;
+ short res;
+ if (short.TryParse(s, out res)) return res;
+ else return null;
+ }
+ int? readInt(string varName) {
+ var s = sess.GetVariable(varName);
+ if (string.IsNullOrEmpty(s)) return null;
+ int res;
+ if (int.TryParse(s, out res)) return res;
+ else return null;
+ }
+
+ // String suffix is added when the var is better represented as
+ // a different data type, but for now we return string
+
+ public string SofiaProfileName { get { return sess.GetVariable(sofia_profile_name); } }
+ public string SipCallID { get { return sess.GetVariable(sip_call_id); } }
+ public string SipReceivedIP { get { return sess.GetVariable(sip_received_ip); } }
+ public short? SipReceivedPort { get { return readShort(sip_received_port); } }
+ public string SipViaProtocolString { get { return sess.GetVariable(sip_via_protocol); } }
+ public string SipFromUser { get { return sess.GetVariable(sip_from_user); } }
+ public string SipFromUriString { get { return sess.GetVariable(sip_from_uri); } }
+ public string SipFromHost { get { return sess.GetVariable(sip_from_host); } }
+ public string SipReqUser { get { return sess.GetVariable(sip_req_user); } }
+ public string SipReqUriString { get { return sess.GetVariable(sip_req_uri); } }
+ public string SipReqHost { get { return sess.GetVariable(sip_req_host); } }
+ public string SipToUser { get { return sess.GetVariable(sip_to_user); } }
+ public string SipToUriString { get { return sess.GetVariable(sip_to_uri); } }
+ public string SipToHost { get { return sess.GetVariable(sip_to_host); } }
+ public string SipContactUser { get { return sess.GetVariable(sip_contact_user); } }
+ public string SipContactUriString { get { return sess.GetVariable(sip_contact_uri); } }
+ public string SipContactHost { get { return sess.GetVariable(sip_contact_host); } }
+ public short? SipContactPort { get { return readShort(sip_contact_port); } }
+ public string SipDestinationUrlString { get { return sess.GetVariable(sip_destination_url); } }
+ public int? SipTermStatus { get { return readInt(sip_term_status); } }
+ public int? SipTermCause { get { return readInt(sip_term_cause); } }
+ public string SwitchRSdp { get { return sess.GetVariable(switch_r_sdp); } }
+ public string SwitchMSdp { get { return sess.GetVariable(switch_m_sdp); } }
+ public string SipHangupPhrase { get { return sess.GetVariable(sip_hangup_phrase); } }
+
+ /*** Other ***/
+
+ const string proto_specific_hangup_cause = "proto_specific_hangup_cause";
+ const string hangup_cause = "hangup_cause";
+ const string hangup_cause_q850 = "hangup_cause_q850";
+ const string originate_disposition = "originate_disposition";
+ const string direction = "direction";
+
+ public string ProtoSpecificHangupCause { get { return sess.GetVariable(proto_specific_hangup_cause); } }
+ public string HangupCauseString { get { return sess.GetVariable(hangup_cause); } }
+ public int? HangupCauseQ850 { get { return readInt(hangup_cause_q850); } }
+ public string OriginateDispositionString { get { return sess.GetVariable(originate_disposition); } }
+
+ public Native.switch_call_direction_t CallDirection {
+ get {
+ var s = sess.GetVariable(direction);
+ if (string.IsNullOrEmpty(s)) return switch_call_direction_t.SWITCH_CALL_DIRECTION_INBOUND; // I guess
+ return s.ToLowerInvariant() == "inbound" ? switch_call_direction_t.SWITCH_CALL_DIRECTION_INBOUND : switch_call_direction_t.SWITCH_CALL_DIRECTION_OUTBOUND;
+ }
+
+ }
+ // Need to find a better place to put these - then make them public
+ static readonly DateTime epoch = new DateTime(1970, 1, 1);
+ static DateTime epochUsToDateTime(long us)
+ {
+ return us == 0 ?
+ DateTime.MinValue :
+ epoch.AddMilliseconds((double)((decimal)us / 1000m));
+ }
+
+ static string boolToStr(bool b)
+ {
+ return b ? "true" : "false";
+ }
+ static bool strToBool(string s)
+ {
+ if (string.IsNullOrEmpty(s)) return false;
+ switch (s.ToLowerInvariant())
+ {
+ case "true":
+ case "yes":
+ case "on":
+ case "enable":
+ case "enabled":
+ case "active":
+ case "allow":
+ return true;
+ default:
+ // Numbers are true
+ long tmp;
+ return long.TryParse(s, out tmp);
+ }
+ }
+ }
+}
\ No newline at end of file
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Native/FSUtil.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Native/FSUtil.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Native/FSUtil.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+using System.Reflection;
+
+namespace FreeSWITCH
+{
+ public static class FSUtil
+ {
+ // IntPtr cPtr, bool futureUse
+ static readonly Type[] swigConstructorTypes = new[] { typeof(IntPtr), typeof(bool) };
+ public static T CreateSwigTypePointer<T>(this IntPtr cPtr)
+ {
+ var ty = typeof(T);
+ var bflags = BindingFlags.Default | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance;
+ var cons = ty.GetConstructor(bflags, null, swigConstructorTypes, null);
+ if (cons == null) throw new ArgumentException(ty.Name + " constructor not found.");
+ return (T)cons.Invoke(new object[] { cPtr, false });
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Native/Log.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Native/Log.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Native/Log.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,96 @@
+/*
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_managed
+ * Copyright (C) 2008, Michael Giagnocavo <mgg@giagnocavo.net>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_managed
+ *
+ * The Initial Developer of the Original Code is
+ * Michael Giagnocavo <mgg@giagnocavo.net>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Michael Giagnocavo <mgg@giagnocavo.net>
+ *
+ * Log.cs -- Log wrappers
+ *
+ */
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace FreeSWITCH
+{
+ public static class Log
+ {
+ public static void Write(LogLevel level, string message)
+ {
+ Native.freeswitch.console_log(level.ToLogString(), message);
+ }
+ public static void Write(LogLevel level, string format, params object[] args)
+ {
+ Native.freeswitch.console_log(level.ToLogString(), string.Format(format, args));
+ }
+ public static void WriteLine(LogLevel level, string message)
+ {
+ Native.freeswitch.console_log(level.ToLogString(), message + Environment.NewLine);
+ }
+ public static void WriteLine(LogLevel level, string format, params object[] args)
+ {
+ Native.freeswitch.console_log(level.ToLogString(), string.Format(format, args) + Environment.NewLine);
+ }
+
+ static string ToLogString(this LogLevel level)
+ {
+ switch (level) {
+ case LogLevel.Alert: return "ALERT";
+ case LogLevel.Critical: return "CRIT";
+ case LogLevel.Debug: return "DEBUG";
+ case LogLevel.Error: return "ERR";
+ case LogLevel.Info: return "INFO";
+ case LogLevel.Notice: return "NOTICE";
+ case LogLevel.Warning: return "WARNING";
+ default:
+ System.Diagnostics.Debug.Fail("Invalid LogLevel: " + level.ToString() + " (" + (int)level+ ").");
+ return "INFO";
+ }
+ }
+ }
+
+ /*switch_log.c:
+ tatic const char *LEVELS[] = {
+ "CONSOLE",
+ "ALERT",
+ "CRIT",
+ "ERR",
+ "WARNING",
+ "NOTICE",
+ "INFO",
+ "DEBUG",
+ NULL
+ };*/
+ public enum LogLevel
+ {
+ Debug,
+ Info,
+ Error,
+ Critical,
+ Alert,
+ Warning,
+ Notice,
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Native/ManagedSession.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Native/ManagedSession.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Native/ManagedSession.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,273 @@
+/*
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_managed
+ * Copyright (C) 2008, Michael Giagnocavo <mgg@giagnocavo.net>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_managed
+ *
+ * The Initial Developer of the Original Code is
+ * Michael Giagnocavo <mgg@giagnocavo.net>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Michael Giagnocavo <mgg@giagnocavo.net>
+ *
+ * ManagedSession.cs -- ManagedSession additional functions
+ *
+ */
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace FreeSWITCH.Native
+{
+ // switch_status_t ManagedSession::run_dtmf_callback(void *input, switch_input_type_t itype)
+ // But, process_callback_result is used to turn a string into a switch_status_t
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate string DtmfCallback(IntPtr input, Native.switch_input_type_t itype);
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ delegate void CdeclAction();
+
+ // This callback is used for originate
+ [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
+ public delegate switch_status_t switch_state_handler_t_delegate(IntPtr sessionPtr);
+
+ public partial class ManagedSession
+ {
+ // SWITCH_DECLARE(void) InitManagedSession(ManagedSession *session, MonoObject *dtmfDelegate, MonoObject *hangupDelegate)
+ [DllImport("mod_managed.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.Cdecl)]
+ static extern void InitManagedSession(IntPtr sessionPtr, DtmfCallback dtmfDelegate, CdeclAction hangupDelegate);
+
+ /// <summary>Initializes the native ManagedSession. Must be called after Originate.</summary>
+ public void Initialize()
+ {
+ if (allocated == 0)
+ {
+ throw new InvalidOperationException("Cannot initialize a ManagedSession until it is allocated (originated successfully).");
+ }
+ // P/Invoke generated function pointers stick around until the delegate is collected
+ // By sticking the delegates in fields, their lifetime won't be less than the session
+ // So we don't need to worry about GCHandles and all that....
+ // Info here: http://blogs.msdn.com/cbrumme/archive/2003/05/06/51385.aspx
+ this._inputCallbackRef = inputCallback;
+ this._hangupCallbackRef = hangupCallback;
+ InitManagedSession(ManagedSession.getCPtr(this).Handle, this._inputCallbackRef, this._hangupCallbackRef);
+ this._variables = new ChannelVariables(this);
+ }
+ DtmfCallback _inputCallbackRef;
+ CdeclAction _hangupCallbackRef;
+
+ /// <summary>Function to execute when this session hangs up.</summary>
+ public Action HangupFunction { get; set; }
+
+ void hangupCallback()
+ {
+ Log.WriteLine(LogLevel.Debug, "AppFunction is in hangupCallback.");
+ try
+ {
+ var f = HangupFunction;
+ if (f != null) f();
+ }
+ catch (Exception ex)
+ {
+ Log.WriteLine(LogLevel.Warning, "Exception in hangupCallback: {0}", ex.ToString());
+ }
+ }
+
+ public Func<Char, TimeSpan, string> DtmfReceivedFunction { get; set; }
+
+ public Func<Native.Event, string> EventReceivedFunction { get; set; }
+
+ string inputCallback(IntPtr input, Native.switch_input_type_t inputType)
+ {
+ try
+ {
+ switch (inputType)
+ {
+ case FreeSWITCH.Native.switch_input_type_t.SWITCH_INPUT_TYPE_DTMF:
+ using (var dtmf = new Native.switch_dtmf_t(input, false))
+ {
+ return dtmfCallback(dtmf);
+ }
+ case FreeSWITCH.Native.switch_input_type_t.SWITCH_INPUT_TYPE_EVENT:
+ using (var swevt = new Native.switch_event(input, false))
+ {
+ return eventCallback(swevt);
+ }
+ default:
+ return "";
+ }
+ }
+ catch (Exception ex)
+ {
+ Log.WriteLine(LogLevel.Error, "InputCallback threw exception: " + ex.ToString());
+ return "-ERR InputCallback Exception: " + ex.Message;
+ }
+ }
+
+ string dtmfCallback(Native.switch_dtmf_t dtmf)
+ {
+ var f = DtmfReceivedFunction;
+ return f == null ? ""
+ : f(((char)(byte)dtmf.digit), TimeSpan.FromMilliseconds(dtmf.duration));
+ }
+
+ string eventCallback(Native.switch_event swevt)
+ {
+ using (var evt = new FreeSWITCH.Native.Event(swevt, 0))
+ {
+ var f = EventReceivedFunction;
+ return f == null ? ""
+ : f(evt);
+ }
+ }
+ [Obsolete("Use static Originate method.", false)]
+ public bool Originate(CoreSession aLegSession, string destination, TimeSpan timeout)
+ {
+ var res = 0 == this.originate(aLegSession, destination, (int)timeout.TotalMilliseconds, null);
+ if (res)
+ {
+ this.Initialize();
+ }
+ return res;
+ }
+
+
+ // Creating these function pointers is a two-stage process.
+ // The delegate needs to be stored so it doesn't get GC'd, so we can't just return GetFunctionPointerForDelegate right away.
+
+ /// <summary>Wraps a nice handler into a delegate suitable for reverse P/Invoke. This only currently works well for hangup/reporting handlers.</summary>
+ public static switch_state_handler_t_delegate CreateStateHandlerDelegate(Action<ManagedSession> handler)
+ {
+ // We create a ManagedSession on top of the session so callbacks can use it "nicely"
+ // Then we sort of dispose it.
+ switch_state_handler_t_delegate del = ptr =>
+ {
+ using (var sess = new ManagedSession(new SWIGTYPE_p_switch_core_session(ptr, false)))
+ {
+ handler(sess);
+ return switch_status_t.SWITCH_STATUS_SUCCESS;
+ }
+ };
+ return del;
+ }
+ public static SWIGTYPE_p_f_p_switch_core_session__switch_status_t WrapStateHandlerDelegate(switch_state_handler_t_delegate del)
+ {
+ return new SWIGTYPE_p_f_p_switch_core_session__switch_status_t(Marshal.GetFunctionPointerForDelegate(del), false);
+ }
+
+
+ // These are needed on the ManagedSession bleg, so they don't get GC'd
+ // while the B Leg is still around
+ switch_state_handler_t_delegate originate_onhangup_delegate;
+ switch_state_handler_t_delegate originate_ondestroy_delegate;
+ switch_state_handler_table originate_table;
+ GCHandle originate_keepalive_handle; // Make sure the B Leg is not collected and disposed until we run ondestroy
+
+ switch_status_t originate_onhangup_method(IntPtr channelPtr)
+ {
+ // CS_DESTROY lets the bleg be collected
+ // and frees originate_table memory
+ // Note that this (bleg ManagedSession) is invalid
+ // to touch right now - the unmanaged memory has already been free'd
+ if (this.originate_keepalive_handle.IsAllocated)
+ {
+ this.originate_keepalive_handle.Free(); // GC can now collect this bleg
+ }
+ if (this.originate_table != null)
+ {
+ this.originate_table.Dispose();
+ this.originate_table = null;
+ }
+ return switch_status_t.SWITCH_STATUS_SUCCESS;
+ }
+
+ /// <summary>
+ /// Performs originate. Returns ManagedSession on success, null on failure.
+ /// onHangup is called as a state handler, after the channel is truly hungup.
+ /// </summary>
+ public static ManagedSession OriginateHandleHangup(CoreSession aLegSession, string destination, TimeSpan timeout, Action<ManagedSession> onHangup)
+ {
+ var bleg = new ManagedSession();
+
+ bleg.originate_ondestroy_delegate = bleg.originate_onhangup_method;
+ bleg.originate_onhangup_delegate = CreateStateHandlerDelegate(sess_b =>
+ {
+ if (onHangup != null)
+ {
+ onHangup(sess_b);
+ }
+ });
+ bleg.originate_table = new switch_state_handler_table();
+ bleg.originate_table.on_hangup = WrapStateHandlerDelegate(bleg.originate_onhangup_delegate);
+ bleg.originate_table.on_destroy = WrapStateHandlerDelegate(bleg.originate_ondestroy_delegate);
+ var res = 0 == bleg.originate(aLegSession, destination, (int)timeout.TotalSeconds, bleg.originate_table);
+ bleg.originate_keepalive_handle = GCHandle.Alloc(bleg, GCHandleType.Normal); // Prevent GC from eating the bleg
+ if (res)
+ {
+ bleg.Initialize();
+ return bleg;
+ }
+ else
+ {
+ // Dispose to free the lock
+ // The bleg lives on with its unmanaged memory freed
+ // Until CS_DESTROY gets called
+ bleg.Dispose();
+ return null;
+ }
+ }
+
+ // Convenience
+ public bool IsAvailable
+ {
+ get { return this.Ready(); }
+ }
+
+ public Guid Uuid
+ {
+ get
+ {
+ if (allocated == 0) throw new InvalidOperationException("Session has not been initialized.");
+ return new Guid(this.GetUuid());
+ }
+ }
+
+ public switch_call_cause_t CallCause
+ {
+ get
+ {
+ if (allocated == 0) throw new InvalidOperationException("Session has not been initialized.");
+ return freeswitch.switch_channel_get_cause(this.channel);
+ }
+ }
+
+ ChannelVariables _variables; // Set on ManagedSession init
+ public ChannelVariables Variables
+ {
+ get
+ {
+ if (_variables == null)
+ {
+ _variables = new ChannelVariables(this);
+ }
+ return _variables;
+ }
+ }
+ }
+}
Deleted: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PluginInterfaces.cs
Deleted: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PluginManager.cs
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/DefaultExecuteCommand.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/DefaultExecuteCommand.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/DefaultExecuteCommand.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections.ObjectModel;
+
+namespace FreeSWITCH.Managed
+{
+ public class ExecuteCommandOnModuleList : IExecuteCommand
+ {
+ public ModuleList moduleList;
+ public ExecuteCommandOnModuleList(ModuleList moduleList)
+ {
+ this.moduleList = moduleList;
+ }
+
+ public bool Execute(string command, IntPtr streamHandle, IntPtr eventHandle)
+ {
+ bool returnValue = false;
+ this.moduleList.Items.ForEach(module =>
+ {
+ bool result = module.Proxy.PluginHandlerOrchestrator.Execute(command, streamHandle, eventHandle);
+ if (result == true) { returnValue = true; }
+ });
+ return returnValue;
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/ExecuteBackgroundCommandOnCollection.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/ExecuteBackgroundCommandOnCollection.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/ExecuteBackgroundCommandOnCollection.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace FreeSWITCH.Managed
+{
+ public class ExecuteBackgroundCommandOnCollection : IExecuteBackgroundCommand
+ {
+ public SynchronizedList<IExecuteBackgroundCommand> Commands { get; private set; }
+ private ILogger logDirector;
+
+ public ExecuteBackgroundCommandOnCollection(ILogger logDirector)
+ {
+ this.logDirector = logDirector;
+ this.Commands = new SynchronizedList<IExecuteBackgroundCommand>();
+ }
+
+ public bool ExecuteBackground(string command)
+ {
+ try
+ {
+ bool runResult = true;
+ foreach (var commandObject in Commands.Items)
+ {
+ bool success = commandObject.ExecuteBackground(command);
+ if (!success)
+ {
+ runResult = false;
+ }
+ }
+ return runResult;
+ }
+ catch (Exception ex)
+ {
+ logDirector.Error(string.Format("Exception in ExecuteBackground({0}): {1}", command, ex.ToString()));
+ return false;
+ }
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/ExecuteBackgroundCommandOnModuleList.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/ExecuteBackgroundCommandOnModuleList.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/ExecuteBackgroundCommandOnModuleList.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections.ObjectModel;
+
+namespace FreeSWITCH.Managed
+{
+ public class ExecuteBackgroundCommandOnModuleList : IExecuteBackgroundCommand
+ {
+ public ModuleList moduleList;
+ public ExecuteBackgroundCommandOnModuleList(ModuleList moduleList)
+ {
+ this.moduleList = moduleList;
+ }
+
+ public bool ExecuteBackground(string command)
+ {
+ bool returnValue = false;
+ this.moduleList.Items.ForEach(module =>
+ {
+ bool result = module.Proxy.PluginHandlerOrchestrator.ExecuteBackground(command);
+ if (result == true) { returnValue = true; }
+ });
+ return returnValue;
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/ExecuteCommandOnCollection.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/ExecuteCommandOnCollection.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/ExecuteCommandOnCollection.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace FreeSWITCH.Managed
+{
+ public class ExecuteCommandOnCollection : IExecuteCommand
+ {
+ public SynchronizedList<IExecuteCommand> Commands { get; private set; }
+ private ILogger logDirector;
+
+ public ExecuteCommandOnCollection(ILogger logDirector)
+ {
+ this.logDirector = logDirector;
+ this.Commands = new SynchronizedList<IExecuteCommand>();
+ }
+
+ public bool Execute(string command, IntPtr streamHandle, IntPtr eventHandle)
+ {
+ try
+ {
+ bool runResult = true;
+ foreach (var commandObject in Commands.Items)
+ {
+ bool success = commandObject.Execute(command, streamHandle, eventHandle);
+ if (!success)
+ {
+ runResult = false;
+ }
+ }
+ return runResult;
+ }
+ catch (Exception ex)
+ {
+ logDirector.Error(string.Format("Exception in Execute({0}): {1}", command, ex.ToString()));
+ return false;
+ }
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/IExecuteBackgroundCommand.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/IExecuteBackgroundCommand.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/IExecuteBackgroundCommand.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections.ObjectModel;
+
+namespace FreeSWITCH.Managed
+{
+ public interface IExecuteBackgroundCommand
+ {
+ bool ExecuteBackground(string command);
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/IExecuteCommand.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/IExecuteCommand.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/IExecuteCommand.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections.ObjectModel;
+
+namespace FreeSWITCH.Managed
+{
+ public interface IExecuteCommand
+ {
+ bool Execute(string command, IntPtr streamHandle, IntPtr eventHandle);
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/IReloadCommand.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/IReloadCommand.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/IReloadCommand.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections.ObjectModel;
+
+namespace FreeSWITCH.Managed
+{
+ public interface IReloadCommand
+ {
+ bool Reload(string command);
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/IRunCommand.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/IRunCommand.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/IRunCommand.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections.ObjectModel;
+
+namespace FreeSWITCH.Managed
+{
+ public interface IRunCommand
+ {
+ bool Run(string command, IntPtr sessionHandle);
+ }
+}
\ No newline at end of file
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/ReloadCommandDirector.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/ReloadCommandDirector.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/ReloadCommandDirector.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace FreeSWITCH.Managed
+{
+ public class ReloadCommandOnCollection : IReloadCommand
+ {
+ public SynchronizedList<IReloadCommand> Commands { get; private set; }
+ private ILogger logDirector;
+
+ public ReloadCommandOnCollection(ILogger logDirector)
+ {
+ this.logDirector = logDirector;
+ this.Commands = new SynchronizedList<IReloadCommand>();
+ }
+
+ public bool Reload(string command)
+ {
+ try
+ {
+ bool runResult = true;
+ foreach (var commandObject in Commands.Items)
+ {
+ bool success = commandObject.Reload(command);
+ if (!success)
+ {
+ runResult = false;
+ }
+ }
+ return runResult;
+ }
+ catch (Exception ex)
+ {
+ logDirector.Error(string.Format("Error reloading {0}: {1}", command, ex.ToString()));
+ return false;
+ }
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/ReloadCommandOnModuleList.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/ReloadCommandOnModuleList.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/ReloadCommandOnModuleList.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+
+namespace FreeSWITCH.Managed
+{
+ public class ReloadCommandOnModuleList : IReloadCommand
+ {
+ private IDirectoryController directories;
+ public ModuleList moduleList;
+ private IModuleLoader moduleLoader;
+
+ public ReloadCommandOnModuleList(IDirectoryController directories, ModuleList moduleList, IModuleLoader moduleLoader)
+ {
+ this.directories = directories;
+ this.moduleList = moduleList;
+ this.moduleLoader = moduleLoader;
+ }
+
+ public bool Reload(string command)
+ {
+ try
+ {
+ if (Path.IsPathRooted(command))
+ {
+ moduleLoader.LoadModule(command);
+ }
+ else
+ {
+ moduleLoader.LoadModule(Path.Combine(this.directories.ModuleDirectoryPath, command));
+ }
+ return true;
+ }
+ catch (Exception ex)
+ {
+ Log.WriteLine(LogLevel.Error, "Error reloading {0}: {1}", command, ex.ToString());
+ return false;
+ }
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/RunCommandOnCollection.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/RunCommandOnCollection.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/RunCommandOnCollection.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections.ObjectModel;
+
+namespace FreeSWITCH.Managed
+{
+ public class RunCommandOnCollection : IRunCommand
+ {
+ public SynchronizedList<IRunCommand> Commands { get; private set; }
+ private ILogger logDirector;
+
+ public RunCommandOnCollection(ILogger logDirector)
+ {
+ this.logDirector = logDirector;
+ this.Commands = new SynchronizedList<IRunCommand>();
+ }
+
+ public bool Run(string command, IntPtr sessionHandle)
+ {
+ try
+ {
+ bool runResult = true;
+ foreach (var commandObject in Commands.Items)
+ {
+ bool success = commandObject.Run(command, sessionHandle);
+ if (!success)
+ {
+ runResult = false;
+ }
+ }
+ return runResult;
+ }
+ catch (Exception ex)
+ {
+ logDirector.Error(string.Format("Exception in Run({0}): {1}", command, ex.ToString()));
+ return false;
+ }
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/RunCommandOnModuleList.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/RunCommandOnModuleList.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Commands/RunCommandOnModuleList.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections.ObjectModel;
+
+namespace FreeSWITCH.Managed
+{
+ public class RunCommandOnModuleList : IRunCommand
+ {
+ public ModuleList moduleList;
+ public RunCommandOnModuleList(ModuleList moduleList)
+ {
+ this.moduleList = moduleList;
+ }
+
+ public bool Run(string command, IntPtr sessionHandle)
+ {
+ bool returnValue = false;
+ this.moduleList.Items.ForEach(module =>
+ {
+ bool result = module.Proxy.PluginHandlerOrchestrator.Run(command, sessionHandle);
+ if (result == true) { returnValue = true; }
+ });
+ return returnValue;
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/DefaultRegistry.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/DefaultRegistry.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/DefaultRegistry.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+using System.IO;
+
+namespace FreeSWITCH.Managed
+{
+ public class DefaultRegistry
+ {
+ public void Register(DefaultServiceLocator registry)
+ {
+ //System.Diagnostics.Debugger.Break();
+ ConfigureProxyTypes(registry);
+ registry.RegisterSingleton<IDirectoryController>(container =>
+ {
+ return new DefaultDirectoryController();
+ });
+ registry.RegisterSingleton<LoggerContainer>(container =>
+ {
+ var logger = new LoggerContainer();
+ logger.Add(new DefaultLogger());
+ return logger;
+ });
+ registry.Register<ILogger>(container =>
+ {
+ return container.Create<LoggerContainer>();
+ });
+ registry.Register<ILoggerContainer>(container =>
+ {
+ return container.Create<LoggerContainer>();
+ });
+ registry.Register<IModuleLoader>(container =>
+ {
+ return container.Create<SelectiveModuleLoader>();
+ });
+ registry.Register<IAppDomainFactory>(container =>
+ {
+ return container.Create<DefaultAppDomainFactory>();
+ });
+ registry.DeclareSingleton(typeof(ModuleList));
+ registry.DeclareSingleton(typeof(RunCommandOnCollection));
+ registry.DeclareSingleton(typeof(ExecuteCommandOnCollection));
+ registry.DeclareSingleton(typeof(ExecuteBackgroundCommandOnCollection));
+ registry.DeclareSingleton(typeof(ReloadCommandOnCollection));
+ registry.DeclareSingleton(typeof(DefaultModuleDirectorySupervisor));
+ registry.DeclareSingleton(typeof(AssemblyResolver));
+ //registry.DeclareSingleton(typeof(DefaultLoader));
+ AddCommandHandlersToCollections();
+
+ }
+
+ private static void AddCommandHandlersToCollections()
+ {
+ RunCommandOnModuleList runcommand = DefaultServiceLocator.Container.Create<RunCommandOnModuleList>();
+ DefaultServiceLocator.Container.Create<RunCommandOnCollection>().Commands.Add(runcommand);
+
+ ExecuteCommandOnModuleList executecommmand = DefaultServiceLocator.Container.Create<ExecuteCommandOnModuleList>();
+ DefaultServiceLocator.Container.Create<ExecuteCommandOnCollection>().Commands.Add(executecommmand);
+
+ ExecuteBackgroundCommandOnModuleList executebackgroundcommmand = DefaultServiceLocator.Container.Create<ExecuteBackgroundCommandOnModuleList>();
+ DefaultServiceLocator.Container.Create<ExecuteBackgroundCommandOnCollection>().Commands.Add(executebackgroundcommmand);
+
+ ReloadCommandOnModuleList reloadcommand = DefaultServiceLocator.Container.Create<ReloadCommandOnModuleList>();
+ DefaultServiceLocator.Container.Create<ReloadCommandOnCollection>().Commands.Add(reloadcommand);
+ }
+
+ public void ConfigureProxyTypes(DefaultServiceLocator registry)
+ {
+ ModuleProxyTypeDictionary dictionary = new ModuleProxyTypeDictionary();
+ dictionary.Add(".dll",typeof(ModuleProxy));
+ dictionary.Add(".exe",typeof(ModuleProxy));
+ dictionary.Add(".fsx",typeof(ModuleProxy));
+ dictionary.Add(".vbx",typeof(ModuleProxy));
+ dictionary.Add(".csx",typeof(ModuleProxy));
+ dictionary.Add(".jsx",typeof(ModuleProxy));
+ registry.RegisterSingleton<ModuleProxyTypeDictionary>(container =>
+ {
+ return dictionary;
+ });
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/DefaultServiceLocator.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/DefaultServiceLocator.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/DefaultServiceLocator.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+using System.IO;
+
+namespace FreeSWITCH.Managed
+{
+ public class DefaultServiceLocator : ObjectContainer
+ {
+ public static DefaultServiceLocator Container { get; private set; }
+
+ static DefaultServiceLocator()
+ {
+ DefaultServiceLocator.Container = new DefaultServiceLocator();
+ var registry = new DefaultRegistry();
+ registry.Register(DefaultServiceLocator.Container);
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/DefaultAppDomainFactory.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/DefaultAppDomainFactory.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/DefaultAppDomainFactory.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+
+namespace FreeSWITCH.Managed
+{
+ public class DefaultAppDomainFactory : IAppDomainFactory
+ {
+ private IDirectoryController directories;
+ private int appDomainCount = 0;
+
+ public DefaultAppDomainFactory(IDirectoryController directories)
+ {
+ this.directories = directories;
+ }
+
+ public AppDomain CreateAppDomain(string filePath)
+ {
+ var setup = this.CreateSetup(filePath);
+ return AppDomain.CreateDomain(setup.ApplicationName, null, setup);
+ }
+
+ public AppDomainSetup CreateSetup(string filePath)
+ {
+ System.Threading.Interlocked.Increment(ref appDomainCount);
+ var setup = new AppDomainSetup();
+ setup.ApplicationBase = Native.freeswitch.SWITCH_GLOBAL_dirs.mod_dir;
+ setup.ShadowCopyDirectories = String.Format("{0};", directories.ModuleDirectoryPath);
+ setup.LoaderOptimization = LoaderOptimization.MultiDomainHost; // TODO: would MultiDomain work better since FreeSWITCH.Managed isn't gac'd?
+ setup.CachePath = directories.ShadowDirectoryPath;
+ setup.ShadowCopyFiles = "true";
+ setup.PrivateBinPath = "managed";
+ setup.ApplicationName = Path.GetFileName(filePath) + ";" + appDomainCount;
+ if (File.Exists(String.Format("{0}.config", filePath)))
+ {
+ setup.ConfigurationFile = String.Format("{0}.config", filePath);
+ }
+ return setup;
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/DefaultDirectoryController.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/DefaultDirectoryController.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/DefaultDirectoryController.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+using System.Reflection;
+
+namespace FreeSWITCH.Managed
+{
+ public class DefaultDirectoryController : IDirectoryController
+ {
+ public string ModuleDirectoryPath { get; private set; }
+ public string ShadowDirectoryPath { get; private set; }
+
+ public DefaultDirectoryController()
+ {
+ try
+ {
+ this.ModuleDirectoryPath = Path.Combine(Native.freeswitch.SWITCH_GLOBAL_dirs.mod_dir, "managed");
+ this.ShadowDirectoryPath = Path.Combine(this.ModuleDirectoryPath, "shadow");
+ }
+ catch
+ {
+ this.ModuleDirectoryPath = Path.Combine(System.IO.Path.GetTempPath(), Guid.NewGuid().ToString());
+ Directory.CreateDirectory(this.ModuleDirectoryPath);
+ this.ShadowDirectoryPath = Path.Combine(this.ModuleDirectoryPath, "shadow");
+ }
+ }
+
+ public bool ModuleDirectoryExists()
+ {
+ return Directory.Exists(this.ModuleDirectoryPath);
+ }
+
+ public void ClearShadowDirecory()
+ {
+ if (Directory.Exists(this.ShadowDirectoryPath))
+ {
+ Directory.Delete(this.ShadowDirectoryPath, true);
+ Directory.CreateDirectory(this.ShadowDirectoryPath);
+ }
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/DefaultModuleDirectorySupervisor.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/DefaultModuleDirectorySupervisor.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/DefaultModuleDirectorySupervisor.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+using System.Reflection;
+
+namespace FreeSWITCH.Managed
+{
+ public class DefaultModuleDirectorySupervisor
+ {
+ public IDirectoryController directories { get; private set; }
+ public ILogger logger { get; private set; }
+ public ModuleFileLoadQueue filesToLoad { get; private set; }
+ public ModuleFileLoadTimer loadTimer { get; private set; }
+
+ public DefaultModuleDirectorySupervisor(IDirectoryController directories, ILogger logger, IModuleLoader moduleLoader)
+ {
+ this.directories = directories;
+ this.logger = logger;
+ this.filesToLoad = new ModuleFileLoadQueue(directories);
+ this.loadTimer = new ModuleFileLoadTimer(filesToLoad,moduleLoader);
+ }
+ public bool Initialize()
+ {
+ logger.Debug(string.Format("FreeSWITCH.Managed loader is starting with directory '{0}'.", directories.ModuleDirectoryPath));
+ if (!Directory.Exists(directories.ModuleDirectoryPath))
+ {
+ logger.Error(string.Format("Managed directory not found: {0}", directories.ModuleDirectoryPath));
+ return false;
+ }
+ filesToLoad.Initialize();
+ loadTimer.Start();
+ return true;
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/DefaultModuleLoader.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/DefaultModuleLoader.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/DefaultModuleLoader.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+using System.IO;
+
+namespace FreeSWITCH.Managed
+{
+ public class DefaultModuleLoader : IModuleLoader
+ {
+ private ModuleList moduleList;
+ private ILogger logger;
+ public DefaultModuleLoader(ILogger logger, ModuleList moduleList)
+ {
+ this.moduleList = moduleList;
+ this.logger = logger;
+ }
+ public void LoadModule(string fileName)
+ {
+ try
+ {
+ fileName = RemoveDotConfigExtensionIfPresent(fileName);
+ if (moduleList.NoReloadEnabled(fileName)) { return; }
+ // Attempts to load the file. On failure, it will call unload.
+
+ // We might get a load for a file that's no longer there. Just unload the old one.
+ if (!File.Exists(fileName))
+ {
+ moduleList.RemoveAll(moduleList[fileName]);
+ return;
+ }
+ var module = DefaultServiceLocator.Container.Create<Module>();
+
+ module.Initialize(fileName);
+ moduleList.RemoveAll(moduleList[fileName]);
+ moduleList.Add(module);
+
+ logger.Info(string.Format("Finished loading {0} into domain {1}.", module.FilePath, module.Domain.FriendlyName));
+ }
+ catch (Exception ex)
+ {
+ moduleList.RemoveAll(moduleList[fileName]);
+ logger.Error(string.Format("Exception loading change from {0}: {1}", fileName, ex.ToString()));
+ }
+ }
+
+ private static string RemoveDotConfigExtensionIfPresent(string fileName)
+ {
+ if ((Path.GetExtension(fileName).ToLowerInvariant() == ".config"))
+ {
+ fileName = Path.ChangeExtension(fileName, null);
+ }
+ return fileName;
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/IDefaultAppDomainFactory.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/IDefaultAppDomainFactory.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/IDefaultAppDomainFactory.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+
+namespace FreeSWITCH.Managed
+{
+ public interface IAppDomainFactory
+ {
+ AppDomain CreateAppDomain(string filePath);
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/IDirectoryController.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/IDirectoryController.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/IDirectoryController.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+using System.Reflection;
+
+namespace FreeSWITCH.Managed
+{
+ public interface IDirectoryController
+ {
+ string ModuleDirectoryPath { get; }
+ string ShadowDirectoryPath { get; }
+ bool ModuleDirectoryExists();
+ void ClearShadowDirecory();
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/IModuleList.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/IModuleList.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/IModuleList.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections.ObjectModel;
+
+namespace FreeSWITCH.Managed
+{
+ public interface IModuleList
+ {
+ List<Module> this[string fileName] { get; }
+ bool NoReloadEnabled(string fileName);
+ void RemoveAll(List<Module> items);
+ void Add(Module item);
+ bool Remove(Module item);
+ void Clear();
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/IModuleLoader.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/IModuleLoader.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/IModuleLoader.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+using System.IO;
+
+namespace FreeSWITCH.Managed
+{
+ public interface IModuleLoader
+ {
+ void LoadModule(string fileName);
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/IPrimaryAppdomainExtension.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/IPrimaryAppdomainExtension.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/IPrimaryAppdomainExtension.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+using System.IO;
+
+namespace FreeSWITCH.Managed
+{
+ public interface IPrimaryAppdomainExtension
+ {
+ void Load();
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/ManagedDirectoryWatcher.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/ManagedDirectoryWatcher.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/ManagedDirectoryWatcher.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+
+namespace FreeSWITCH.Managed
+{
+ public class ManagedDirectoryWatcher : FileSystemWatcher
+ {
+ public Action<string> FileChanged { get; set; }
+
+ public ManagedDirectoryWatcher(string path) : base(path)
+ {
+ this.IncludeSubdirectories = false;
+ this.NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite;
+ this.EnableRaisingEvents = true;
+ this.Changed += watcher_Changed;
+ this.Created += watcher_Changed;
+ this.Deleted += watcher_Changed;
+ this.Renamed += watcher_Changed;
+ }
+
+ private void watcher_Changed(object sender, FileSystemEventArgs e)
+ {
+ if (this.FileChanged != null)
+ {
+ this.FileChanged.Invoke(e.FullPath);
+ }
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/Module.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/Module.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/Module.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+using System.Reflection;
+
+namespace FreeSWITCH.Managed
+{
+
+ public class Module
+ {
+ public string FilePath { get; private set; }
+ public AppDomain Domain { get; private set; }
+ public IModuleProxy Proxy { get; private set; }
+ private IAppDomainFactory appDomainFactory;
+ private ILoggerContainer primaryLoggerContainer;
+ private ModuleProxyTypeDictionary proxyTypes;
+ private IDirectoryController directories;
+
+ public Module(ILoggerContainer primaryLoggerContainer,
+ IDirectoryController directories,
+ IAppDomainFactory appDomainFactory,
+ ModuleProxyTypeDictionary proxyTypes)
+ {
+ this.proxyTypes = proxyTypes;
+ this.appDomainFactory = appDomainFactory;
+ this.primaryLoggerContainer = primaryLoggerContainer;
+ this.directories = directories;
+ }
+
+ public void Initialize(string filePath)
+ {
+ this.FilePath = filePath;
+ if (!proxyTypes.ContainsKey(filePath.GetLoweredFileExtension())) { return; }
+ Type proxyType = proxyTypes[filePath.GetLoweredFileExtension()];
+
+ this.Domain = appDomainFactory.CreateAppDomain(FilePath);
+
+ try
+ {
+ this.Proxy = (IModuleProxy)Domain.CreateInstanceAndUnwrap(proxyType.Assembly.FullName, proxyType.FullName, null);
+ this.primaryLoggerContainer.Add(this.Proxy.LogDirector);
+ this.Proxy.Logger.Add(this.primaryLoggerContainer);
+ this.Proxy.MasterAssemblyPath = this.FilePath;
+ bool success = this.Proxy.AssemblyLoader.Load(this.FilePath);
+ if (!success)
+ {
+ throw new Exception("Unable to Initialize Module");
+ }
+ }
+ catch (Exception ex)
+ {
+ primaryLoggerContainer.Alert(string.Format("Exception loading {0}: {1}", FilePath, ex.ToString()));
+ AppDomain.Unload(this.Domain);
+ throw;
+ }
+ }
+
+ public void Remove()
+ {
+ this.primaryLoggerContainer.Remove(this.Proxy.LogDirector);
+ var t = new System.Threading.Thread(() =>
+ {
+ var friendlyName = this.Domain.FriendlyName;
+ primaryLoggerContainer.Info(string.Format("Starting to unload {0}, domain {1}.", this.FilePath, friendlyName));
+ try
+ {
+ var d = this.Domain;
+ this.Proxy.PluginHandlerOrchestrator.Unload();
+ this.Proxy = null;
+ this.Domain = null;
+ AppDomain.Unload(d);
+ primaryLoggerContainer.Info(string.Format("Unloaded {0}, domain {1}.", this.FilePath, friendlyName));
+ GC.WaitForPendingFinalizers();
+ }
+ catch (Exception ex)
+ {
+ primaryLoggerContainer.Alert(string.Format("Could not unload {0}, domain {1}: {2}", this.FilePath, friendlyName, ex.ToString()));
+ }
+ }) { Priority = System.Threading.ThreadPriority.BelowNormal, IsBackground = true };
+ t.Start();
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/ModuleFileLoadTimer.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/ModuleFileLoadTimer.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/ModuleFileLoadTimer.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+using System.Threading;
+
+namespace FreeSWITCH.Managed
+{
+ public class ModuleFileLoadTimer
+ {
+ private Timer loadTick;
+ private ModuleFileLoadQueue modulesToLoad;
+ private IModuleLoader moduleLoader;
+
+ public ModuleFileLoadTimer(ModuleFileLoadQueue modulesToLoad, IModuleLoader moduleLoader)
+ {
+ this.modulesToLoad = modulesToLoad;
+ this.moduleLoader = moduleLoader;
+ loadTick = new System.Threading.Timer(this.OnTick);
+ }
+
+ public void Start()
+ {
+ loadTick.Change(1000, 1000);
+ }
+
+ public void Stop()
+ {
+ loadTick.Change(System.Threading.Timeout.Infinite,
+ System.Threading.Timeout.Infinite);
+ }
+
+ public void Load()
+ {
+ var items = modulesToLoad.Files.Items;
+ modulesToLoad.Files.Clear();
+ foreach (var file in items)
+ {
+ //Todo: eliminate this static reference.
+ moduleLoader.LoadModule(file);
+ }
+ }
+
+ private void OnTick(object state)
+ {
+ this.Load();
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/ModuleList.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/ModuleList.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/ModuleList.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections.ObjectModel;
+
+namespace FreeSWITCH.Managed
+{
+ public class ModuleList : SynchronizedList<Module>, IModuleList
+ {
+ public List<Module> this[string fileName]
+ {
+ get
+ {
+ lock (this.syncRoot)
+ {
+ return this.innerCollection.Where(p => string.Equals(fileName, p.FilePath, StringComparison.OrdinalIgnoreCase)).ToList();
+ }
+ }
+ }
+
+ public bool NoReloadEnabled(string fileName)
+ {
+ lock (this.syncRoot)
+ {
+ foreach (var module in this.innerCollection.Where(p => string.Equals(fileName, p.FilePath, StringComparison.OrdinalIgnoreCase)))
+ {
+ if (module.Proxy.PluginHandlerOrchestrator.NoReload)
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+ }
+
+ public new void Add(Module item)
+ {
+ lock (this.syncRoot)
+ {
+ this.innerCollection.Add(item);
+ }
+ }
+
+ public new bool Remove(Module item)
+ {
+ lock (this.syncRoot)
+ {
+ return this.innerCollection.Remove(item);
+ }
+ }
+
+ public new void Clear()
+ {
+ lock (this.syncRoot)
+ {
+ this.innerCollection.Clear();
+ }
+ }
+
+ public void RemoveAll(List<Module> items)
+ {
+ lock (this.syncRoot)
+ {
+ this.innerCollection.RemoveAll(info => items.Contains(info));
+ }
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/ModuleProxyTypeDictionary.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/ModuleProxyTypeDictionary.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/ModuleProxyTypeDictionary.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+using System.Reflection;
+
+namespace FreeSWITCH.Managed
+{
+ public class ModuleProxyTypeDictionary : Dictionary<string, Type>
+ {
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/PluginFileLoadQueue.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/PluginFileLoadQueue.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/PluginFileLoadQueue.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+using System.Timers;
+
+namespace FreeSWITCH.Managed
+{
+ public class ModuleFileLoadQueue
+ {
+ private IDirectoryController directories;
+ private ManagedDirectoryWatcher watcher;
+ public SynchronizedList<string> Files { get; private set; }
+
+ public ModuleFileLoadQueue(IDirectoryController directories)
+ {
+ this.directories = directories;
+ this.Files = new SynchronizedList<string>();
+ }
+
+ public void Initialize()
+ {
+ this.watcher = new ManagedDirectoryWatcher(directories.ModuleDirectoryPath);
+ this.watcher.FileChanged = this.ChangedFileFound;
+ var allFiles = Directory.GetFiles(directories.ModuleDirectoryPath);
+ foreach (var file in allFiles)
+ {
+ this.Files.Add(file);
+ }
+ }
+
+ private void ChangedFileFound(string fullPath)
+ {
+ this.Files.Add(fullPath);
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/PrimaryDomainExtensionModuleLoader.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/PrimaryDomainExtensionModuleLoader.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/PrimaryDomainExtensionModuleLoader.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+using System.IO;
+
+namespace FreeSWITCH.Managed
+{
+ public class PrimaryDomainExtensionModuleLoader : IModuleLoader
+ {
+ private ILogger logger;
+ public PrimaryDomainExtensionModuleLoader(ILogger logger)
+ {
+ this.logger = logger;
+
+ }
+
+ public void LoadModule(string fileName)
+ {
+ this.logger.Notice(string.Format("Loading file {0}", fileName));
+ if (File.Exists(fileName))
+ {
+ Assembly loaded = Assembly.LoadFile(fileName);
+ var types = loaded.GetExportedTypes();
+ foreach (var item in types)
+ {
+ this.logger.Notice(string.Format("Checking type {0}", item.FullName));
+ if (typeof(IPrimaryAppdomainExtension).IsAssignableFrom(item))
+ {
+ this.logger.Notice(string.Format("Found extension {0}", item.FullName));
+ var instance = loaded.CreateInstance(item.FullName) as IPrimaryAppdomainExtension;
+ instance.Load();
+ }
+ }
+
+ }
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/SelectiveModuleLoader.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/SelectiveModuleLoader.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/ModuleDirectory/SelectiveModuleLoader.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+using System.IO;
+
+namespace FreeSWITCH.Managed
+{
+ public class SelectiveModuleLoader : IModuleLoader
+ {
+ private PrimaryDomainExtensionModuleLoader primaryLoader;
+ private DefaultModuleLoader defaultLoader;
+ public SelectiveModuleLoader(DefaultModuleLoader defaultLoader, PrimaryDomainExtensionModuleLoader primaryLoader)
+ {
+ this.primaryLoader = primaryLoader;
+ this.defaultLoader = defaultLoader;
+ }
+ public void LoadModule(string fileName)
+ {
+ if (fileName.Contains(".primary"))
+ {
+ this.primaryLoader.LoadModule(fileName);
+ }
+ else
+ {
+ this.defaultLoader.LoadModule(fileName);
+ }
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Utility/AssemblyResolver.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Utility/AssemblyResolver.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/PrimaryAppdomain/Utility/AssemblyResolver.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+using System.IO;
+
+namespace FreeSWITCH.Managed
+{
+ public class AssemblyResolver
+ {
+ private ResolveEventHandler defaultEventResolver;
+ private IDirectoryController directories;
+ private ILogger logger;
+ public AssemblyResolver(ILogger logger, IDirectoryController directories)
+ {
+ this.directories = directories;
+ this.logger = logger;
+ this.defaultEventResolver = new ResolveEventHandler(DefaultAssemblyResolver);
+ }
+
+ public void AttachDefaultAssemblyResolver()
+ {
+ AppDomain.CurrentDomain.AssemblyResolve += defaultEventResolver;
+ }
+
+ public void DetatchDefaultAssemblyResolver()
+ {
+ AppDomain.CurrentDomain.AssemblyResolve -= defaultEventResolver;
+ }
+
+ // This event handler resolves the filename of the requested assembly.
+ // http://support.microsoft.com/kb/837908
+ // Can this be simplified with AppDomain.CurrentDomain.AppendPrivatePath(string path)?
+ private Assembly DefaultAssemblyResolver(object sender, ResolveEventArgs args)
+ {
+ logger.Info(string.Format("Resolving assembly '{0}'.", args.Name));
+ string currentAssemblyName = Assembly.GetExecutingAssembly().FullName;
+ if (args.Name == currentAssemblyName)
+ {
+ return Assembly.GetExecutingAssembly();
+ }
+ string[] assemblyRefernceComponents = args.Name.Split(',');
+ string newAssemblyName = assemblyRefernceComponents[0];
+ string newAssemblyPath = Path.Combine(directories.ModuleDirectoryPath, string.Format("{0}.dll", newAssemblyName));
+ logger.Info(string.Format("Resolving to: '{0}'.", newAssemblyPath));
+ if (File.Exists(newAssemblyPath))
+ {
+ return Assembly.LoadFile(newAssemblyPath);
+ }
+ else
+ {
+ return null;
+ }
+ }
+ }
+}
Deleted: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/ScriptPluginManager.cs
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/Exceptions/ModuleDoesNotReferenceFreeswitchManagedDllException.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/Exceptions/ModuleDoesNotReferenceFreeswitchManagedDllException.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/Exceptions/ModuleDoesNotReferenceFreeswitchManagedDllException.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.Serialization;
+
+namespace FreeSWITCH
+{
+ public class ModuleDoesNotReferenceFreeswitchManagedDllException : Exception
+ {
+ public ModuleDoesNotReferenceFreeswitchManagedDllException()
+ {
+
+ }
+ public ModuleDoesNotReferenceFreeswitchManagedDllException(string message)
+ : base(message)
+ {
+
+ }
+ public ModuleDoesNotReferenceFreeswitchManagedDllException(string message, Exception innerException)
+ : base(message, innerException)
+ {
+
+ }
+ protected ModuleDoesNotReferenceFreeswitchManagedDllException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
+ : base(info, context)
+ {
+
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/Exceptions/RunNotifyException.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/Exceptions/RunNotifyException.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/Exceptions/RunNotifyException.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.Serialization;
+
+namespace FreeSWITCH
+{
+ public class RunNotifyException : Exception
+ {
+ public RunNotifyException()
+ {
+
+ }
+ public RunNotifyException(string message)
+ : base(message)
+ {
+
+ }
+ public RunNotifyException(string message, Exception innerException)
+ : base(message, innerException)
+ {
+
+ }
+ protected RunNotifyException(SerializationInfo info, StreamingContext context)
+ : base(info, context)
+ {
+
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/Exceptions/ScriptDoesNotCompileException.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/Exceptions/ScriptDoesNotCompileException.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/Exceptions/ScriptDoesNotCompileException.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.Serialization;
+
+namespace FreeSWITCH
+{
+ public class ScriptDoesNotCompileException : Exception
+ {
+ public ScriptDoesNotCompileException()
+ {
+
+ }
+ public ScriptDoesNotCompileException(string message)
+ : base(message)
+ {
+
+ }
+ public ScriptDoesNotCompileException(string message, Exception innerException)
+ : base(message, innerException)
+ {
+
+ }
+ protected ScriptDoesNotCompileException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
+ : base(info, context)
+ {
+
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/Interfaces/IObjectContainer.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/Interfaces/IObjectContainer.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/Interfaces/IObjectContainer.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.IO;
+using FreeSWITCH.Managed;
+
+namespace FreeSWITCH
+{
+ public interface IObjectContainer
+ {
+ SynchronizedDictionary<string, object> Configuration { get; }
+ void DeclareSingleton(Type type);
+ void Register<T>(Creator creator);
+ void RegisterSingleton<T>(Creator creator);
+ T Create<T>();
+ T GetConfiguration<T>(string name);
+ string ToString();
+ void Reset();
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/Interfaces/ISynchronizedDictionary.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/Interfaces/ISynchronizedDictionary.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/Interfaces/ISynchronizedDictionary.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections.ObjectModel;
+
+namespace FreeSWITCH.Managed
+{
+ public interface ISynchronizedDictionary<TKey, TValue>
+ {
+ TValue this[TKey key] { get; set; }
+ void Add(TKey key, TValue value);
+ bool Remove(TKey key);
+ void RemoveValue(TValue value);
+ void Clear();
+ Dictionary<TKey, TValue> ToDictionary();
+ ReadOnlyCollection<TKey> Keys { get; }
+ ReadOnlyCollection<TValue> Values { get; }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/Interfaces/ISynchronizedList.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/Interfaces/ISynchronizedList.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/Interfaces/ISynchronizedList.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections.ObjectModel;
+
+namespace FreeSWITCH.Managed
+{
+ public interface ISynchronizedList<T>
+ {
+ void Add(T item);
+ bool Remove(T item);
+ void Clear();
+ ReadOnlyCollection<T> Items { get; }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/ObjectContainer.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/ObjectContainer.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/ObjectContainer.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,139 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.IO;
+using FreeSWITCH.Managed;
+using System.Text;
+
+namespace FreeSWITCH
+{
+ public delegate object Creator(ObjectContainer container);
+ public class ObjectContainer : IObjectContainer
+ {
+ private readonly SynchronizedDictionary<string, object> configuration =
+ new SynchronizedDictionary<string, object>();
+ private readonly SynchronizedDictionary<Type, Creator> typeToCreator =
+ new SynchronizedDictionary<Type, Creator>();
+ private readonly SynchronizedDictionary<Type, object> singletons =
+ new SynchronizedDictionary<Type, object>();
+
+ public SynchronizedDictionary<string, object> Configuration
+ {
+ get { return configuration; }
+ }
+
+ public void DeclareSingleton(Type type)
+ {
+ singletons[type]=this.Create(type);
+ }
+
+ public void Register<T>(Creator creator)
+ {
+ typeToCreator[typeof(T)]=creator;
+ }
+
+ public void RegisterSingleton<T>(Creator creator)
+ {
+ typeToCreator[typeof(T)]=creator;
+ singletons[typeof(T)]=this.Create<T>();
+ }
+
+ public T Create<T>()
+ {
+ try
+ {
+ return (T)singletons[typeof(T)];
+ }
+ catch { }
+ try
+ {
+ if (typeToCreator.Keys.Contains(typeof(T)))
+ {
+ return (T)typeToCreator[typeof(T)](this);
+ }
+ else
+ {
+ return (T)Create(typeof(T));
+ }
+ }
+ catch (Exception ex)
+ {
+ throw new Exception(string.Format("Type {0} not registered. Exception: {1}{2}", typeof(T), ex, this.ToString()));
+ }
+ }
+ internal object Create(Type type)
+ {
+ try
+ {
+ return singletons[type];
+ }
+ catch { }
+ if (typeToCreator.Keys.Contains(type))
+ {
+ return (typeToCreator[type](this));
+ }
+ ConstructorInfo constructor;
+ try
+ {
+ return Activator.CreateInstance(type);
+ }
+ catch
+ {
+ try
+ {
+ constructor = type.GetConstructors()[0];
+ }
+ catch (Exception ex)
+ {
+ throw new Exception(string.Format("Type {0} not registered. Exception: {1}{2}", type, ex, this.ToString()));
+ }
+ }
+ ParameterInfo[] constructorParameters = constructor.GetParameters();
+ if (constructorParameters.Length == 0) return Activator.CreateInstance(type);
+ List<object> parameters = new List<object>(constructorParameters.Length);
+ foreach (ParameterInfo parameterInfo in constructorParameters)
+ {
+ Type parameterType = parameterInfo.ParameterType;
+ parameters.Add(this.Create(parameterType));
+ }
+ return constructor.Invoke(parameters.ToArray());
+ }
+
+
+ public T GetConfiguration<T>(string name)
+ {
+ return (T)configuration[name];
+ }
+
+ public override string ToString()
+ {
+ StringBuilder description = new StringBuilder();
+ description.AppendLine("Registered Types in Container:");
+ this.typeToCreator.Keys.ForEach(key =>
+ {
+ description.AppendLine(string.Format("{0}:{1}", key, this.typeToCreator[key]));
+ });
+ description.AppendLine("Singletons in Container:");
+ this.singletons.Keys.ForEach(key =>
+ {
+ description.AppendLine(string.Format("{0}:{1}", key, this.singletons[key]));
+ });
+ description.AppendLine("Configuration objects in Container:");
+ this.configuration.Keys.ForEach(key =>
+ {
+ description.AppendLine(string.Format("{0}:{1}", key, this.configuration[key]));
+ });
+ description.AppendLine(string.Empty);
+ return description.ToString();
+ }
+
+ public void Reset()
+ {
+ this.configuration.Clear();
+ this.singletons.Clear();
+ this.typeToCreator.Clear();
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/SynchronizedDictionary.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/SynchronizedDictionary.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/SynchronizedDictionary.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,111 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections.ObjectModel;
+
+namespace FreeSWITCH.Managed
+{
+ public class SynchronizedDictionary<TKey, TValue> : ISynchronizedDictionary<TKey, TValue>
+ {
+ protected Dictionary<TKey, TValue> innerCollection;
+ protected object syncRoot;
+
+ public SynchronizedDictionary()
+ {
+ this.syncRoot = new object();
+ this.innerCollection = new Dictionary<TKey, TValue>();
+ }
+
+ public SynchronizedDictionary(IEqualityComparer<TKey> comparer)
+ {
+ this.syncRoot = new object();
+ this.innerCollection = new Dictionary<TKey, TValue>(comparer);
+ }
+
+ public TValue this[TKey key]
+ {
+ get
+ {
+ lock (this.syncRoot)
+ {
+ return this.innerCollection[key];
+ }
+ }
+ set
+ {
+ lock (this.syncRoot)
+ {
+ this.innerCollection[key]=value;
+ }
+ }
+ }
+
+ public void Add(TKey key, TValue value)
+ {
+ lock (this.syncRoot)
+ {
+ this.innerCollection.Add(key, value);
+ }
+ }
+
+ public bool Remove(TKey key)
+ {
+ lock (this.syncRoot)
+ {
+ return this.innerCollection.Remove(key);
+ }
+ }
+
+ public void RemoveValue(TValue value)
+ {
+ lock (this.syncRoot)
+ {
+ List<TKey> keys = (from pair in this.innerCollection
+ where pair.Value.Equals(value)
+ select pair.Key).ToList();
+ keys.ForEach(key => this.innerCollection.Remove(key));
+ }
+ }
+
+ public void Clear()
+ {
+ lock (this.syncRoot)
+ {
+ this.innerCollection.Clear();
+ }
+ }
+
+
+ public Dictionary<TKey, TValue> ToDictionary()
+ {
+ lock (this.syncRoot)
+ {
+ var result = new Dictionary<TKey, TValue>();
+ this.innerCollection.ForEach((pair) => result.Add(pair.Key, pair.Value));
+ return result;
+ }
+ }
+ public ReadOnlyCollection<TKey> Keys
+ {
+ get
+ {
+ lock (this.syncRoot)
+ {
+ return this.innerCollection.Keys.ToList().AsReadOnly();
+ }
+ }
+ }
+
+ public ReadOnlyCollection<TValue> Values
+ {
+ get
+ {
+ lock (this.syncRoot)
+ {
+ return this.innerCollection.Values.ToList().AsReadOnly();
+ }
+ }
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/SynchronizedList.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/SynchronizedList.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Types/SynchronizedList.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections.ObjectModel;
+
+namespace FreeSWITCH.Managed
+{
+ public class SynchronizedList<T> : ISynchronizedList<T>
+ {
+ protected List<T> innerCollection;
+ protected object syncRoot;
+
+ public SynchronizedList()
+ {
+ this.syncRoot = new object();
+ this.innerCollection = new List<T>();
+ }
+
+ public void Add(T item)
+ {
+ lock (this.syncRoot)
+ {
+ this.innerCollection.Add(item);
+ }
+ }
+
+ public bool Remove(T item)
+ {
+ lock (this.syncRoot)
+ {
+ return this.innerCollection.Remove(item);
+ }
+ }
+
+ public void Clear()
+ {
+ lock (this.syncRoot)
+ {
+ this.innerCollection.Clear();
+ }
+ }
+
+ public ReadOnlyCollection<T> Items
+ {
+ get
+ {
+ lock (this.syncRoot)
+ {
+ return this.innerCollection.ToList().AsReadOnly();
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/AppdomainTests/AppdomainExplorationTests.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/AppdomainTests/AppdomainExplorationTests.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/AppdomainTests/AppdomainExplorationTests.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+
+namespace FreeSWITCH.Managed.Tests
+{
+ public interface IConsoleWriter
+ {
+ void WriteLine(string line);
+ }
+ public class ConsoleWriter : MarshalByRefObject, IConsoleWriter
+ {
+ public void WriteLine(string line)
+ {
+ Console.WriteLine(line);
+ throw new Exception(line);
+ }
+ }
+ public interface IConsoleProxy
+ {
+ IConsoleWriter writer { get; set; }
+ }
+ public class ConsoleProxy : MarshalByRefObject, IConsoleProxy
+ {
+ public IConsoleWriter writer { get; set; }
+ public ConsoleProxy()
+ {
+ this.writer = new ConsoleWriter();
+ }
+ }
+
+ [TestFixture]
+ public class AppdomainExplorationTests
+ {
+ [Test]
+ [ExpectedException(ExpectedMessage="Smoke Test")]
+ public void CreateAndUnwrapInstance()
+ {
+ AppDomainSetup appSetup = new AppDomainSetup();
+ appSetup.ShadowCopyFiles = "true";
+ appSetup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;
+ appSetup.ActivationArguments = AppDomain.CurrentDomain.SetupInformation.ActivationArguments;
+ Type writer = typeof(ConsoleWriter);
+ AppDomain domain = AppDomain.CreateDomain("TestDomain", null, appSetup);
+ var instance = (ConsoleWriter)domain.CreateInstanceAndUnwrap(writer.Assembly.FullName,writer.FullName);
+ instance.WriteLine("Smoke Test");
+ AppDomain.Unload(domain);
+ }
+
+ [Test]
+ [ExpectedException(ExpectedMessage = "Smoke Test")]
+ public void CreateAndUnwrapInterface()
+ {
+ AppDomainSetup appSetup = new AppDomainSetup();
+ appSetup.ShadowCopyFiles = "true";
+ appSetup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;
+ appSetup.ActivationArguments = AppDomain.CurrentDomain.SetupInformation.ActivationArguments;
+ Type writer = typeof(ConsoleWriter);
+ AppDomain domain = AppDomain.CreateDomain("TestDomain", null, appSetup);
+ var instance = (IConsoleWriter)domain.CreateInstanceAndUnwrap(writer.Assembly.FullName, writer.FullName);
+ instance.WriteLine("Smoke Test");
+ AppDomain.Unload(domain);
+ }
+
+ [Test]
+ [ExpectedException(ExpectedMessage = "Smoke Test")]
+ public void CreateAndUnwrapProxy()
+ {
+ AppDomainSetup appSetup = new AppDomainSetup();
+ appSetup.ShadowCopyFiles = "true";
+ appSetup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;
+ appSetup.ActivationArguments = AppDomain.CurrentDomain.SetupInformation.ActivationArguments;
+ Type writer = typeof(ConsoleProxy);
+ AppDomain domain = AppDomain.CreateDomain("TestDomain", null, appSetup);
+ var instance = (ConsoleProxy)domain.CreateInstanceAndUnwrap(writer.Assembly.FullName, writer.FullName);
+ instance.writer.WriteLine("Smoke Test");
+ AppDomain.Unload(domain);
+ }
+
+
+ [Test]
+ [ExpectedException(ExpectedMessage = "Smoke Test")]
+ public void CreateAndUnwrapProxyInterface()
+ {
+ AppDomainSetup appSetup = new AppDomainSetup();
+ appSetup.ShadowCopyFiles = "true";
+ appSetup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;
+ appSetup.ActivationArguments = AppDomain.CurrentDomain.SetupInformation.ActivationArguments;
+ Type writer = typeof(ConsoleProxy);
+ AppDomain domain = AppDomain.CreateDomain("TestDomain", null, appSetup);
+ var instance = (IConsoleProxy)domain.CreateInstanceAndUnwrap(writer.Assembly.FullName, writer.FullName);
+ instance.writer.WriteLine("Smoke Test");
+ AppDomain.Unload(domain);
+ }
+
+ [Test]
+ [ExpectedException(ExpectedMessage = "Smoke Test")]
+ public void CreateAndUnwrapProxyInterfaceWithLocalWriter()
+ {
+ AppDomainSetup appSetup = new AppDomainSetup();
+ appSetup.ShadowCopyFiles = "true";
+ appSetup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;
+ appSetup.ActivationArguments = AppDomain.CurrentDomain.SetupInformation.ActivationArguments;
+ Type writer = typeof(ConsoleProxy);
+ AppDomain domain = AppDomain.CreateDomain("TestDomain", null, appSetup);
+ var instance = (IConsoleProxy)domain.CreateInstanceAndUnwrap(writer.Assembly.FullName, writer.FullName);
+ instance.writer = new ConsoleWriter();
+ instance.writer.WriteLine("Smoke Test");
+ AppDomain.Unload(domain);
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/CoreDelegatesTests.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/CoreDelegatesTests.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/CoreDelegatesTests.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+
+namespace FreeSWITCH.Managed.Tests
+{
+ [TestFixture]
+ public class CoreDelegatesTests
+ {
+ [Test]
+ public void InitializeCoreDelegatesMethodExists()
+ {
+ // This is a "compilation test". It is necessary that this method and class exist.
+ // It is hard to test pass the pinvoke boundary.
+ try
+ {
+ CoreDelegates.InitializeCoreDelegates();
+ }
+ catch (DllNotFoundException)
+ {
+ }
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/DefaultLoaderTests.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/DefaultLoaderTests.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/DefaultLoaderTests.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+
+namespace FreeSWITCH.Managed.Tests
+{
+ [TestFixture]
+ public class DefaultLoaderTests
+ {
+ [SetUp]
+ public void Setup()
+ {
+ CoreDelegates.Run = null;
+ CoreDelegates.Execute = null;
+ CoreDelegates.ExecuteBackground = null;
+ CoreDelegates.Reload = null;
+ }
+
+ [Test]
+ public void SingletonFactory()
+ {
+ var firstLoader = DefaultLoader.Loader;
+ var secondLoader = DefaultLoader.Loader;
+ Assert.AreEqual(firstLoader, secondLoader);
+ }
+
+ [Test]
+ public void Load_Empty_ReturnsTrue()
+ {
+ Assert.IsTrue(DefaultLoader.Loader.Load());
+ }
+
+ [Test]
+ public void Load_Empty_SetsRunDelegateToRunCommand()
+ {
+ DefaultLoader.Loader.Load();
+ Assert.IsNotNull(CoreDelegates.Run);
+ }
+
+ [Test]
+ public void Load_Empty_SetsRunDelegateToExecuteCommand()
+ {
+ DefaultLoader.Loader.Load();
+ Assert.IsNotNull(CoreDelegates.Execute);
+ }
+
+ [Test]
+ public void Load_Empty_SetsRunDelegateToExecuteBackgroundCommand()
+ {
+ DefaultLoader.Loader.Load();
+ Assert.IsNotNull(CoreDelegates.ExecuteBackground);
+ }
+
+ [Test]
+ public void Load_Empty_SetsRunDelegateToReloadCommand()
+ {
+ DefaultLoader.Loader.Load();
+ Assert.IsNotNull(CoreDelegates.Reload);
+ }
+
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Directors/ExecuteBackgroundCommandDirectorTests.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Directors/ExecuteBackgroundCommandDirectorTests.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Directors/ExecuteBackgroundCommandDirectorTests.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using Moq;
+
+namespace FreeSWITCH.Managed.Tests.Directors
+{
+ [TestFixture]
+ public class ExecuteBackgroundCommandDirectorTests
+ {
+ [Test]
+ public void ClassContainsCommandsCollection()
+ {
+ var logdirector = new Mock<ILogger>();
+ var objectUnderTest = new ExecuteBackgroundCommandOnCollection(logdirector.Object);
+ Assert.IsNotNull(objectUnderTest.Commands);
+ }
+
+ [Test]
+ public void ExecuteBackground_Empty_ReturnsTrue()
+ {
+ var logdirector = new Mock<ILogger>();
+ var objectUnderTest = new ExecuteBackgroundCommandOnCollection(logdirector.Object);
+ Assert.IsTrue(objectUnderTest.ExecuteBackground(string.Empty));
+ }
+
+ [Test]
+ public void ExecuteBackground_FalseReturningCommand_ReturnsFalse()
+ {
+ var logdirector = new Mock<ILogger>();
+ var runcommand = new Mock<IExecuteBackgroundCommand>();
+ runcommand.Setup(foo => foo.ExecuteBackground(string.Empty)).Returns(false);
+
+ var objectUnderTest = new ExecuteBackgroundCommandOnCollection(logdirector.Object);
+ objectUnderTest.Commands.Add(runcommand.Object);
+
+ Assert.IsFalse(objectUnderTest.ExecuteBackground(string.Empty));
+ }
+
+ [Test]
+ public void ExecuteBackground_ExceptionThrowingCommand_ReturnsFalse()
+ {
+ var logdirector = new Mock<ILogger>();
+ var runcommand = new Mock<IExecuteBackgroundCommand>();
+ runcommand.Setup(foo => foo.ExecuteBackground(string.Empty)).Throws(new Exception("Test Exception"));
+
+ var objectUnderTest = new ExecuteBackgroundCommandOnCollection(logdirector.Object);
+ objectUnderTest.Commands.Add(runcommand.Object);
+
+ Assert.IsFalse(objectUnderTest.ExecuteBackground(string.Empty));
+ }
+
+ [Test]
+ public void ExecuteBackground_ExceptionThrowingCommand_LogsError()
+ {
+ var logdirector = new Mock<ILogger>();
+ logdirector.Setup(foo => foo.Error(It.IsRegex("Exception in ExecuteBackground")));
+ var runcommand = new Mock<IExecuteBackgroundCommand>();
+ runcommand.Setup(foo => foo.ExecuteBackground(string.Empty)).Throws(new Exception("Test Exception"));
+
+ var objectUnderTest = new ExecuteBackgroundCommandOnCollection(logdirector.Object);
+ objectUnderTest.Commands.Add(runcommand.Object);
+ objectUnderTest.ExecuteBackground(string.Empty);
+
+ logdirector.VerifyAll();
+ }
+
+ [Test]
+ public void ExecuteBackground_MultipleCommands_RunsAll()
+ {
+ var logdirector = new Mock<ILogger>();
+ var runcommand1 = new Mock<IExecuteBackgroundCommand>();
+ runcommand1.Setup(foo => foo.ExecuteBackground(string.Empty)).Returns(true);
+ var runcommand2 = new Mock<IExecuteBackgroundCommand>();
+ runcommand2.Setup(foo => foo.ExecuteBackground(string.Empty)).Returns(true);
+
+ var objectUnderTest = new ExecuteBackgroundCommandOnCollection(logdirector.Object);
+ objectUnderTest.Commands.Add(runcommand1.Object);
+ objectUnderTest.Commands.Add(runcommand2.Object);
+ objectUnderTest.ExecuteBackground(string.Empty);
+
+ runcommand1.VerifyAll();
+ runcommand2.VerifyAll();
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Directors/ExecuteCommandDirectorTests.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Directors/ExecuteCommandDirectorTests.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Directors/ExecuteCommandDirectorTests.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using Moq;
+
+namespace FreeSWITCH.Managed.Tests.Directors
+{
+ [TestFixture]
+ public class ExecuteCommandDirectorTests
+ {
+ [Test]
+ public void ClassContainsCommandsCollection()
+ {
+ var logdirector = new Mock<ILogger>();
+ var objectUnderTest = new ExecuteCommandOnCollection(logdirector.Object);
+ Assert.IsNotNull(objectUnderTest.Commands);
+ }
+
+ [Test]
+ public void Execute_Empty_ReturnsTrue()
+ {
+ var logdirector = new Mock<ILogger>();
+ var objectUnderTest = new ExecuteCommandOnCollection(logdirector.Object);
+ Assert.IsTrue(objectUnderTest.Execute(string.Empty, IntPtr.Zero, IntPtr.Zero));
+ }
+
+ [Test]
+ public void Execute_FalseReturningCommand_ReturnsFalse()
+ {
+ var logdirector = new Mock<ILogger>();
+ var executecommand = new Mock<IExecuteCommand>();
+ executecommand.Setup(foo => foo.Execute(string.Empty, IntPtr.Zero, IntPtr.Zero)).Returns(false);
+
+ var objectUnderTest = new ExecuteCommandOnCollection(logdirector.Object);
+ objectUnderTest.Commands.Add(executecommand.Object);
+
+ Assert.IsFalse(objectUnderTest.Execute(string.Empty, IntPtr.Zero, IntPtr.Zero));
+ }
+
+ [Test]
+ public void Execute_ExceptionThrowingCommand_ReturnsFalse()
+ {
+ var logdirector = new Mock<ILogger>();
+ var executecommand = new Mock<IExecuteCommand>();
+ executecommand.Setup(foo => foo.Execute(string.Empty, IntPtr.Zero, IntPtr.Zero)).Throws(new Exception("Test Exception"));
+
+ var objectUnderTest = new ExecuteCommandOnCollection(logdirector.Object);
+ objectUnderTest.Commands.Add(executecommand.Object);
+
+ Assert.IsFalse(objectUnderTest.Execute(string.Empty, IntPtr.Zero, IntPtr.Zero));
+ }
+
+ [Test]
+ public void Execute_ExceptionThrowingCommand_LogsError()
+ {
+ var logdirector = new Mock<ILogger>();
+ logdirector.Setup(foo => foo.Error(It.IsRegex("Exception in Execute")));
+ var executecommand = new Mock<IExecuteCommand>();
+ executecommand.Setup(foo => foo.Execute(string.Empty, IntPtr.Zero, IntPtr.Zero)).Throws(new Exception("Test Exception"));
+
+ var objectUnderTest = new ExecuteCommandOnCollection(logdirector.Object);
+ objectUnderTest.Commands.Add(executecommand.Object);
+ objectUnderTest.Execute(string.Empty, IntPtr.Zero, IntPtr.Zero);
+
+ logdirector.VerifyAll();
+ }
+
+ [Test]
+ public void Execute_MultipleCommands_RunsAll()
+ {
+ var logdirector = new Mock<ILogger>();
+ var executecommand1 = new Mock<IExecuteCommand>();
+ executecommand1.Setup(foo => foo.Execute(string.Empty, IntPtr.Zero, IntPtr.Zero)).Returns(true);
+ var executecommand2 = new Mock<IExecuteCommand>();
+ executecommand2.Setup(foo => foo.Execute(string.Empty, IntPtr.Zero, IntPtr.Zero)).Returns(true);
+
+ var objectUnderTest = new ExecuteCommandOnCollection(logdirector.Object);
+ objectUnderTest.Commands.Add(executecommand1.Object);
+ objectUnderTest.Commands.Add(executecommand2.Object);
+
+ Assert.IsTrue(objectUnderTest.Execute(string.Empty, IntPtr.Zero, IntPtr.Zero));
+ executecommand1.VerifyAll();
+ executecommand2.VerifyAll();
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Directors/LogDirectorTests.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Directors/LogDirectorTests.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Directors/LogDirectorTests.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using Moq;
+
+namespace FreeSWITCH.Managed.Tests.Directors
+{
+ [TestFixture]
+ public class LogDirectorTests
+ {
+ [Test]
+ public void ClassContainsCommandsCollection()
+ {
+ var objectUnderTest = new LoggerContainer();
+ Assert.IsNotNull(objectUnderTest.Loggers);
+ }
+
+ [Test]
+ public void Debug_Message_CallsLogger()
+ {
+ var subLogger = new Mock<ILogger>();
+ subLogger.Setup(foo => foo.Debug("Test Message"));
+ var objectUnderTest = new LoggerContainer();
+ objectUnderTest.Loggers.Add(subLogger.Object);
+ objectUnderTest.Debug("Test Message");
+ subLogger.VerifyAll();
+ }
+
+ [Test]
+ public void Alert_Message_CallsLogger()
+ {
+ var subLogger = new Mock<ILogger>();
+ subLogger.Setup(foo => foo.Alert("Test Message"));
+ var objectUnderTest = new LoggerContainer();
+ objectUnderTest.Loggers.Add(subLogger.Object);
+ objectUnderTest.Alert("Test Message");
+ subLogger.VerifyAll();
+ }
+
+
+ [Test]
+ public void Critical_Message_CallsLogger()
+ {
+ var subLogger = new Mock<ILogger>();
+ subLogger.Setup(foo => foo.Critical("Test Message"));
+ var objectUnderTest = new LoggerContainer();
+ objectUnderTest.Loggers.Add(subLogger.Object);
+ objectUnderTest.Critical("Test Message");
+ subLogger.VerifyAll();
+ }
+
+
+ [Test]
+ public void Error_Message_CallsLogger()
+ {
+ var subLogger = new Mock<ILogger>();
+ subLogger.Setup(foo => foo.Error("Test Message"));
+ var objectUnderTest = new LoggerContainer();
+ objectUnderTest.Loggers.Add(subLogger.Object);
+ objectUnderTest.Error("Test Message");
+ subLogger.VerifyAll();
+ }
+
+
+ [Test]
+ public void Notice_Message_CallsLogger()
+ {
+ var subLogger = new Mock<ILogger>();
+ subLogger.Setup(foo => foo.Notice("Test Message"));
+ var objectUnderTest = new LoggerContainer();
+ objectUnderTest.Loggers.Add(subLogger.Object);
+ objectUnderTest.Notice("Test Message");
+ subLogger.VerifyAll();
+ }
+
+
+ [Test]
+ public void Warning_Message_CallsLogger()
+ {
+ var subLogger = new Mock<ILogger>();
+ subLogger.Setup(foo => foo.Warning("Test Message"));
+ var objectUnderTest = new LoggerContainer();
+ objectUnderTest.Loggers.Add(subLogger.Object);
+ objectUnderTest.Warning("Test Message");
+ subLogger.VerifyAll();
+ }
+
+ [Test]
+ public void Info_LoggerWithException_Continues()
+ {
+ var subLogger1 = new Mock<ILogger>();
+ subLogger1.Setup(foo => foo.Info("Test Message"));
+ var subLogger2 = new Mock<ILogger>();
+ subLogger2.Setup(foo => foo.Info("Test Message")).Throws(new Exception());
+ var subLogger3 = new Mock<ILogger>();
+ subLogger3.Setup(foo => foo.Info("Test Message"));
+ var objectUnderTest = new LoggerContainer();
+ objectUnderTest.Loggers.Add(subLogger1.Object);
+ objectUnderTest.Loggers.Add(subLogger2.Object);
+ objectUnderTest.Loggers.Add(subLogger3.Object);
+ objectUnderTest.Info("Test Message");
+ subLogger1.VerifyAll();
+ subLogger2.VerifyAll();
+ subLogger3.VerifyAll();
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Directors/ReloadCommandDirectorTests.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Directors/ReloadCommandDirectorTests.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Directors/ReloadCommandDirectorTests.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using Moq;
+
+namespace FreeSWITCH.Managed.Tests.Directors
+{
+ [TestFixture]
+ public class ReloadCommandDirectorTests
+ {
+ [Test]
+ public void ClassContainsCommandsCollection()
+ {
+ var logdirector = new Mock<ILogger>();
+ var objectUnderTest = new ReloadCommandOnCollection(logdirector.Object);
+ Assert.IsNotNull(objectUnderTest.Commands);
+ }
+
+ [Test]
+ public void Reload_Empty_ReturnsTrue()
+ {
+ var logdirector = new Mock<ILogger>();
+ var objectUnderTest = new ReloadCommandOnCollection(logdirector.Object);
+ Assert.IsTrue(objectUnderTest.Reload(string.Empty));
+ }
+
+ [Test]
+ public void Reload_FalseReturningCommand_ReturnsFalse()
+ {
+ var logdirector = new Mock<ILogger>();
+ var runcommand = new Mock<IReloadCommand>();
+ runcommand.Setup(foo => foo.Reload(string.Empty)).Returns(false);
+
+ var objectUnderTest = new ReloadCommandOnCollection(logdirector.Object);
+ objectUnderTest.Commands.Add(runcommand.Object);
+
+ Assert.IsFalse(objectUnderTest.Reload(string.Empty));
+ }
+
+ [Test]
+ public void Reload_ExceptionThrowingCommand_ReturnsFalse()
+ {
+ var logdirector = new Mock<ILogger>();
+ var runcommand = new Mock<IReloadCommand>();
+ runcommand.Setup(foo => foo.Reload(string.Empty)).Throws(new Exception("Test Exception"));
+
+ var objectUnderTest = new ReloadCommandOnCollection(logdirector.Object);
+ objectUnderTest.Commands.Add(runcommand.Object);
+
+ Assert.IsFalse(objectUnderTest.Reload(string.Empty));
+ }
+
+ [Test]
+ public void Reload_ExceptionThrowingCommand_LogsError()
+ {
+ var logdirector = new Mock<ILogger>();
+ logdirector.Setup(foo => foo.Error(It.IsRegex("Error reloading")));
+ var runcommand = new Mock<IReloadCommand>();
+ runcommand.Setup(foo => foo.Reload(string.Empty)).Throws(new Exception("Test Exception"));
+
+ var objectUnderTest = new ReloadCommandOnCollection(logdirector.Object);
+ objectUnderTest.Commands.Add(runcommand.Object);
+ objectUnderTest.Reload(string.Empty);
+
+ logdirector.VerifyAll();
+ }
+
+ [Test]
+ public void Reload_MultipleCommands_RunsAll()
+ {
+ var logdirector = new Mock<ILogger>();
+ var runcommand1 = new Mock<IReloadCommand>();
+ runcommand1.Setup(foo => foo.Reload(string.Empty)).Returns(true);
+ var runcommand2 = new Mock<IReloadCommand>();
+ runcommand2.Setup(foo => foo.Reload(string.Empty)).Returns(true);
+
+ var objectUnderTest = new ReloadCommandOnCollection(logdirector.Object);
+ objectUnderTest.Commands.Add(runcommand1.Object);
+ objectUnderTest.Commands.Add(runcommand2.Object);
+ objectUnderTest.Reload(string.Empty);
+
+ runcommand1.VerifyAll();
+ runcommand2.VerifyAll();
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Directors/RunCommandDirectorTests.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Directors/RunCommandDirectorTests.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Directors/RunCommandDirectorTests.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using Moq;
+
+namespace FreeSWITCH.Managed.Tests.Directors
+{
+ [TestFixture]
+ public class RunCommandDirectorTests
+ {
+ [Test]
+ public void ClassContainsCommandsCollection()
+ {
+ var logdirector = new Mock<ILogger>();
+ var objectUnderTest = new RunCommandOnCollection(logdirector.Object);
+ Assert.IsNotNull(objectUnderTest.Commands);
+ }
+
+ [Test]
+ public void Run_Empty_ReturnsTrue()
+ {
+ var logdirector = new Mock<ILogger>();
+ var objectUnderTest = new RunCommandOnCollection(logdirector.Object);
+ Assert.IsTrue(objectUnderTest.Run(string.Empty,IntPtr.Zero));
+ }
+
+ [Test]
+ public void Run_FalseReturningCommand_ReturnsFalse()
+ {
+ var logdirector = new Mock<ILogger>();
+ var runcommand = new Mock<IRunCommand>();
+ runcommand.Setup(foo => foo.Run(string.Empty, IntPtr.Zero)).Returns(false);
+
+ var objectUnderTest = new RunCommandOnCollection(logdirector.Object);
+ objectUnderTest.Commands.Add(runcommand.Object);
+
+ Assert.IsFalse(objectUnderTest.Run(string.Empty, IntPtr.Zero));
+ }
+
+ [Test]
+ public void Run_ExceptionThrowingCommand_ReturnsFalse()
+ {
+ var logdirector = new Mock<ILogger>();
+ var runcommand = new Mock<IRunCommand>();
+ runcommand.Setup(foo => foo.Run(string.Empty, IntPtr.Zero)).Throws(new Exception("Test Exception"));
+
+ var objectUnderTest = new RunCommandOnCollection(logdirector.Object);
+ objectUnderTest.Commands.Add(runcommand.Object);
+
+ Assert.IsFalse(objectUnderTest.Run(string.Empty, IntPtr.Zero));
+ }
+
+ [Test]
+ public void Run_ExceptionThrowingCommand_LogsError()
+ {
+ var logdirector = new Mock<ILogger>();
+ logdirector.Setup(foo => foo.Error(It.IsRegex("Exception in Run")));
+ var runcommand = new Mock<IRunCommand>();
+ runcommand.Setup(foo => foo.Run(string.Empty, IntPtr.Zero)).Throws(new Exception("Test Exception"));
+
+ var objectUnderTest = new RunCommandOnCollection(logdirector.Object);
+ objectUnderTest.Commands.Add(runcommand.Object);
+ objectUnderTest.Run(string.Empty, IntPtr.Zero);
+
+ logdirector.VerifyAll();
+ }
+
+ [Test]
+ public void Run_MultipleCommands_RunsAll()
+ {
+ var logdirector = new Mock<ILogger>();
+ var runcommand1 = new Mock<IRunCommand>();
+ runcommand1.Setup(foo => foo.Run(string.Empty, IntPtr.Zero)).Returns(true);
+ var runcommand2 = new Mock<IRunCommand>();
+ runcommand2.Setup(foo => foo.Run(string.Empty, IntPtr.Zero)).Returns(true);
+
+ var objectUnderTest = new RunCommandOnCollection(logdirector.Object);
+ objectUnderTest.Commands.Add(runcommand1.Object);
+ objectUnderTest.Commands.Add(runcommand2.Object);
+ objectUnderTest.Run(string.Empty, IntPtr.Zero);
+
+ runcommand1.VerifyAll();
+ runcommand2.VerifyAll();
+ }
+ }
+}
\ No newline at end of file
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/FreeSWITCH.Managed.Tests.csproj (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/FreeSWITCH.Managed.Tests.csproj (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/FreeSWITCH.Managed.Tests.csproj 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,92 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="3.5" 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>{CDB35510-9438-4C49-B278-2EDCEDAA3729}</ProjectGuid>
+ <OutputType>Library</OutputType>
+ <AppDesignerFolder>Properties</AppDesignerFolder>
+ <RootNamespace>FreeSWITCH.Managed.Tests</RootNamespace>
+ <AssemblyName>FreeSWITCH.Managed.Tests</AssemblyName>
+ <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+ <FileAlignment>512</FileAlignment>
+ </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>
+ </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>
+ </PropertyGroup>
+ <ItemGroup>
+ <Reference Include="Moq, Version=3.1.416.3, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
+ <SpecificVersion>False</SpecificVersion>
+ <HintPath>ThirdParty\moq\Moq.dll</HintPath>
+ </Reference>
+ <Reference Include="nunit.framework, Version=2.5.2.9222, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+ <SpecificVersion>False</SpecificVersion>
+ <HintPath>ThirdParty\nunit\nunit.framework.dll</HintPath>
+ </Reference>
+ <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="AppdomainTests\AppdomainExplorationTests.cs" />
+ <Compile Include="CoreDelegatesTests.cs" />
+ <Compile Include="DefaultLoaderTests.cs" />
+ <Compile Include="ModuleAppdomains\AssemblyCompilerTests.cs" />
+ <Compile Include="ModuleAppdomains\AssemblyComposers\ScriptAssemblyComposerTests.cs" />
+ <Compile Include="ModuleAppdomains\ModuleServiceLocatorTests.cs" />
+ <Compile Include="ModuleAppdomains\ModuleProxyTests.cs" />
+ <Compile Include="ModuleAppdomains\PluginHandlers\DefaultPluginHandlerTests.cs" />
+ <Compile Include="ModuleAppdomains\PluginHandlers\RunNotifyPluginHandlerTests.cs" />
+ <Compile Include="TestHelpers\DefaultServiceLocatorSetup.cs" />
+ <Compile Include="PrimaryAppdomain\DefaultServiceLocatorTests.cs" />
+ <Compile Include="Directors\ExecuteBackgroundCommandDirectorTests.cs" />
+ <Compile Include="Directors\ExecuteCommandDirectorTests.cs" />
+ <Compile Include="Directors\LogDirectorTests.cs" />
+ <Compile Include="Directors\ReloadCommandDirectorTests.cs" />
+ <Compile Include="Directors\RunCommandDirectorTests.cs" />
+ <Compile Include="LoaderTests.cs" />
+ <Compile Include="ModuleAppdomains\PluginTypes\DefaultPluginExecutorTests.cs" />
+ <Compile Include="Properties\AssemblyInfo.cs" />
+ <Compile Include="Types\ObjectContainerTests.cs" />
+ <Compile Include="TestHelpers\ModuleServiceLocatorSetup.cs" />
+ </ItemGroup>
+ <ItemGroup>
+ <ProjectReference Include="..\FreeSWITCH.Managed.csproj">
+ <Project>{834E2B2F-5483-4B80-8FE3-FE48FF76E5C0}</Project>
+ <Name>FreeSWITCH.Managed</Name>
+ </ProjectReference>
+ </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>
\ No newline at end of file
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/LoaderTests.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/LoaderTests.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/LoaderTests.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+
+namespace FreeSWITCH.Managed.Tests
+{
+ [TestFixture]
+ public class LoaderTests
+ {
+ [Test]
+ public void LoadMethodExists()
+ {
+ // This is a "compilation test". It is necessary that this method and class exist.
+ // It is hard to test pass the pinvoke boundary.
+ try
+ {
+ Loader.Load();
+ }
+ catch (DllNotFoundException)
+ {
+ }
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/AssemblyCompilerTests.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/AssemblyCompilerTests.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/AssemblyCompilerTests.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using Moq;
+using FreeSWITCH;
+
+namespace FreeSWITCH.Managed.Tests.ModuleAppdomains
+{
+ [TestFixture]
+ public class AssemblyCompilerTests
+ {
+ [Test]
+ public void Constructor_Requires_ILogger()
+ {
+ var logger = new Mock<ILogger>();
+ var objectUnderTest = new AssemblyCompiler(logger.Object);
+ Assert.IsNotNull(objectUnderTest);
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/AssemblyComposers/ScriptAssemblyComposerTests.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/AssemblyComposers/ScriptAssemblyComposerTests.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/AssemblyComposers/ScriptAssemblyComposerTests.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using Moq;
+
+namespace FreeSWITCH.Managed.Tests.ModuleAppdomains.AssemblyComposers
+{
+ [TestFixture]
+ public class ScriptAssemblyComposerTests
+ {
+ [Test]
+ public void Constructor_Requires_IAssemblyCompiler()
+ {
+ var logger = new Mock<IAssemblyCompiler>();
+ var objectUnderTest = new ScriptAssemblyComposer(logger.Object);
+ Assert.IsNotNull(objectUnderTest);
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/ModuleProxyTests.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/ModuleProxyTests.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/ModuleProxyTests.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+
+namespace FreeSWITCH.Managed.Tests.ModuleAppdomains
+{
+ [TestFixture]
+ public class ModuleProxyTests
+ {
+ [SetUp]
+ public void Setup()
+ {
+ TestHelpers.ModuleServiceLocatorSetup.ContainerReset();
+ }
+
+ [TearDown]
+ public void TearDown()
+ {
+ TestHelpers.ModuleServiceLocatorSetup.ContainerReset();
+ }
+
+ [Test]
+ public void ClassHasDefaultConstructor()
+ {
+ var createdObject = new ModuleProxy();
+ Assert.IsInstanceOf<ModuleProxy>(createdObject);
+ }
+
+ [Test]
+ public void Logger_Get_ReturnsLoggerFromContainer()
+ {
+ var createdObject = new ModuleProxy();
+ var logger = ModuleServiceLocator.Container.Create<ILogger>();
+ Assert.AreSame(createdObject.Logger, logger);
+ }
+
+ [Test]
+ public void Logger_Get_ReturnsLogDirectorFromContainer()
+ {
+ var createdObject = new ModuleProxy();
+ var logger = ModuleServiceLocator.Container.Create<LoggerContainer>();
+ Assert.AreSame(createdObject.LogDirector, logger);
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/ModuleServiceLocatorTests.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/ModuleServiceLocatorTests.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/ModuleServiceLocatorTests.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+
+namespace FreeSWITCH.Managed.Tests.ModuleAppdomains
+{
+ [TestFixture]
+ public class ModuleServiceLocatorTests
+ {
+ [SetUp]
+ public void Setup()
+ {
+ TestHelpers.ModuleServiceLocatorSetup.ContainerReset();
+ }
+ [TearDown]
+ public void TearDown()
+ {
+ TestHelpers.ModuleServiceLocatorSetup.ContainerReset();
+ }
+
+ private void ConfirmSingletonDeclaration<T>()
+ {
+ var createdObject1 = ModuleServiceLocator.Container.Create<T>();
+ var createdObject2 = ModuleServiceLocator.Container.Create<T>();
+ Assert.IsInstanceOf<T>(createdObject1);
+ Assert.AreSame(createdObject1, createdObject2);
+ }
+
+ [Test]
+ public void LocatorResolvesIDirectoryController()
+ {
+ var createdObject = ModuleServiceLocator.Container.Create<IAssemblyCompiler>();
+ Assert.IsInstanceOf<AssemblyCompiler>(createdObject);
+ }
+ [Test]
+ public void LocatorResolvesAssemblyComposerDictionary()
+ {
+ var createdObject = ModuleServiceLocator.Container.Create<AssemblyComposerDictionary>();
+ Assert.IsInstanceOf<AssemblyComposerDictionary>(createdObject);
+ Assert.IsInstanceOf<Func<IAssemblyComposer>>(createdObject[".dll"]);
+ Assert.IsInstanceOf<Func<IAssemblyComposer>>(createdObject[".exe"]);
+ Assert.IsInstanceOf<Func<IAssemblyComposer>>(createdObject[".fsx"]);
+ Assert.IsInstanceOf<Func<IAssemblyComposer>>(createdObject[".csx"]);
+ Assert.IsInstanceOf<Func<IAssemblyComposer>>(createdObject[".vbx"]);
+ Assert.IsInstanceOf<Func<IAssemblyComposer>>(createdObject[".jsx"]);
+ }
+
+ [Test]
+ public void LocatorResolvesILogger()
+ {
+ ConfirmSingletonDeclaration<ILogger>();
+ }
+
+ [Test]
+ public void LocatorResolvesLogDirector()
+ {
+ ConfirmSingletonDeclaration<LoggerContainer>();
+ }
+
+ [Test]
+ public void LocatorResolvesPluginHandlerOrchestrator()
+ {
+ var createdObject1 = ModuleServiceLocator.Container.Create<IPluginHandlerOrchestrator>();
+ var createdObject2 = ModuleServiceLocator.Container.Create<IPluginHandlerOrchestrator>();
+ Assert.IsInstanceOf<PluginHandlerOrchestrator>(createdObject1);
+ Assert.AreSame(createdObject1, createdObject2);
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/PluginHandlers/DefaultPluginHandlerTests.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/PluginHandlers/DefaultPluginHandlerTests.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/PluginHandlers/DefaultPluginHandlerTests.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using Moq;
+
+namespace FreeSWITCH.Managed.Tests.ModuleAppdomains.PluginHandlers
+{
+ [TestFixture]
+ public class DefaultPluginHandlerTests
+ {
+ [Test]
+ public void ConstructorRequiresILogger()
+ {
+ var logger = new Mock<ILogger>();
+ var objectUnderTest = new DefaultPluginHandler(logger.Object);
+ Assert.IsNotNull(objectUnderTest);
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/PluginHandlers/RunNotifyPluginHandlerTests.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/PluginHandlers/RunNotifyPluginHandlerTests.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/PluginHandlers/RunNotifyPluginHandlerTests.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using Moq;
+
+namespace FreeSWITCH.Managed.Tests.ModuleAppdomains.PluginHandlers
+{
+ [TestFixture]
+ public class RunNotifyPluginHandlerTests
+ {
+ [Test]
+ public void NoReload_Get_ReturnsFalse()
+ {
+ var createdObject = new RunNotifyPluginHandler();
+ Assert.IsFalse(createdObject.NoReload);
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/PluginTypes/DefaultPluginExecutorTests.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/PluginTypes/DefaultPluginExecutorTests.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ModuleAppdomains/PluginTypes/DefaultPluginExecutorTests.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using Moq;
+using FreeSWITCH;
+
+namespace FreeSWITCH.Managed.Tests.ModuleAppdomains.PluginTypes
+{
+ [TestFixture]
+ public class DefaultPluginExecutorTests
+ {
+ [SetUp]
+ public void Setup()
+ {
+ TestHelpers.ModuleServiceLocatorSetup.ContainerReset();
+ }
+ [TearDown]
+ public void TearDown()
+ {
+ TestHelpers.ModuleServiceLocatorSetup.ContainerReset();
+ }
+ private class TestPluginExecutorImplementation : DefaultPluginExecutor
+ {
+ public TestPluginExecutorImplementation(string name, List<string> aliases, PluginOptions pluginOptions)
+ : base(name, aliases, pluginOptions)
+ {
+ }
+ }
+ [Test]
+ public void Constructor_Requires_ILogger()
+ {
+ ModuleServiceLocator.Container.Reset();
+ var logger = new Mock<ILogger>();
+ bool called = false;
+ ModuleServiceLocator.Container.Register<ILogger>(c =>
+ {
+ called = true; return logger.Object;
+ });
+ var objectUnderTest = new TestPluginExecutorImplementation("Name", new List<string>{"One"}, new PluginOptions());
+ Assert.IsTrue(called);
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/PrimaryAppdomain/DefaultServiceLocatorTests.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/PrimaryAppdomain/DefaultServiceLocatorTests.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/PrimaryAppdomain/DefaultServiceLocatorTests.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,111 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+
+namespace FreeSWITCH.Managed.Tests.PrimaryAppdomain
+{
+ [TestFixture]
+ public class DefaultServiceLocatorTests
+ {
+ [SetUp]
+ public void Setup()
+ {
+ TestHelpers.DefaultServiceLocatorSetup.ContainerReset();
+ }
+ [TearDown]
+ public void TearDown()
+ {
+ TestHelpers.DefaultServiceLocatorSetup.ContainerReset();
+ }
+ [Test]
+ public void LocatorResolvesIDirectoryController()
+ {
+ var createdObject = DefaultServiceLocator.Container.Create<IDirectoryController>();
+ Assert.IsInstanceOf<DefaultDirectoryController>(createdObject);
+ }
+
+ [Test]
+ public void LocatorResolvesLogger()
+ {
+ var createdObject = DefaultServiceLocator.Container.Create<ILogger>();
+ var createdObject2 = DefaultServiceLocator.Container.Create<LoggerContainer>();
+ var createdObject3 = DefaultServiceLocator.Container.Create<ILoggerContainer>();
+ Assert.IsInstanceOf<LoggerContainer>(createdObject);
+ Assert.AreSame(createdObject, createdObject2);
+ Assert.AreSame(createdObject, createdObject3);
+ }
+
+ [Test]
+ public void LocatorResolvesIModuleLoader()
+ {
+ var createdObject = DefaultServiceLocator.Container.Create<IModuleLoader>();
+ Assert.IsInstanceOf<SelectiveModuleLoader>(createdObject);
+ }
+
+ [Test]
+ public void LocatorResolvesModuleProxyTypeDictionary()
+ {
+ var createdObject = DefaultServiceLocator.Container.Create<ModuleProxyTypeDictionary>();
+ Assert.IsInstanceOf<ModuleProxyTypeDictionary>(createdObject);
+ }
+
+ [Test]
+ public void LocatorResolvesIAppDomainFactory()
+ {
+ var createdObject = DefaultServiceLocator.Container.Create<IAppDomainFactory>();
+ Assert.IsInstanceOf<DefaultAppDomainFactory>(createdObject);
+ }
+
+ private void ConfirmSingletonDeclaration<T>()
+ {
+ var createdObject1 = DefaultServiceLocator.Container.Create<T>();
+ var createdObject2 = DefaultServiceLocator.Container.Create<T>();
+ Assert.IsInstanceOf<T>(createdObject1);
+ Assert.AreSame(createdObject1, createdObject2);
+ }
+
+ [Test]
+ public void LocatorResolvesRunCommandDirector()
+ {
+ ConfirmSingletonDeclaration<RunCommandOnCollection>();
+ }
+
+ [Test]
+ public void LocatorResolvesExecuteCommandDirector()
+ {
+ ConfirmSingletonDeclaration<ExecuteCommandOnCollection>();
+ }
+
+ [Test]
+ public void LocatorResolvesExecuteBackgroundCommandDirector()
+ {
+ ConfirmSingletonDeclaration<ExecuteBackgroundCommandOnCollection>();
+ }
+
+ [Test]
+ public void LocatorResolvesReloadCommandDirector()
+ {
+ ConfirmSingletonDeclaration<ReloadCommandOnCollection>();
+ }
+
+ [Test]
+ public void LocatorResolvesDefaultPluginDirectoryWatcher()
+ {
+ ConfirmSingletonDeclaration<DefaultModuleDirectorySupervisor>();
+ }
+
+ [Test]
+ public void LocatorResolvesModuleList()
+ {
+ ConfirmSingletonDeclaration<ModuleList>();
+ }
+
+ [Test]
+ public void LocatorResolvesAssemblyResolver()
+ {
+ ConfirmSingletonDeclaration<AssemblyResolver>();
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Properties/AssemblyInfo.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Properties/AssemblyInfo.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Properties/AssemblyInfo.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("FreeSWITCH.Managed.Tests")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("FreeSWITCH.Managed.Tests")]
+[assembly: AssemblyCopyright("Copyright © 2009")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components. If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("260c11c5-c392-4b7a-8727-68fc7a101b0e")]
+
+// Version information for an assembly consists of the following four values:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/TestHelpers/DefaultServiceLocatorSetup.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/TestHelpers/DefaultServiceLocatorSetup.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/TestHelpers/DefaultServiceLocatorSetup.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+
+namespace FreeSWITCH.Managed.Tests.TestHelpers
+{
+ public static class DefaultServiceLocatorSetup
+ {
+ public static void ContainerReset()
+ {
+ DefaultServiceLocator.Container.Reset();
+ DefaultRegistry registry = new DefaultRegistry();
+ registry.Register(DefaultServiceLocator.Container);
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/TestHelpers/ModuleServiceLocatorSetup.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/TestHelpers/ModuleServiceLocatorSetup.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/TestHelpers/ModuleServiceLocatorSetup.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+
+namespace FreeSWITCH.Managed.Tests.TestHelpers
+{
+ public static class ModuleServiceLocatorSetup
+ {
+ public static void ContainerReset()
+ {
+ ModuleServiceLocator.Container.Reset();
+ ModuleRegistry registry = new ModuleRegistry();
+ registry.Register(ModuleServiceLocator.Container);
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ThirdParty/moq/Moq.chm
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ThirdParty/moq/Moq.dll
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ThirdParty/moq/Moq.pdb
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ThirdParty/moq/Moq.xml (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ThirdParty/moq/Moq.xml (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ThirdParty/moq/Moq.xml 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,3467 @@
+<?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<string>()))
+ .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<string>(),
+ It.IsAny<string>()))
+ .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<string>(),
+ It.IsAny<string>(),
+ It.IsAny<int>()))
+ .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<string>(),
+ It.IsAny<string>(),
+ It.IsAny<int>(),
+ It.IsAny<bool>()))
+ .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<ICommand>();
+ 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<ICommand>();
+ 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<IContainer>();
+
+ mock.Setup(add => add.Add(It.IsAny<string>(), It.IsAny<object>()))
+ .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<IContainer>();
+ // 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 => add.Add(It.IsAny<string>(), It.IsAny<object>()))
+ .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 => 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 => 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<Order> 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<IRepository<Order>>();
+
+ mock.Setup(x => x.Save(Orders.Contains(order)))
+ .Throws<ArgumentException>();
+ </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<Order> 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<Order> Contains(Order order)
+ {
+ return null;
+ }
+
+ public static bool Contains(IEnumerable<Order> orders, Order order)
+ {
+ return orders.Contains(order);
+ }
+ }
+ </code>
+ And the concrete test using this matcher:
+ <code>
+ var order = new Order { ... };
+ var mock = new Mock<IRepository<Order>>();
+
+ mock.Setup(x => x.Save(Orders.Contains(order)))
+ .Throws<ArgumentException>();
+
+ // 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<string>()))
+ .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<string>(),
+ It.IsAny<string>()))
+ .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<string>(),
+ It.IsAny<string>(),
+ It.IsAny<int>()))
+ .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<string>(),
+ It.IsAny<string>(),
+ It.IsAny<int>(),
+ It.IsAny<bool>()))
+ .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 => 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 => x.Execute(""))
+ .Throws<ArgumentException>();
+ </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<string>()))
+ .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<string>(),
+ It.IsAny<string>()))
+ .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<string>(),
+ It.IsAny<string>(),
+ It.IsAny<int>()))
+ .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<string>(),
+ It.IsAny<string>(),
+ It.IsAny<int>(),
+ It.IsAny<bool>()))
+ .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<ICommand>();
+ mock.Setup(foo => 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 => x.Remove(It.IsAny<string>())).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 => x.Do(It.Is<int>(i => 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 => x.GetUser(It.Is<int>(i => i < 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 => x.HasInventory(
+ It.IsAny<string>(),
+ 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 => 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 => 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<HttpRequestBase> request = Mock.Get(context.Request);
+ mock.Setup(req => 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<IWarehouse>();
+ this.Setup(x => 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<IWarehouse>();
+ this.Setup(x => 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<IOrdersView>();
+ var mockedEvent = mockView.CreateEventHandler<OrderEventArgs>();
+
+ 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<OrderEventArgs>();
+ // 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<IOrdersView>();
+ 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<IFoo>();
+ var bar = factory.Create<IBar>();
+
+ // no need to call Verifiable() on the setup
+ // as we'll be validating all of them anyway.
+ foo.Setup(f => f.Do());
+ bar.Setup(b => 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<IFoo>();
+ var bar = factory.Create<IBar>();
+
+ // this setup will be verified when we verify the factory
+ foo.Setup(f => f.Do()).Verifiable();
+
+ // this setup will NOT be verified
+ foo.Setup(f => f.Calculate());
+
+ // this setup will be verified when we verify the factory
+ bar.Setup(b => 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<IFoo>(MockBehavior.Loose);
+ var bar = factory.Create<IBar>();
+
+ // 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<IFoo>();
+ // 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<MyBase>("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<IFoo>(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<MyBase>(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'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'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'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 => 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<T>..
+ </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 => x.{1}).Returns(value);
+ mock.SetupGet(x => x.{1}).Returns(value); //equivalent to previous one
+ mock.SetupSet(x => 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<{2}>(x => x.{1}).Returns(value);
+ mock.SetupGet(x => x.{1}).Returns(value); //equivalent to previous one
+ mock.SetupSet(x => 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<string>())
+ .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<string>())
+ .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<int>(i => 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<int>(i => i < 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<string>(),
+ 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<Order>.Create(
+ o => o.GrandTotal >= 5000,
+ /* a friendly expression to render on failures */
+ () => IsBigOrder());
+ }
+ </code>
+ This method can be used in any mock setup invocation:
+ <code>
+ mock.Setup(m => m.Submit(IsBigOrder()).Throws<UnauthorizedAccessException>();
+ </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<Order> Contains(Order order)
+ {
+ return Match<IEnumerable<Order>>.Create(orders => 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<IRepository<Order>>();
+
+ mock.Setup(x => x.Save(Orders.Contains(order)))
+ .Throws<ArgumentException>();
+ </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="Match{T}.Create(condition,renderExpression"]/*"/>
+ </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="Match{T}.Convert"]/*"/>
+ </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<IWarehouse>();
+
+ mock.Setup(x => 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<IWarehouse>();
+
+ // shows how to expect a value within a range
+ mock.Setup(x => x.HasInventory(
+ It.IsAny<string>(),
+ It.IsInRange(0, 100, Range.Inclusive)))
+ .Returns(false);
+
+ // shows how to throw for unexpected calls.
+ mock.Setup(x => x.Remove(
+ It.IsAny<string>(),
+ It.IsAny<int>()))
+ .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<IFormatProvider>();</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<MyProvider>(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<IFormatProvider>(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<MyProvider>(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<IProcessor>();
+ mock.Setup(x => 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 => 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 => 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 => 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 => 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<IHaveValue>();
+ mock.Stub(v => 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<IHaveValue>();
+ mock.SetupProperty(v => 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<IProcessor>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't call Execute with a "ping" string argument.
+ mock.Verify(proc => 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<IProcessor>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't call Execute with a "ping" string argument.
+ mock.Verify(proc => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't call HasInventory.
+ mock.Verify(warehouse => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't call HasInventory.
+ mock.Verify(warehouse => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't retrieve the IsClosed property.
+ mock.VerifyGet(warehouse => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't retrieve the IsClosed property.
+ mock.VerifyGet(warehouse => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't set the IsClosed property.
+ mock.VerifySet(warehouse => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't set the IsClosed property.
+ mock.VerifySet(warehouse => 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<IProcessor>();
+ mock.Setup(x => x.Execute("ping"));
+
+ // add IDisposable interface
+ var disposable = mock.As<IDisposable>();
+ disposable.Setup(d => 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<IViewModel>();
+
+ mock.Raise(x => 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<IOrdersView>();
+ 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 => 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<IViewModel>();
+
+ mock.Raise(x => 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 => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't set the IsClosed property.
+ mock.VerifySet(warehouse => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't set the IsClosed property.
+ mock.VerifySet(warehouse => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't set the IsClosed property.
+ mock.VerifySet(warehouse => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't set the IsClosed property.
+ mock.VerifySet(warehouse => 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>
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ThirdParty/nunit/nunit.framework.dll
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ThirdParty/nunit/nunit.framework.xml (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ThirdParty/nunit/nunit.framework.xml (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/ThirdParty/nunit/nunit.framework.xml 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,10088 @@
+<?xml version="1.0"?>
+<doc>
+ <assembly>
+ <name>nunit.framework</name>
+ </assembly>
+ <members>
+ <member name="T:NUnit.Framework.Constraints.TypeConstraint">
+ <summary>
+ TypeConstraint is the abstract base for constraints
+ that take a Type as their expected value.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.Constraint">
+ <summary>
+ The Constraint class is the base of all built-in constraints
+ within NUnit. It provides the operator overloads used to combine
+ constraints.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.IResolveConstraint">
+ <summary>
+ The IConstraintExpression interface is implemented by all
+ complete and resolvable constraints and expressions.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.IResolveConstraint.Resolve">
+ <summary>
+ Return the top-level constraint for this expression
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.Constraint.UNSET">
+ <summary>
+ Static UnsetObject used to detect derived constraints
+ failing to set the actual value.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.Constraint.actual">
+ <summary>
+ The actual value being tested against a constraint
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.Constraint.displayName">
+ <summary>
+ The display name of this Constraint for use by ToString()
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.Constraint.argcnt">
+ <summary>
+ Argument fields used by ToString();
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.Constraint.builder">
+ <summary>
+ The builder holding this constraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.#ctor">
+ <summary>
+ Construct a constraint with no arguments
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.#ctor(System.Object)">
+ <summary>
+ Construct a constraint with one argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.#ctor(System.Object,System.Object)">
+ <summary>
+ Construct a constraint with two arguments
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.SetBuilder(NUnit.Framework.Constraints.ConstraintBuilder)">
+ <summary>
+ Sets the ConstraintBuilder holding this constraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.WriteMessageTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the failure message to the MessageWriter provided
+ as an argument. The default implementation simply passes
+ the constraint and the actual value to the writer, which
+ then displays the constraint description and the value.
+
+ Constraints that need to provide additional details,
+ such as where the error occured can override this.
+ </summary>
+ <param name="writer">The MessageWriter on which to display the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.Matches(NUnit.Framework.Constraints.ActualValueDelegate)">
+ <summary>
+ Test whether the constraint is satisfied by an
+ ActualValueDelegate that returns the value to be tested.
+ The default implementation simply evaluates the delegate
+ but derived classes may override it to provide for delayed
+ processing.
+ </summary>
+ <param name="del">An ActualValueDelegate</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.Matches``1(``0@)">
+ <summary>
+ Test whether the constraint is satisfied by a given reference.
+ The default implementation simply dereferences the value but
+ derived classes may override it to provide for delayed processing.
+ </summary>
+ <param name="actual">A reference to the value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter. The default implementation simply writes
+ the raw value of actual, leaving it to the writer to
+ perform any formatting.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.ToString">
+ <summary>
+ Default override of ToString returns the constraint DisplayName
+ followed by any arguments within angle brackets.
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.op_BitwiseAnd(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ This operator creates a constraint that is satisfied only if both
+ argument constraints are satisfied.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.op_BitwiseOr(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ This operator creates a constraint that is satisfied if either
+ of the argument constraints is satisfied.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.op_LogicalNot(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ This operator creates a constraint that is satisfied if the
+ argument constraint is not satisfied.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.After(System.Int32)">
+ <summary>
+ Returns a DelayedConstraint with the specified delay time.
+ </summary>
+ <param name="delayInMilliseconds">The delay in milliseconds.</param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.After(System.Int32,System.Int32)">
+ <summary>
+ Returns a DelayedConstraint with the specified delay time
+ and polling interval.
+ </summary>
+ <param name="delayInMilliseconds">The delay in milliseconds.</param>
+ <param name="pollingInterval">The interval at which to test the constraint.</param>
+ <returns></returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Constraint.DisplayName">
+ <summary>
+ The display name of this Constraint for use by ToString().
+ The default value is the name of the constraint with
+ trailing "Constraint" removed. Derived classes may set
+ this to another name in their constructors.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Constraint.And">
+ <summary>
+ Returns a ConstraintExpression by appending And
+ to the current constraint.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Constraint.With">
+ <summary>
+ Returns a ConstraintExpression by appending And
+ to the current constraint.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Constraint.Or">
+ <summary>
+ Returns a ConstraintExpression by appending Or
+ to the current constraint.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.Constraint.UnsetObject">
+ <summary>
+ Class used to detect any derived constraints
+ that fail to set the actual value in their
+ Matches override.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.TypeConstraint.expectedType">
+ <summary>
+ The expected Type used by the constraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.TypeConstraint.#ctor(System.Type)">
+ <summary>
+ Construct a TypeConstraint for a given Type
+ </summary>
+ <param name="type"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.TypeConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter. TypeConstraints override this method to write
+ the name of the type.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ExactTypeConstraint">
+ <summary>
+ ExactTypeConstraint is used to test that an object
+ is of the exact type provided in the constructor
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ExactTypeConstraint.#ctor(System.Type)">
+ <summary>
+ Construct an ExactTypeConstraint for a given Type
+ </summary>
+ <param name="type">The expected Type.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ExactTypeConstraint.Matches(System.Object)">
+ <summary>
+ Test that an object is of the exact type specified
+ </summary>
+ <param name="actual">The actual value.</param>
+ <returns>True if the tested object is of the exact type provided, otherwise false.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ExactTypeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer">The MessageWriter to use</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.InstanceOfTypeConstraint">
+ <summary>
+ InstanceOfTypeConstraint is used to test that an object
+ is of the same type provided or derived from it.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.InstanceOfTypeConstraint.#ctor(System.Type)">
+ <summary>
+ Construct an InstanceOfTypeConstraint for the type provided
+ </summary>
+ <param name="type">The expected Type</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.InstanceOfTypeConstraint.Matches(System.Object)">
+ <summary>
+ Test whether an object is of the specified type or a derived type
+ </summary>
+ <param name="actual">The object to be tested</param>
+ <returns>True if the object is of the provided type or derives from it, otherwise false.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.InstanceOfTypeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer">The MessageWriter to use</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.AssignableFromConstraint">
+ <summary>
+ AssignableFromConstraint is used to test that an object
+ can be assigned from a given Type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AssignableFromConstraint.#ctor(System.Type)">
+ <summary>
+ Construct an AssignableFromConstraint for the type provided
+ </summary>
+ <param name="type"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AssignableFromConstraint.Matches(System.Object)">
+ <summary>
+ Test whether an object can be assigned from the specified type
+ </summary>
+ <param name="actual">The object to be tested</param>
+ <returns>True if the object can be assigned a value of the expected Type, otherwise false.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AssignableFromConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer">The MessageWriter to use</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.AssignableToConstraint">
+ <summary>
+ AssignableToConstraint is used to test that an object
+ can be assigned to a given Type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AssignableToConstraint.#ctor(System.Type)">
+ <summary>
+ Construct an AssignableToConstraint for the type provided
+ </summary>
+ <param name="type"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AssignableToConstraint.Matches(System.Object)">
+ <summary>
+ Test whether an object can be assigned to the specified type
+ </summary>
+ <param name="actual">The object to be tested</param>
+ <returns>True if the object can be assigned a value of the expected Type, otherwise false.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AssignableToConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer">The MessageWriter to use</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ConstraintBuilder">
+ <summary>
+ ConstraintBuilder maintains the stacks that are used in
+ processing a ConstraintExpression. An OperatorStack
+ is used to hold operators that are waiting for their
+ operands to be reognized. a ConstraintStack holds
+ input constraints as well as the results of each
+ operator applied.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.#ctor">
+ <summary>
+ Initializes a new instance of the <see cref="T:ConstraintBuilder"/> class.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.Append(NUnit.Framework.Constraints.ConstraintOperator)">
+ <summary>
+ Appends the specified operator to the expression by first
+ reducing the operator stack and then pushing the new
+ operator on the stack.
+ </summary>
+ <param name="op">The operator to push.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.Append(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Appends the specified constraint to the expresson by pushing
+ it on the constraint stack.
+ </summary>
+ <param name="constraint">The constraint to push.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.SetTopOperatorRightContext(System.Object)">
+ <summary>
+ Sets the top operator right context.
+ </summary>
+ <param name="rightContext">The right context.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ReduceOperatorStack(System.Int32)">
+ <summary>
+ Reduces the operator stack until the topmost item
+ precedence is greater than or equal to the target precedence.
+ </summary>
+ <param name="targetPrecedence">The target precedence.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.Resolve">
+ <summary>
+ Resolves this instance, returning a Constraint. If the builder
+ is not currently in a resolvable state, an exception is thrown.
+ </summary>
+ <returns>The resolved constraint</returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.IsResolvable">
+ <summary>
+ Gets a value indicating whether this instance is resolvable.
+ </summary>
+ <value>
+ <c>true</c> if this instance is resolvable; otherwise, <c>false</c>.
+ </value>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack">
+ <summary>
+ OperatorStack is a type-safe stack for holding ConstraintOperators
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">
+ <summary>
+ Initializes a new instance of the <see cref="T:OperatorStack"/> class.
+ </summary>
+ <param name="builder">The builder.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Push(NUnit.Framework.Constraints.ConstraintOperator)">
+ <summary>
+ Pushes the specified operator onto the stack.
+ </summary>
+ <param name="op">The op.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Pop">
+ <summary>
+ Pops the topmost operator from the stack.
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Empty">
+ <summary>
+ Gets a value indicating whether this <see cref="T:OpStack"/> is empty.
+ </summary>
+ <value><c>true</c> if empty; otherwise, <c>false</c>.</value>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Top">
+ <summary>
+ Gets the topmost operator without modifying the stack.
+ </summary>
+ <value>The top.</value>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack">
+ <summary>
+ ConstraintStack is a type-safe stack for holding Constraints
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">
+ <summary>
+ Initializes a new instance of the <see cref="T:ConstraintStack"/> class.
+ </summary>
+ <param name="builder">The builder.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Push(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Pushes the specified constraint. As a side effect,
+ the constraint's builder field is set to the
+ ConstraintBuilder owning this stack.
+ </summary>
+ <param name="constraint">The constraint.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Pop">
+ <summary>
+ Pops this topmost constrait from the stack.
+ As a side effect, the constraint's builder
+ field is set to null.
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Empty">
+ <summary>
+ Gets a value indicating whether this <see cref="T:ConstraintStack"/> is empty.
+ </summary>
+ <value><c>true</c> if empty; otherwise, <c>false</c>.</value>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Top">
+ <summary>
+ Gets the topmost constraint without modifying the stack.
+ </summary>
+ <value>The topmost constraint</value>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ThrowsConstraint">
+ <summary>
+ ThrowsConstraint is used to test the exception thrown by
+ a delegate by applying a constraint to it.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.PrefixConstraint">
+ <summary>
+ Abstract base class used for prefixes
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.PrefixConstraint.baseConstraint">
+ <summary>
+ The base constraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PrefixConstraint.#ctor(NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Construct given a base constraint
+ </summary>
+ <param name="resolvable"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Initializes a new instance of the <see cref="T:ThrowsConstraint"/> class,
+ using a constraint to be applied to the exception.
+ </summary>
+ <param name="baseConstraint">A constraint to apply to the caught exception.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.Matches(System.Object)">
+ <summary>
+ Executes the code of the delegate and captures any exception.
+ If a non-null base constraint was provided, it applies that
+ constraint to the exception.
+ </summary>
+ <param name="actual">A delegate representing the code to be tested</param>
+ <returns>True if an exception is thrown and the constraint succeeds, otherwise false</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.Matches(NUnit.Framework.Constraints.ActualValueDelegate)">
+ <summary>
+ Converts an ActualValueDelegate to a TestDelegate
+ before calling the primary overload.
+ </summary>
+ <param name="del"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter. The default implementation simply writes
+ the raw value of actual, leaving it to the writer to
+ perform any formatting.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.ToString">
+ <summary>
+ Returns the string representation of this constraint
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ThrowsConstraint.ActualException">
+ <summary>
+ Get the actual exception thrown - used by Assert.Throws.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ThrowsNothingConstraint">
+ <summary>
+ ThrowsNothingConstraint tests that a delegate does not
+ throw an exception.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True if no exception is thrown, otherwise false</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter. The default implementation simply writes
+ the raw value of actual, leaving it to the writer to
+ perform any formatting.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.CollectionConstraint">
+ <summary>
+ CollectionConstraint is the abstract base class for
+ constraints that operate on collections.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionConstraint.#ctor">
+ <summary>
+ Construct an empty CollectionConstraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionConstraint.#ctor(System.Object)">
+ <summary>
+ Construct a CollectionConstraint
+ </summary>
+ <param name="arg"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionConstraint.IsEmpty(System.Collections.IEnumerable)">
+ <summary>
+ Determines whether the specified enumerable is empty.
+ </summary>
+ <param name="enumerable">The enumerable.</param>
+ <returns>
+ <c>true</c> if the specified enumerable is empty; otherwise, <c>false</c>.
+ </returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionConstraint.doMatch(System.Collections.IEnumerable)">
+ <summary>
+ Protected method to be implemented by derived classes
+ </summary>
+ <param name="collection"></param>
+ <returns></returns>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.CollectionItemsEqualConstraint">
+ <summary>
+ CollectionItemsEqualConstraint is the abstract base class for all
+ collection constraints that apply some notion of item equality
+ as a part of their operation.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.#ctor">
+ <summary>
+ Construct an empty CollectionConstraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.#ctor(System.Object)">
+ <summary>
+ Construct a CollectionConstraint
+ </summary>
+ <param name="arg"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using(System.Collections.IComparer)">
+ <summary>
+ Flag the constraint to use the supplied IComparer object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
+ <summary>
+ Flag the constraint to use the supplied IComparer object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using``1(System.Comparison{``0})">
+ <summary>
+ Flag the constraint to use the supplied Comparison object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using(System.Collections.IEqualityComparer)">
+ <summary>
+ Flag the constraint to use the supplied IEqualityComparer object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using``1(System.Collections.Generic.IEqualityComparer{``0})">
+ <summary>
+ Flag the constraint to use the supplied IEqualityComparer object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.ItemsEqual(System.Object,System.Object)">
+ <summary>
+ Compares two collection members for equality
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Tally(System.Collections.IEnumerable)">
+ <summary>
+ Return a new CollectionTally for use in making tests
+ </summary>
+ <param name="c">The collection to be included in the tally</param>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.IgnoreCase">
+ <summary>
+ Flag the constraint to ignore case and return self.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.CollectionTally">
+ <summary>
+ CollectionTally counts (tallies) the number of
+ occurences of each object in one or more enumerations.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.CollectionTally.#ctor(NUnit.Framework.Constraints.NUnitEqualityComparer,System.Collections.IEnumerable)">
+ <summary>
+ Construct a CollectionTally object from a comparer and a collection
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.CollectionTally.TryRemove(System.Object)">
+ <summary>
+ Try to remove an object from the tally
+ </summary>
+ <param name="o">The object to remove</param>
+ <returns>True if successful, false if the object was not found</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.CollectionTally.TryRemove(System.Collections.IEnumerable)">
+ <summary>
+ Try to remove a set of objects from the tally
+ </summary>
+ <param name="c">The objects to remove</param>
+ <returns>True if successful, false if any object was not found</returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.CollectionTally.Count">
+ <summary>
+ The number of objects remaining in the tally
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.EmptyCollectionConstraint">
+ <summary>
+ EmptyCollectionConstraint tests whether a collection is empty.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EmptyCollectionConstraint.doMatch(System.Collections.IEnumerable)">
+ <summary>
+ Check that the collection is empty
+ </summary>
+ <param name="collection"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EmptyCollectionConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.UniqueItemsConstraint">
+ <summary>
+ UniqueItemsConstraint tests whether all the items in a
+ collection are unique.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.UniqueItemsConstraint.doMatch(System.Collections.IEnumerable)">
+ <summary>
+ Check that all items are unique.
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.UniqueItemsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.CollectionContainsConstraint">
+ <summary>
+ CollectionContainsConstraint is used to test whether a collection
+ contains an expected object as a member.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionContainsConstraint.#ctor(System.Object)">
+ <summary>
+ Construct a CollectionContainsConstraint
+ </summary>
+ <param name="expected"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionContainsConstraint.doMatch(System.Collections.IEnumerable)">
+ <summary>
+ Test whether the expected item is contained in the collection
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionContainsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a descripton of the constraint to a MessageWriter
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.CollectionEquivalentConstraint">
+ <summary>
+ CollectionEquivalentCOnstraint is used to determine whether two
+ collections are equivalent.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionEquivalentConstraint.#ctor(System.Collections.IEnumerable)">
+ <summary>
+ Construct a CollectionEquivalentConstraint
+ </summary>
+ <param name="expected"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionEquivalentConstraint.doMatch(System.Collections.IEnumerable)">
+ <summary>
+ Test whether two collections are equivalent
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionEquivalentConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.CollectionSubsetConstraint">
+ <summary>
+ CollectionSubsetConstraint is used to determine whether
+ one collection is a subset of another
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionSubsetConstraint.#ctor(System.Collections.IEnumerable)">
+ <summary>
+ Construct a CollectionSubsetConstraint
+ </summary>
+ <param name="expected">The collection that the actual value is expected to be a subset of</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionSubsetConstraint.doMatch(System.Collections.IEnumerable)">
+ <summary>
+ Test whether the actual collection is a subset of
+ the expected collection provided.
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionSubsetConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.CollectionOrderedConstraint">
+ <summary>
+ CollectionOrderedConstraint is used to test whether a collection is ordered.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.#ctor">
+ <summary>
+ Construct a CollectionOrderedConstraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.Using(System.Collections.IComparer)">
+ <summary>
+ Modifies the constraint to use an IComparer and returns self.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
+ <summary>
+ Modifies the constraint to use an IComparer<T> and returns self.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.Using``1(System.Comparison{``0})">
+ <summary>
+ Modifies the constraint to use a Comparison<T> and returns self.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.By(System.String)">
+ <summary>
+ Modifies the constraint to test ordering by the value of
+ a specified property and returns self.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.doMatch(System.Collections.IEnumerable)">
+ <summary>
+ Test whether the collection is ordered
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of the constraint to a MessageWriter
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.ToString">
+ <summary>
+ Returns the string representation of the constraint.
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.CollectionOrderedConstraint.Descending">
+ <summary>
+ If used performs a reverse comparison
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.EmptyDirectoryContraint">
+ <summary>
+ EmptyDirectoryConstraint is used to test that a directory is empty
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EmptyDirectoryContraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EmptyDirectoryContraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EmptyDirectoryContraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter. The default implementation simply writes
+ the raw value of actual, leaving it to the writer to
+ perform any formatting.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.SubDirectoryConstraint">
+ <summary>
+ SubDirectoryConstraint is used to test that one directory is a subdirectory of another.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SubDirectoryConstraint.#ctor(System.IO.DirectoryInfo)">
+ <summary>
+ Initializes a new instance of the <see cref="T:SubDirectoryConstraint"/> class.
+ </summary>
+ <param name="dirInfo">The dir info.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SubDirectoryConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SubDirectoryConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SubDirectoryConstraint.BuildDirectoryList(System.IO.DirectoryInfo)">
+ <summary>
+ Builds a list of DirectoryInfo objects, recursing where necessary
+ </summary>
+ <param name="StartingDirectory">directory to recurse</param>
+ <returns>list of DirectoryInfo objects from the top level</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SubDirectoryConstraint.IsDirectoryOnPath(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
+ <summary>
+ private method to determine whether a directory is within the path
+ </summary>
+ <param name="ParentDirectory">top-level directory to search</param>
+ <param name="SearchDirectory">directory to search for</param>
+ <returns>true if found, false if not</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SubDirectoryConstraint.DirectoriesEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
+ <summary>
+ Method to compare two DirectoryInfo objects
+ </summary>
+ <param name="expected">first directory to compare</param>
+ <param name="actual">second directory to compare</param>
+ <returns>true if equivalent, false if not</returns>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.PathConstraint">
+ <summary>
+ PathConstraint serves as the abstract base of constraints
+ that operate on paths and provides several helper methods.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.PathConstraint.expected">
+ <summary>
+ The expected path used in the constraint
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.PathConstraint.caseInsensitive">
+ <summary>
+ Flag indicating whether a caseInsensitive comparison should be made
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PathConstraint.#ctor(System.String)">
+ <summary>
+ Construct a PathConstraint for a give expected path
+ </summary>
+ <param name="expected">The expected path</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PathConstraint.ToString">
+ <summary>
+ Returns the string representation of this constraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PathConstraint.Canonicalize(System.String)">
+ <summary>
+ Canonicalize the provided path
+ </summary>
+ <param name="path"></param>
+ <returns>The path in standardized form</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PathConstraint.IsSamePath(System.String,System.String)">
+ <summary>
+ Test whether two paths are the same
+ </summary>
+ <param name="path1">The first path</param>
+ <param name="path2">The second path</param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PathConstraint.IsSamePathOrUnder(System.String,System.String)">
+ <summary>
+ Test whether one path is the same as or under another path
+ </summary>
+ <param name="path1">The first path - supposed to be the parent path</param>
+ <param name="path2">The second path - supposed to be the child path</param>
+ <returns></returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.PathConstraint.IgnoreCase">
+ <summary>
+ Modifies the current instance to be case-insensitve
+ and returns it.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.PathConstraint.RespectCase">
+ <summary>
+ Modifies the current instance to be case-sensitve
+ and returns it.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.SamePathConstraint">
+ <summary>
+ Summary description for SamePathConstraint.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SamePathConstraint.#ctor(System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:SamePathConstraint"/> class.
+ </summary>
+ <param name="expected">The expected path</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SamePathConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SamePathConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.SamePathOrUnderConstraint">
+ <summary>
+ SamePathOrUnderConstraint tests that one path is under another
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SamePathOrUnderConstraint.#ctor(System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:SamePathOrUnderConstraint"/> class.
+ </summary>
+ <param name="expected">The expected path</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SamePathOrUnderConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SamePathOrUnderConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.PropertyExistsConstraint">
+ <summary>
+ PropertyExistsConstraint tests that a named property
+ exists on the object provided through Match.
+
+ Originally, PropertyConstraint provided this feature
+ in addition to making optional tests on the vaue
+ of the property. The two constraints are now separate.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.#ctor(System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:PropertyExistConstraint"/> class.
+ </summary>
+ <param name="name">The name of the property.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the property exists for a given object
+ </summary>
+ <param name="actual">The object to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.ToString">
+ <summary>
+ Returns the string representation of the constraint.
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.PropertyConstraint">
+ <summary>
+ PropertyConstraint extracts a named property and uses
+ its value as the actual value for a chained constraint.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyConstraint.#ctor(System.String,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Initializes a new instance of the <see cref="T:PropertyConstraint"/> class.
+ </summary>
+ <param name="name">The name.</param>
+ <param name="baseConstraint">The constraint to apply to the property.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter. The default implementation simply writes
+ the raw value of actual, leaving it to the writer to
+ perform any formatting.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyConstraint.ToString">
+ <summary>
+ Returns the string representation of the constraint.
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ConstraintExpression">
+ <summary>
+ ConstraintExpression represents a compound constraint in the
+ process of being constructed from a series of syntactic elements.
+
+ Individual elements are appended to the expression as they are
+ reognized. Once an actual Constraint is appended, the expression
+ returns a resolvable Constraint.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ConstraintExpressionBase">
+ <summary>
+ ConstraintExpressionBase is the abstract base class for the
+ generated ConstraintExpression class, which represents a
+ compound constraint in the process of being constructed
+ from a series of syntactic elements.
+
+ NOTE: ConstraintExpressionBase is aware of some of its
+ derived classes, which is an apparent violation of
+ encapsulation. Ideally, these classes would be a
+ single class, but they must be separated in order to
+ allow parts to be generated under .NET 1.x and to
+ provide proper user feedback in syntactically
+ aware IDEs.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ConstraintExpressionBase.builder">
+ <summary>
+ The ConstraintBuilder holding the elements recognized so far
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.#ctor">
+ <summary>
+ Initializes a new instance of the <see cref="T:ConstraintExpressionBase"/> class.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">
+ <summary>
+ Initializes a new instance of the <see cref="T:ConstraintExpressionBase"/>
+ class passing in a ConstraintBuilder, which may be pre-populated.
+ </summary>
+ <param name="builder">The builder.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.ToString">
+ <summary>
+ Returns a string representation of the expression as it
+ currently stands. This should only be used for testing,
+ since it has the side-effect of resolving the expression.
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.Append(NUnit.Framework.Constraints.ConstraintOperator)">
+ <summary>
+ Appends an operator to the expression and returns the
+ resulting expression itself.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.Append(NUnit.Framework.Constraints.SelfResolvingOperator)">
+ <summary>
+ Appends a self-resolving operator to the expression and
+ returns a new ResolvableConstraintExpression.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.Append(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Appends a constraint to the expression and returns that
+ constraint, which is associated with the current state
+ of the expression being built.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.#ctor">
+ <summary>
+ Initializes a new instance of the <see cref="T:ConstraintExpression"/> class.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">
+ <summary>
+ Initializes a new instance of the <see cref="T:ConstraintExpression"/>
+ class passing in a ConstraintBuilder, which may be pre-populated.
+ </summary>
+ <param name="builder">The builder.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Property(System.String)">
+ <summary>
+ Returns a new PropertyConstraintExpression, which will either
+ test for the existence of the named property on the object
+ being tested or apply any following constraint to that property.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Attribute(System.Type)">
+ <summary>
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Attribute``1">
+ <summary>
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Matches(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Returns the constraint provided as an argument - used to allow custom
+ custom constraints to easily participate in the syntax.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Matches``1(System.Predicate{``0})">
+ <summary>
+ Returns the constraint provided as an argument - used to allow custom
+ custom constraints to easily participate in the syntax.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.EqualTo(System.Object)">
+ <summary>
+ Returns a constraint that tests two items for equality
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SameAs(System.Object)">
+ <summary>
+ Returns a constraint that tests that two references are the same object
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.GreaterThan(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is greater than the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.GreaterThanOrEqualTo(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AtLeast(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.LessThan(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is less than the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.LessThanOrEqualTo(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AtMost(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.TypeOf(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.TypeOf``1">
+ <summary>
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOf(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOf``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOfType(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOfType``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableFrom(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableFrom``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableTo(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableTo``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.EquivalentTo(System.Collections.IEnumerable)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is a collection containing the same elements as the
+ collection supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SubsetOf(System.Collections.IEnumerable)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is a subset of the collection supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Member(System.Object)">
+ <summary>
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Contains(System.Object)">
+ <summary>
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Contains(System.String)">
+ <summary>
+ Returns a new ContainsConstraint. This constraint
+ will, in turn, make use of the appropriate second-level
+ constraint, depending on the type of the actual argument.
+ This overload is only used if the item sought is a string,
+ since any other type implies that we are looking for a
+ collection member.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringContaining(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.ContainsSubstring(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StartsWith(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringStarting(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.EndsWith(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringEnding(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Matches(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringMatching(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SamePath(System.String)">
+ <summary>
+ Returns a constraint that tests whether the path provided
+ is the same as an expected path after canonicalization.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SamePathOrUnder(System.String)">
+ <summary>
+ Returns a constraint that tests whether the path provided
+ is the same path or under an expected path after canonicalization.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InRange(System.IComparable,System.IComparable)">
+ <summary>
+ Returns a constraint that tests whether the actual value falls
+ within a specified range.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Not">
+ <summary>
+ Returns a ConstraintExpression that negates any
+ following constraint.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.No">
+ <summary>
+ Returns a ConstraintExpression that negates any
+ following constraint.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.All">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Some">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if at least one of them succeeds.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.None">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them fail.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Length">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Length property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Count">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Count property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Message">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Message property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.InnerException">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the InnerException property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.With">
+ <summary>
+ With is currently a NOP - reserved for future use.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Null">
+ <summary>
+ Returns a constraint that tests for null
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.True">
+ <summary>
+ Returns a constraint that tests for True
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.False">
+ <summary>
+ Returns a constraint that tests for False
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.NaN">
+ <summary>
+ Returns a constraint that tests for NaN
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Empty">
+ <summary>
+ Returns a constraint that tests for empty
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Unique">
+ <summary>
+ Returns a constraint that tests whether a collection
+ contains all unique items.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.BinarySerializable">
+ <summary>
+ Returns a constraint that tests whether an object graph is serializable in binary format.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.XmlSerializable">
+ <summary>
+ Returns a constraint that tests whether an object graph is serializable in xml format.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Ordered">
+ <summary>
+ Returns a constraint that tests whether a collection is ordered
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.RangeConstraint">
+ <summary>
+ RangeConstraint tests whethe two values are within a
+ specified range.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.RangeConstraint.#ctor(System.IComparable,System.IComparable)">
+ <summary>
+ Initializes a new instance of the <see cref="T:RangeConstraint"/> class.
+ </summary>
+ <param name="from">From.</param>
+ <param name="to">To.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.RangeConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.RangeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.RangeConstraint.Using(System.Collections.IComparer)">
+ <summary>
+ Modifies the constraint to use an IComparer and returns self.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.RangeConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
+ <summary>
+ Modifies the constraint to use an IComparer<T> and returns self.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.RangeConstraint.Using``1(System.Comparison{``0})">
+ <summary>
+ Modifies the constraint to use a Comparison<T> and returns self.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.EqualConstraint">
+ <summary>
+ EqualConstraint is able to compare an actual value with the
+ expected value provided in its constructor. Two objects are
+ considered equal if both are null, or if both have the same
+ value. NUnit has special semantics for some object types.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.EqualConstraint.clipStrings">
+ <summary>
+ If true, strings in error messages will be clipped
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.EqualConstraint.comparer">
+ <summary>
+ NUnitEqualityComparer used to test equality.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.#ctor(System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:NUnit.Framework.Constraints.EqualConstraint"/> class.
+ </summary>
+ <param name="expected">The expected value.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.Within(System.Object)">
+ <summary>
+ Flag the constraint to use a tolerance when determining equality.
+ </summary>
+ <param name="amount">Tolerance value to be used</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.Comparer(System.Collections.IComparer)">
+ <summary>
+ Flag the constraint to use the supplied IComparer object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using(System.Collections.IComparer)">
+ <summary>
+ Flag the constraint to use the supplied IComparer object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
+ <summary>
+ Flag the constraint to use the supplied IComparer object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using``1(System.Comparison{``0})">
+ <summary>
+ Flag the constraint to use the supplied Comparison object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using(System.Collections.IEqualityComparer)">
+ <summary>
+ Flag the constraint to use the supplied IEqualityComparer object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using``1(System.Collections.Generic.IEqualityComparer{``0})">
+ <summary>
+ Flag the constraint to use the supplied IEqualityComparer object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.WriteMessageTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a failure message. Overridden to provide custom
+ failure messages for EqualConstraint.
+ </summary>
+ <param name="writer">The MessageWriter to write to</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write description of this constraint
+ </summary>
+ <param name="writer">The MessageWriter to write to</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.DisplayCollectionDifferences(NUnit.Framework.Constraints.MessageWriter,System.Collections.ICollection,System.Collections.ICollection,System.Int32)">
+ <summary>
+ Display the failure information for two collections that did not match.
+ </summary>
+ <param name="writer">The MessageWriter on which to display</param>
+ <param name="expected">The expected collection.</param>
+ <param name="actual">The actual collection</param>
+ <param name="depth">The depth of this failure in a set of nested collections</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.DisplayCollectionTypesAndSizes(NUnit.Framework.Constraints.MessageWriter,System.Collections.ICollection,System.Collections.ICollection,System.Int32)">
+ <summary>
+ Displays a single line showing the types and sizes of the expected
+ and actual collections or arrays. If both are identical, the value is
+ only shown once.
+ </summary>
+ <param name="writer">The MessageWriter on which to display</param>
+ <param name="expected">The expected collection or array</param>
+ <param name="actual">The actual collection or array</param>
+ <param name="indent">The indentation level for the message line</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.DisplayFailurePoint(NUnit.Framework.Constraints.MessageWriter,System.Collections.ICollection,System.Collections.ICollection,System.Int32,System.Int32)">
+ <summary>
+ Displays a single line showing the point in the expected and actual
+ arrays at which the comparison failed. If the arrays have different
+ structures or dimensions, both values are shown.
+ </summary>
+ <param name="writer">The MessageWriter on which to display</param>
+ <param name="expected">The expected array</param>
+ <param name="actual">The actual array</param>
+ <param name="failurePoint">Index of the failure point in the underlying collections</param>
+ <param name="indent">The indentation level for the message line</param>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.IgnoreCase">
+ <summary>
+ Flag the constraint to ignore case and return self.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.NoClip">
+ <summary>
+ Flag the constraint to suppress string clipping
+ and return self.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.AsCollection">
+ <summary>
+ Flag the constraint to compare arrays as collections
+ and return self.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.Ulps">
+ <summary>
+ Switches the .Within() modifier to interpret its tolerance as
+ a distance in representable values (see remarks).
+ </summary>
+ <returns>Self.</returns>
+ <remarks>
+ Ulp stands for "unit in the last place" and describes the minimum
+ amount a given value can change. For any integers, an ulp is 1 whole
+ digit. For floating point values, the accuracy of which is better
+ for smaller numbers and worse for larger numbers, an ulp depends
+ on the size of the number. Using ulps for comparison of floating
+ point results instead of fixed tolerances is safer because it will
+ automatically compensate for the added inaccuracy of larger numbers.
+ </remarks>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.Percent">
+ <summary>
+ Switches the .Within() modifier to interpret its tolerance as
+ a percentage that the actual values is allowed to deviate from
+ the expected value.
+ </summary>
+ <returns>Self</returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.Days">
+ <summary>
+ Causes the tolerance to be interpreted as a TimeSpan in days.
+ </summary>
+ <returns>Self</returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.Hours">
+ <summary>
+ Causes the tolerance to be interpreted as a TimeSpan in hours.
+ </summary>
+ <returns>Self</returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.Minutes">
+ <summary>
+ Causes the tolerance to be interpreted as a TimeSpan in minutes.
+ </summary>
+ <returns>Self</returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.Seconds">
+ <summary>
+ Causes the tolerance to be interpreted as a TimeSpan in seconds.
+ </summary>
+ <returns>Self</returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.Milliseconds">
+ <summary>
+ Causes the tolerance to be interpreted as a TimeSpan in milliseconds.
+ </summary>
+ <returns>Self</returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.Ticks">
+ <summary>
+ Causes the tolerance to be interpreted as a TimeSpan in clock ticks.
+ </summary>
+ <returns>Self</returns>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.NotConstraint">
+ <summary>
+ NotConstraint negates the effect of some other constraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NotConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Initializes a new instance of the <see cref="T:NotConstraint"/> class.
+ </summary>
+ <param name="baseConstraint">The base constraint to be negated.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NotConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for if the base constraint fails, false if it succeeds</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NotConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NotConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a MessageWriter.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.AllItemsConstraint">
+ <summary>
+ AllItemsConstraint applies another constraint to each
+ item in a collection, succeeding if they all succeed.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AllItemsConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Construct an AllItemsConstraint on top of an existing constraint
+ </summary>
+ <param name="itemConstraint"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AllItemsConstraint.Matches(System.Object)">
+ <summary>
+ Apply the item constraint to each item in the collection,
+ failing if any item fails.
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AllItemsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.SomeItemsConstraint">
+ <summary>
+ SomeItemsConstraint applies another constraint to each
+ item in a collection, succeeding if any of them succeeds.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SomeItemsConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Construct a SomeItemsConstraint on top of an existing constraint
+ </summary>
+ <param name="itemConstraint"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SomeItemsConstraint.Matches(System.Object)">
+ <summary>
+ Apply the item constraint to each item in the collection,
+ succeeding if any item succeeds.
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SomeItemsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.NoItemConstraint">
+ <summary>
+ NoItemConstraint applies another constraint to each
+ item in a collection, failing if any of them succeeds.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NoItemConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Construct a SomeItemsConstraint on top of an existing constraint
+ </summary>
+ <param name="itemConstraint"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NoItemConstraint.Matches(System.Object)">
+ <summary>
+ Apply the item constraint to each item in the collection,
+ failing if any item fails.
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NoItemConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ContainsConstraint">
+ <summary>
+ ContainsConstraint tests a whether a string contains a substring
+ or a collection contains an object. It postpones the decision of
+ which test to use until the type of the actual argument is known.
+ This allows testing whether a string is contained in a collection
+ or as a substring of another string using the same syntax.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ContainsConstraint.#ctor(System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:ContainsConstraint"/> class.
+ </summary>
+ <param name="expected">The expected.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ContainsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ContainsConstraint.IgnoreCase">
+ <summary>
+ Flag the constraint to ignore case and return self.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.MsgUtils">
+ <summary>
+ Static methods used in creating messages
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.MsgUtils.ELLIPSIS">
+ <summary>
+ Static string used when strings are clipped
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MsgUtils.GetTypeRepresentation(System.Object)">
+ <summary>
+ Returns the representation of a type as used in NUnitLite.
+ This is the same as Type.ToString() except for arrays,
+ which are displayed with their declared sizes.
+ </summary>
+ <param name="obj"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MsgUtils.EscapeControlChars(System.String)">
+ <summary>
+ Converts any control characters in a string
+ to their escaped representation.
+ </summary>
+ <param name="s">The string to be converted</param>
+ <returns>The converted string</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MsgUtils.GetArrayIndicesAsString(System.Int32[])">
+ <summary>
+ Return the a string representation for a set of indices into an array
+ </summary>
+ <param name="indices">Array of indices for which a string is needed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MsgUtils.GetArrayIndicesFromCollectionIndex(System.Collections.ICollection,System.Int32)">
+ <summary>
+ Get an array of indices representing the point in a collection or
+ array corresponding to a single int index into the collection.
+ </summary>
+ <param name="collection">The collection to which the indices apply</param>
+ <param name="index">Index in the collection</param>
+ <returns>Array of indices</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MsgUtils.ClipString(System.String,System.Int32,System.Int32)">
+ <summary>
+ Clip a string to a given length, starting at a particular offset, returning the clipped
+ string with ellipses representing the removed parts
+ </summary>
+ <param name="s">The string to be clipped</param>
+ <param name="maxStringLength">The maximum permitted length of the result string</param>
+ <param name="clipStart">The point at which to start clipping</param>
+ <returns>The clipped string</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MsgUtils.ClipExpectedAndActual(System.String@,System.String@,System.Int32,System.Int32)">
+ <summary>
+ Clip the expected and actual strings in a coordinated fashion,
+ so that they may be displayed together.
+ </summary>
+ <param name="expected"></param>
+ <param name="actual"></param>
+ <param name="maxDisplayLength"></param>
+ <param name="mismatch"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MsgUtils.FindMismatchPosition(System.String,System.String,System.Int32,System.Boolean)">
+ <summary>
+ Shows the position two strings start to differ. Comparison
+ starts at the start index.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The actual string</param>
+ <param name="istart">The index in the strings at which comparison should start</param>
+ <param name="ignoreCase">Boolean indicating whether case should be ignored</param>
+ <returns>-1 if no mismatch found, or the index where mismatch found</returns>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.BasicConstraint">
+ <summary>
+ BasicConstraint is the abstract base for constraints that
+ perform a simple comparison to a constant value.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BasicConstraint.#ctor(System.Object,System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:BasicConstraint"/> class.
+ </summary>
+ <param name="expected">The expected.</param>
+ <param name="description">The description.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BasicConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BasicConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.NullConstraint">
+ <summary>
+ NullConstraint tests that the actual value is null
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NullConstraint.#ctor">
+ <summary>
+ Initializes a new instance of the <see cref="T:NullConstraint"/> class.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.TrueConstraint">
+ <summary>
+ TrueConstraint tests that the actual value is true
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.TrueConstraint.#ctor">
+ <summary>
+ Initializes a new instance of the <see cref="T:TrueConstraint"/> class.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.FalseConstraint">
+ <summary>
+ FalseConstraint tests that the actual value is false
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.FalseConstraint.#ctor">
+ <summary>
+ Initializes a new instance of the <see cref="T:FalseConstraint"/> class.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.NaNConstraint">
+ <summary>
+ NaNConstraint tests that the actual value is a double or float NaN
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NaNConstraint.Matches(System.Object)">
+ <summary>
+ Test that the actual value is an NaN
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NaNConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a specified writer
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.MessageWriter">
+ <summary>
+ MessageWriter is the abstract base for classes that write
+ constraint descriptions and messages in some form. The
+ class has separate methods for writing various components
+ of a message, allowing implementations to tailor the
+ presentation as needed.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.#ctor">
+ <summary>
+ Construct a MessageWriter given a culture
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteMessageLine(System.String,System.Object[])">
+ <summary>
+ Method to write single line message with optional args, usually
+ written to precede the general failure message.
+ </summary>
+ <param name="message">The message to be written</param>
+ <param name="args">Any arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteMessageLine(System.Int32,System.String,System.Object[])">
+ <summary>
+ Method to write single line message with optional args, usually
+ written to precede the general failure message, at a givel
+ indentation level.
+ </summary>
+ <param name="level">The indentation level of the message</param>
+ <param name="message">The message to be written</param>
+ <param name="args">Any arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayDifferences(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Display Expected and Actual lines for a constraint. This
+ is called by MessageWriter's default implementation of
+ WriteMessageTo and provides the generic two-line display.
+ </summary>
+ <param name="constraint">The constraint that failed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayDifferences(System.Object,System.Object)">
+ <summary>
+ Display Expected and Actual lines for given values. This
+ method may be called by constraints that need more control over
+ the display of actual and expected values than is provided
+ by the default implementation.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value causing the failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayDifferences(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance)">
+ <summary>
+ Display Expected and Actual lines for given values, including
+ a tolerance value on the Expected line.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value causing the failure</param>
+ <param name="tolerance">The tolerance within which the test was made</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayStringDifferences(System.String,System.String,System.Int32,System.Boolean,System.Boolean)">
+ <summary>
+ Display the expected and actual string values on separate lines.
+ If the mismatch parameter is >=0, an additional line is displayed
+ line containing a caret that points to the mismatch point.
+ </summary>
+ <param name="expected">The expected string value</param>
+ <param name="actual">The actual string value</param>
+ <param name="mismatch">The point at which the strings don't match or -1</param>
+ <param name="ignoreCase">If true, case is ignored in locating the point where the strings differ</param>
+ <param name="clipping">If true, the strings should be clipped to fit the line</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteConnector(System.String)">
+ <summary>
+ Writes the text for a connector.
+ </summary>
+ <param name="connector">The connector.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.WritePredicate(System.String)">
+ <summary>
+ Writes the text for a predicate.
+ </summary>
+ <param name="predicate">The predicate.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteExpectedValue(System.Object)">
+ <summary>
+ Writes the text for an expected value.
+ </summary>
+ <param name="expected">The expected value.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteModifier(System.String)">
+ <summary>
+ Writes the text for a modifier
+ </summary>
+ <param name="modifier">The modifier.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteActualValue(System.Object)">
+ <summary>
+ Writes the text for an actual value.
+ </summary>
+ <param name="actual">The actual value.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteValue(System.Object)">
+ <summary>
+ Writes the text for a generalized value.
+ </summary>
+ <param name="val">The value.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteCollectionElements(System.Collections.ICollection,System.Int32,System.Int32)">
+ <summary>
+ Writes the text for a collection value,
+ starting at a particular point, to a max length
+ </summary>
+ <param name="collection">The collection containing elements to write.</param>
+ <param name="start">The starting point of the elements to write</param>
+ <param name="max">The maximum number of elements to write</param>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.MessageWriter.MaxLineLength">
+ <summary>
+ Abstract method to get the max line length
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ToleranceMode">
+ <summary>
+ Modes in which the tolerance value for a comparison can
+ be interpreted.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ToleranceMode.None">
+ <summary>
+ The tolerance was created with a value, without specifying
+ how the value would be used. This is used to prevent setting
+ the mode more than once and is generally changed to Linear
+ upon execution of the test.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ToleranceMode.Linear">
+ <summary>
+ The tolerance is used as a numeric range within which
+ two compared values are considered to be equal.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ToleranceMode.Percent">
+ <summary>
+ Interprets the tolerance as the percentage by which
+ the two compared values my deviate from each other.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ToleranceMode.Ulps">
+ <summary>
+ Compares two values based in their distance in
+ representable numbers.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.Tolerance">
+ <summary>
+ The Tolerance class generalizes the notion of a tolerance
+ within which an equality test succeeds. Normally, it is
+ used with numeric types, but it can be used with any
+ type that supports taking a difference between two
+ objects and comparing that difference to a value.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Tolerance.#ctor(System.Object)">
+ <summary>
+ Constructs a linear tolerance of a specdified amount
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Tolerance.#ctor(System.Object,NUnit.Framework.Constraints.ToleranceMode)">
+ <summary>
+ Constructs a tolerance given an amount and ToleranceMode
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Tolerance.CheckLinearAndNumeric">
+ <summary>
+ Tests that the current Tolerance is linear with a
+ numeric value, throwing an exception if it is not.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Empty">
+ <summary>
+ Returns an empty Tolerance object, equivalent to
+ specifying an exact match.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Mode">
+ <summary>
+ Gets the ToleranceMode for the current Tolerance
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Value">
+ <summary>
+ Gets the value of the current Tolerance instance.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Percent">
+ <summary>
+ Returns a new tolerance, using the current amount as a percentage.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Ulps">
+ <summary>
+ Returns a new tolerance, using the current amount in Ulps.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Days">
+ <summary>
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of days.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Hours">
+ <summary>
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of hours.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Minutes">
+ <summary>
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of minutes.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Seconds">
+ <summary>
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of seconds.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Milliseconds">
+ <summary>
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of milliseconds.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Ticks">
+ <summary>
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of clock ticks.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.IsEmpty">
+ <summary>
+ Returns true if the current tolerance is empty.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.Numerics">
+ <summary>
+ The Numerics class contains common operations on numeric values.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Numerics.IsNumericType(System.Object)">
+ <summary>
+ Checks the type of the object, returning true if
+ the object is a numeric type.
+ </summary>
+ <param name="obj">The object to check</param>
+ <returns>true if the object is a numeric type</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Numerics.IsFloatingPointNumeric(System.Object)">
+ <summary>
+ Checks the type of the object, returning true if
+ the object is a floating point numeric type.
+ </summary>
+ <param name="obj">The object to check</param>
+ <returns>true if the object is a floating point numeric type</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Numerics.IsFixedPointNumeric(System.Object)">
+ <summary>
+ Checks the type of the object, returning true if
+ the object is a fixed point numeric type.
+ </summary>
+ <param name="obj">The object to check</param>
+ <returns>true if the object is a fixed point numeric type</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Numerics.AreEqual(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance@)">
+ <summary>
+ Test two numeric values for equality, performing the usual numeric
+ conversions and using a provided or default tolerance. If the tolerance
+ provided is Empty, this method may set it to a default tolerance.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="tolerance">A reference to the tolerance in effect</param>
+ <returns>True if the values are equal</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Numerics.Compare(System.Object,System.Object)">
+ <summary>
+ Compare two numeric values, performing the usual numeric conversions.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <returns>The relationship of the values to each other</returns>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.EmptyConstraint">
+ <summary>
+ EmptyConstraint tests a whether a string or collection is empty,
+ postponing the decision about which test is applied until the
+ type of the actual argument is known.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EmptyConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EmptyConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.StringConstraint">
+ <summary>
+ StringConstraint is the abstract base for constraints
+ that operate on strings. It supports the IgnoreCase
+ modifier for string operations.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.StringConstraint.expected">
+ <summary>
+ The expected value
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.StringConstraint.caseInsensitive">
+ <summary>
+ Indicates whether tests should be case-insensitive
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.StringConstraint.#ctor(System.String)">
+ <summary>
+ Constructs a StringConstraint given an expected value
+ </summary>
+ <param name="expected">The expected value</param>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.StringConstraint.IgnoreCase">
+ <summary>
+ Modify the constraint to ignore case in matching.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.EmptyStringConstraint">
+ <summary>
+ EmptyStringConstraint tests whether a string is empty.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EmptyStringConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EmptyStringConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.NullOrEmptyStringConstraint">
+ <summary>
+ NullEmptyStringConstraint tests whether a string is either null or empty.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NullOrEmptyStringConstraint.#ctor">
+ <summary>
+ Constructs a new NullOrEmptyStringConstraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NullOrEmptyStringConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NullOrEmptyStringConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.SubstringConstraint">
+ <summary>
+ SubstringConstraint can test whether a string contains
+ the expected substring.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SubstringConstraint.#ctor(System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:SubstringConstraint"/> class.
+ </summary>
+ <param name="expected">The expected.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SubstringConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SubstringConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.StartsWithConstraint">
+ <summary>
+ StartsWithConstraint can test whether a string starts
+ with an expected substring.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.StartsWithConstraint.#ctor(System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:StartsWithConstraint"/> class.
+ </summary>
+ <param name="expected">The expected string</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.StartsWithConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is matched by the actual value.
+ This is a template method, which calls the IsMatch method
+ of the derived class.
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.StartsWithConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.EndsWithConstraint">
+ <summary>
+ EndsWithConstraint can test whether a string ends
+ with an expected substring.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EndsWithConstraint.#ctor(System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:EndsWithConstraint"/> class.
+ </summary>
+ <param name="expected">The expected string</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EndsWithConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is matched by the actual value.
+ This is a template method, which calls the IsMatch method
+ of the derived class.
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EndsWithConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.RegexConstraint">
+ <summary>
+ RegexConstraint can test whether a string matches
+ the pattern provided.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.RegexConstraint.#ctor(System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:RegexConstraint"/> class.
+ </summary>
+ <param name="pattern">The pattern.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.RegexConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.RegexConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ComparisonConstraint">
+ <summary>
+ Abstract base class for constraints that compare values to
+ determine if one is greater than, equal to or less than
+ the other.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.expected">
+ <summary>
+ The value against which a comparison is to be made
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.ltOK">
+ <summary>
+ If true, less than returns success
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.eqOK">
+ <summary>
+ if true, equal returns success
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.gtOK">
+ <summary>
+ if true, greater than returns success
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.predicate">
+ <summary>
+ The predicate used as a part of the description
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.comparer">
+ <summary>
+ ComparisonAdapter to be used in making the comparison
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.#ctor(System.Object,System.Boolean,System.Boolean,System.Boolean,System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:ComparisonConstraint"/> class.
+ </summary>
+ <param name="value">The value against which to make a comparison.</param>
+ <param name="ltOK">if set to <c>true</c> less succeeds.</param>
+ <param name="eqOK">if set to <c>true</c> equal succeeds.</param>
+ <param name="gtOK">if set to <c>true</c> greater succeeds.</param>
+ <param name="predicate">String used in describing the constraint.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Using(System.Collections.IComparer)">
+ <summary>
+ Modifies the constraint to use an IComparer and returns self
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
+ <summary>
+ Modifies the constraint to use an IComparer<T> and returns self
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Using``1(System.Comparison{``0})">
+ <summary>
+ Modifies the constraint to use a Comparison<T> and returns self
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.GreaterThanConstraint">
+ <summary>
+ Tests whether a value is greater than the value supplied to its constructor
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.GreaterThanConstraint.#ctor(System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:GreaterThanConstraint"/> class.
+ </summary>
+ <param name="expected">The expected value.</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.GreaterThanOrEqualConstraint">
+ <summary>
+ Tests whether a value is greater than or equal to the value supplied to its constructor
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.GreaterThanOrEqualConstraint.#ctor(System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:GreaterThanOrEqualConstraint"/> class.
+ </summary>
+ <param name="expected">The expected value.</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.LessThanConstraint">
+ <summary>
+ Tests whether a value is less than the value supplied to its constructor
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.LessThanConstraint.#ctor(System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:LessThanConstraint"/> class.
+ </summary>
+ <param name="expected">The expected value.</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.LessThanOrEqualConstraint">
+ <summary>
+ Tests whether a value is less than or equal to the value supplied to its constructor
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.LessThanOrEqualConstraint.#ctor(System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:LessThanOrEqualConstraint"/> class.
+ </summary>
+ <param name="expected">The expected value.</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.SameAsConstraint">
+ <summary>
+ SameAsConstraint tests whether an object is identical to
+ the object passed to its constructor
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SameAsConstraint.#ctor(System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:SameAsConstraint"/> class.
+ </summary>
+ <param name="expected">The expected object.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SameAsConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SameAsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.BinaryConstraint">
+ <summary>
+ BinaryConstraint is the abstract base of all constraints
+ that combine two other constraints in some fashion.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.BinaryConstraint.left">
+ <summary>
+ The first constraint being combined
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.BinaryConstraint.right">
+ <summary>
+ The second constraint being combined
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BinaryConstraint.#ctor(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Construct a BinaryConstraint from two other constraints
+ </summary>
+ <param name="left">The first constraint</param>
+ <param name="right">The second constraint</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.AndConstraint">
+ <summary>
+ AndConstraint succeeds only if both members succeed.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AndConstraint.#ctor(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Create an AndConstraint from two other constraints
+ </summary>
+ <param name="left">The first constraint</param>
+ <param name="right">The second constraint</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AndConstraint.Matches(System.Object)">
+ <summary>
+ Apply both member constraints to an actual value, succeeding
+ succeeding only if both of them succeed.
+ </summary>
+ <param name="actual">The actual value</param>
+ <returns>True if the constraints both succeeded</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AndConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description for this contraint to a MessageWriter
+ </summary>
+ <param name="writer">The MessageWriter to receive the description</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AndConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter. The default implementation simply writes
+ the raw value of actual, leaving it to the writer to
+ perform any formatting.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.OrConstraint">
+ <summary>
+ OrConstraint succeeds if either member succeeds
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.OrConstraint.#ctor(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Create an OrConstraint from two other constraints
+ </summary>
+ <param name="left">The first constraint</param>
+ <param name="right">The second constraint</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.OrConstraint.Matches(System.Object)">
+ <summary>
+ Apply the member constraints to an actual value, succeeding
+ succeeding as soon as one of them succeeds.
+ </summary>
+ <param name="actual">The actual value</param>
+ <returns>True if either constraint succeeded</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.OrConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description for this contraint to a MessageWriter
+ </summary>
+ <param name="writer">The MessageWriter to receive the description</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ConstraintFactory">
+ <summary>
+ Helper class with properties and methods that supply
+ a number of constraints used in Asserts.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Property(System.String)">
+ <summary>
+ Returns a new PropertyConstraintExpression, which will either
+ test for the existence of the named property on the object
+ being tested or apply any following constraint to that property.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Attribute(System.Type)">
+ <summary>
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Attribute``1">
+ <summary>
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.EqualTo(System.Object)">
+ <summary>
+ Returns a constraint that tests two items for equality
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SameAs(System.Object)">
+ <summary>
+ Returns a constraint that tests that two references are the same object
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.GreaterThan(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is greater than the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.GreaterThanOrEqualTo(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AtLeast(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.LessThan(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is less than the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.LessThanOrEqualTo(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AtMost(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.TypeOf(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.TypeOf``1">
+ <summary>
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOf(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOf``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOfType(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOfType``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableFrom(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableFrom``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableTo(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableTo``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.EquivalentTo(System.Collections.IEnumerable)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is a collection containing the same elements as the
+ collection supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SubsetOf(System.Collections.IEnumerable)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is a subset of the collection supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Member(System.Object)">
+ <summary>
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Contains(System.Object)">
+ <summary>
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Contains(System.String)">
+ <summary>
+ Returns a new ContainsConstraint. This constraint
+ will, in turn, make use of the appropriate second-level
+ constraint, depending on the type of the actual argument.
+ This overload is only used if the item sought is a string,
+ since any other type implies that we are looking for a
+ collection member.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringContaining(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.ContainsSubstring(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotContain(System.String)">
+ <summary>
+ Returns a constraint that fails if the actual
+ value contains the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StartsWith(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringStarting(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotStartWith(System.String)">
+ <summary>
+ Returns a constraint that fails if the actual
+ value starts with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.EndsWith(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringEnding(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotEndWith(System.String)">
+ <summary>
+ Returns a constraint that fails if the actual
+ value ends with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Matches(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringMatching(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotMatch(System.String)">
+ <summary>
+ Returns a constraint that fails if the actual
+ value matches the pattern supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SamePath(System.String)">
+ <summary>
+ Returns a constraint that tests whether the path provided
+ is the same as an expected path after canonicalization.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SamePathOrUnder(System.String)">
+ <summary>
+ Returns a constraint that tests whether the path provided
+ is the same path or under an expected path after canonicalization.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InRange(System.IComparable,System.IComparable)">
+ <summary>
+ Returns a constraint that tests whether the actual value falls
+ within a specified range.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Not">
+ <summary>
+ Returns a ConstraintExpression that negates any
+ following constraint.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.No">
+ <summary>
+ Returns a ConstraintExpression that negates any
+ following constraint.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.All">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Some">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if at least one of them succeeds.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.None">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them fail.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Length">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Length property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Count">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Count property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Message">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Message property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.InnerException">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the InnerException property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Null">
+ <summary>
+ Returns a constraint that tests for null
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.True">
+ <summary>
+ Returns a constraint that tests for True
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.False">
+ <summary>
+ Returns a constraint that tests for False
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.NaN">
+ <summary>
+ Returns a constraint that tests for NaN
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Empty">
+ <summary>
+ Returns a constraint that tests for empty
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Unique">
+ <summary>
+ Returns a constraint that tests whether a collection
+ contains all unique items.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.BinarySerializable">
+ <summary>
+ Returns a constraint that tests whether an object graph is serializable in binary format.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.XmlSerializable">
+ <summary>
+ Returns a constraint that tests whether an object graph is serializable in xml format.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Ordered">
+ <summary>
+ Returns a constraint that tests whether a collection is ordered
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.DelayedConstraint">
+ <summary>
+ Applies a delay to the match so that a match can be evaluated in the future.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.DelayedConstraint.#ctor(NUnit.Framework.Constraints.Constraint,System.Int32)">
+ <summary>
+ Creates a new DelayedConstraint
+ </summary>
+ <param name="baseConstraint">The inner constraint two decorate</param>
+ <param name="delayInMilliseconds">The time interval after which the match is performed</param>
+ <exception cref="T:System.InvalidOperationException">If the value of <paramref name="delayInMilliseconds"/> is less than 0</exception>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.DelayedConstraint.#ctor(NUnit.Framework.Constraints.Constraint,System.Int32,System.Int32)">
+ <summary>
+ Creates a new DelayedConstraint
+ </summary>
+ <param name="baseConstraint">The inner constraint two decorate</param>
+ <param name="delayInMilliseconds">The time interval after which the match is performed</param>
+ <param name="pollingInterval">The time interval used for polling</param>
+ <exception cref="T:System.InvalidOperationException">If the value of <paramref name="delayInMilliseconds"/> is less than 0</exception>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.DelayedConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for if the base constraint fails, false if it succeeds</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.DelayedConstraint.Matches(NUnit.Framework.Constraints.ActualValueDelegate)">
+ <summary>
+ Test whether the constraint is satisfied by a delegate
+ </summary>
+ <param name="del">The delegate whose value is to be tested</param>
+ <returns>True for if the base constraint fails, false if it succeeds</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.DelayedConstraint.Matches``1(``0@)">
+ <summary>
+ Test whether the constraint is satisfied by a given reference.
+ Overridden to wait for the specified delay period before
+ calling the base constraint with the dereferenced value.
+ </summary>
+ <param name="actual">A reference to the value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.DelayedConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.DelayedConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a MessageWriter.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.DelayedConstraint.ToString">
+ <summary>
+ Returns the string representation of the constraint.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.NUnitComparer">
+ <summary>
+ NUnitComparer encapsulates NUnit's default behavior
+ in comparing two objects.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NUnitComparer.Compare(System.Object,System.Object)">
+ <summary>
+ Compares two objects
+ </summary>
+ <param name="x"></param>
+ <param name="y"></param>
+ <returns></returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.NUnitComparer.Default">
+ <summary>
+ Returns the default NUnitComparer.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ActualValueDelegate">
+ <summary>
+ Delegate used to delay evaluation of the actual value
+ to be used in evaluating a constraint
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.NUnitEqualityComparer">
+ <summary>
+ NUnitEqualityComparer encapsulates NUnit's handling of
+ equality tests between objects.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.caseInsensitive">
+ <summary>
+ If true, all string comparisons will ignore case
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.compareAsCollection">
+ <summary>
+ If true, arrays will be treated as collections, allowing
+ those of different dimensions to be compared
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.tolerance">
+ <summary>
+ If non-zero, equality comparisons within the specified
+ tolerance will succeed.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.externalComparer">
+ <summary>
+ Comparison object used in comparisons for some constraints.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NUnitEqualityComparer.ObjectsEqual(System.Object,System.Object)">
+ <summary>
+ Compares two objects for equality.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NUnitEqualityComparer.ArraysEqual(System.Array,System.Array)">
+ <summary>
+ Helper method to compare two arrays
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NUnitEqualityComparer.DirectoriesEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
+ <summary>
+ Method to compare two DirectoryInfo objects
+ </summary>
+ <param name="x">first directory to compare</param>
+ <param name="y">second directory to compare</param>
+ <returns>true if equivalent, false if not</returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.Default">
+ <summary>
+ Returns the default NUnitEqualityComparer
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.IgnoreCase">
+ <summary>
+ Gets and sets a flag indicating whether case should
+ be ignored in determining equality.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.CompareAsCollection">
+ <summary>
+ Gets and sets a flag indicating that arrays should be
+ compared as collections, without regard to their shape.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.ExternalComparer">
+ <summary>
+ Gets and sets an external comparer to be used to
+ test for equality. It is applied to members of
+ collections, in place of NUnit's own logic.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.Tolerance">
+ <summary>
+ Gets and sets a tolerance used to compare objects of
+ certin types.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.FailurePoints">
+ <summary>
+ Gets the list of failure points for the last Match performed.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ComparisonAdapter">
+ <summary>
+ ComparisonAdapter class centralizes all comparisons of
+ values in NUnit, adapting to the use of any provided
+ IComparer, IComparer<T> or Comparison<T>
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.For(System.Collections.IComparer)">
+ <summary>
+ Returns a ComparisonAdapter that wraps an IComparer
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.For``1(System.Collections.Generic.IComparer{``0})">
+ <summary>
+ Returns a ComparisonAdapter that wraps an IComparer<T>
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.For``1(System.Comparison{``0})">
+ <summary>
+ Returns a ComparisonAdapter that wraps a Comparison<T>
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.Compare(System.Object,System.Object)">
+ <summary>
+ Compares two objects
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ComparisonAdapter.Default">
+ <summary>
+ Gets the default ComparisonAdapter, which wraps an
+ NUnitComparer object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter.#ctor(System.Collections.IComparer)">
+ <summary>
+ Construct a ComparisonAdapter for an IComparer
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter.Compare(System.Object,System.Object)">
+ <summary>
+ Compares two objects
+ </summary>
+ <param name="expected"></param>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.DefaultComparisonAdapter.#ctor">
+ <summary>
+ Construct a default ComparisonAdapter
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter`1">
+ <summary>
+ ComparisonAdapter<T> extends ComparisonAdapter and
+ allows use of an IComparer<T> or Comparison<T>
+ to actually perform the comparison.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter`1.#ctor(System.Collections.Generic.IComparer{`0})">
+ <summary>
+ Construct a ComparisonAdapter for an IComparer<T>
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter`1.Compare(System.Object,System.Object)">
+ <summary>
+ Compare a Type T to an object
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparisonAdapterForComparison`1.#ctor(System.Comparison{`0})">
+ <summary>
+ Construct a ComparisonAdapter for a Comparison<T>
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparisonAdapterForComparison`1.Compare(System.Object,System.Object)">
+ <summary>
+ Compare a Type T to an object
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ConstraintOperator">
+ <summary>
+ The ConstraintOperator class is used internally by a
+ ConstraintBuilder to represent an operator that
+ modifies or combines constraints.
+
+ Constraint operators use left and right precedence
+ values to determine whether the top operator on the
+ stack should be reduced before pushing a new operator.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ConstraintOperator.left_precedence">
+ <summary>
+ The precedence value used when the operator
+ is about to be pushed to the stack.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ConstraintOperator.right_precedence">
+ <summary>
+ The precedence value used when the operator
+ is on the top of the stack.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
+ <summary>
+ Reduce produces a constraint from the operator and
+ any arguments. It takes the arguments from the constraint
+ stack and pushes the resulting constraint on it.
+ </summary>
+ <param name="stack"></param>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintOperator.LeftContext">
+ <summary>
+ The syntax element preceding this operator
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintOperator.RightContext">
+ <summary>
+ The syntax element folowing this operator
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintOperator.LeftPrecedence">
+ <summary>
+ The precedence value used when the operator
+ is about to be pushed to the stack.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintOperator.RightPrecedence">
+ <summary>
+ The precedence value used when the operator
+ is on the top of the stack.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.PrefixOperator">
+ <summary>
+ PrefixOperator takes a single constraint and modifies
+ it's action in some way.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PrefixOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
+ <summary>
+ Reduce produces a constraint from the operator and
+ any arguments. It takes the arguments from the constraint
+ stack and pushes the resulting constraint on it.
+ </summary>
+ <param name="stack"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PrefixOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Returns the constraint created by applying this
+ prefix to another constraint.
+ </summary>
+ <param name="constraint"></param>
+ <returns></returns>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.NotOperator">
+ <summary>
+ Negates the test of the constraint it wraps.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NotOperator.#ctor">
+ <summary>
+ Constructs a new NotOperator
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NotOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Returns a NotConstraint applied to its argument.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.CollectionOperator">
+ <summary>
+ Abstract base for operators that indicate how to
+ apply a constraint to items in a collection.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionOperator.#ctor">
+ <summary>
+ Constructs a CollectionOperator
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.AllOperator">
+ <summary>
+ Represents a constraint that succeeds if all the
+ members of a collection match a base constraint.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AllOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Returns a constraint that will apply the argument
+ to the members of a collection, succeeding if
+ they all succeed.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.SomeOperator">
+ <summary>
+ Represents a constraint that succeeds if any of the
+ members of a collection match a base constraint.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SomeOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Returns a constraint that will apply the argument
+ to the members of a collection, succeeding if
+ any of them succeed.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.NoneOperator">
+ <summary>
+ Represents a constraint that succeeds if none of the
+ members of a collection match a base constraint.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NoneOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Returns a constraint that will apply the argument
+ to the members of a collection, succeeding if
+ none of them succeed.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.WithOperator">
+ <summary>
+ Represents a constraint that simply wraps the
+ constraint provided as an argument, without any
+ further functionality, but which modifes the
+ order of evaluation because of its precedence.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.WithOperator.#ctor">
+ <summary>
+ Constructor for the WithOperator
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.WithOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Returns a constraint that wraps its argument
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.SelfResolvingOperator">
+ <summary>
+ Abstract base class for operators that are able to reduce to a
+ constraint whether or not another syntactic element follows.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.PropOperator">
+ <summary>
+ Operator used to test for the presence of a named Property
+ on an object and optionally apply further tests to the
+ value of that property.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropOperator.#ctor(System.String)">
+ <summary>
+ Constructs a PropOperator for a particular named property
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
+ <summary>
+ Reduce produces a constraint from the operator and
+ any arguments. It takes the arguments from the constraint
+ stack and pushes the resulting constraint on it.
+ </summary>
+ <param name="stack"></param>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.PropOperator.Name">
+ <summary>
+ Gets the name of the property to which the operator applies
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.AttributeOperator">
+ <summary>
+ Operator that tests for the presence of a particular attribute
+ on a type and optionally applies further tests to the attribute.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeOperator.#ctor(System.Type)">
+ <summary>
+ Construct an AttributeOperator for a particular Type
+ </summary>
+ <param name="type">The Type of attribute tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
+ <summary>
+ Reduce produces a constraint from the operator and
+ any arguments. It takes the arguments from the constraint
+ stack and pushes the resulting constraint on it.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ThrowsOperator">
+ <summary>
+ Operator that tests that an exception is thrown and
+ optionally applies further tests to the exception.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsOperator.#ctor">
+ <summary>
+ Construct a ThrowsOperator
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
+ <summary>
+ Reduce produces a constraint from the operator and
+ any arguments. It takes the arguments from the constraint
+ stack and pushes the resulting constraint on it.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.BinaryOperator">
+ <summary>
+ Abstract base class for all binary operators
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BinaryOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
+ <summary>
+ Reduce produces a constraint from the operator and
+ any arguments. It takes the arguments from the constraint
+ stack and pushes the resulting constraint on it.
+ </summary>
+ <param name="stack"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BinaryOperator.ApplyOperator(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Abstract method that produces a constraint by applying
+ the operator to its left and right constraint arguments.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.BinaryOperator.LeftPrecedence">
+ <summary>
+ Gets the left precedence of the operator
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.BinaryOperator.RightPrecedence">
+ <summary>
+ Gets the right precedence of the operator
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.AndOperator">
+ <summary>
+ Operator that requires both it's arguments to succeed
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AndOperator.#ctor">
+ <summary>
+ Construct an AndOperator
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AndOperator.ApplyOperator(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Apply the operator to produce an AndConstraint
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.OrOperator">
+ <summary>
+ Operator that requires at least one of it's arguments to succeed
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.OrOperator.#ctor">
+ <summary>
+ Construct an OrOperator
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.OrOperator.ApplyOperator(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Apply the operator to produce an OrConstraint
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.BinarySerializableConstraint">
+ <summary>
+ BinarySerializableConstraint tests whether
+ an object is serializable in binary format.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter. The default implementation simply writes
+ the raw value of actual, leaving it to the writer to
+ perform any formatting.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.ToString">
+ <summary>
+ Returns the string representation
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.XmlSerializableConstraint">
+ <summary>
+ BinarySerializableConstraint tests whether
+ an object is serializable in binary format.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter. The default implementation simply writes
+ the raw value of actual, leaving it to the writer to
+ perform any formatting.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.ToString">
+ <summary>
+ Returns the string representation of this constraint
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ResolvableConstraintExpression">
+ <summary>
+ ResolvableConstraintExpression is used to represent a compound
+ constraint being constructed at a point where the last operator
+ may either terminate the expression or may have additional
+ qualifying constraints added to it.
+
+ It is used, for example, for a Property element or for
+ an Exception element, either of which may be optionally
+ followed by constraints that apply to the property or
+ exception.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.#ctor">
+ <summary>
+ Create a new instance of ResolvableConstraintExpression
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">
+ <summary>
+ Create a new instance of ResolvableConstraintExpression,
+ passing in a pre-populated ConstraintBuilder.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.NUnit#Framework#Constraints#IResolveConstraint#Resolve">
+ <summary>
+ Resolve the current expression to a Constraint
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ResolvableConstraintExpression.And">
+ <summary>
+ Appends an And Operator to the expression
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ResolvableConstraintExpression.Or">
+ <summary>
+ Appends an Or operator to the expression.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.EqualityAdapter">
+ <summary>
+ EqualityAdapter class handles all equality comparisons
+ that use an IEqualityComparer, IEqualityComparer<T>
+ or a ComparisonAdapter.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualityAdapter.ObjectsEqual(System.Object,System.Object)">
+ <summary>
+ Compares two objects, returning true if they are equal
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For(System.Collections.IComparer)">
+ <summary>
+ Returns an EqualityAdapter that wraps an IComparer.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For(System.Collections.IEqualityComparer)">
+ <summary>
+ Returns an EqualityAdapter that wraps an IEqualityComparer.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For``1(System.Collections.Generic.IEqualityComparer{``0})">
+ <summary>
+ Returns an EqualityAdapter that wraps an IEqualityComparer<T>.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For``1(System.Collections.Generic.IComparer{``0})">
+ <summary>
+ Returns an EqualityAdapter that wraps an IComparer<T>.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For``1(System.Comparison{``0})">
+ <summary>
+ Returns an EqualityAdapter that wraps a Comparison<T>.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.AttributeExistsConstraint">
+ <summary>
+ AttributeExistsConstraint tests for the presence of a
+ specified attribute on a Type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeExistsConstraint.#ctor(System.Type)">
+ <summary>
+ Constructs an AttributeExistsConstraint for a specific attribute Type
+ </summary>
+ <param name="type"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeExistsConstraint.Matches(System.Object)">
+ <summary>
+ Tests whether the object provides the expected attribute.
+ </summary>
+ <param name="actual">A Type, MethodInfo, or other ICustomAttributeProvider</param>
+ <returns>True if the expected attribute is present, otherwise false</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeExistsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Writes the description of the constraint to the specified writer
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.AttributeConstraint">
+ <summary>
+ AttributeConstraint tests that a specified attribute is present
+ on a Type or other provider and that the value of the attribute
+ satisfies some other constraint.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeConstraint.#ctor(System.Type,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Constructs an AttributeConstraint for a specified attriute
+ Type and base constraint.
+ </summary>
+ <param name="type"></param>
+ <param name="baseConstraint"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeConstraint.Matches(System.Object)">
+ <summary>
+ Determines whether the Type or other provider has the
+ expected attribute and if its value matches the
+ additional constraint specified.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Writes a description of the attribute to the specified writer.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Writes the actual value supplied to the specified writer.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeConstraint.ToString">
+ <summary>
+ Returns a string representation of the constraint.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.FloatingPointNumerics">
+ <summary>Helper routines for working with floating point numbers</summary>
+ <remarks>
+ <para>
+ The floating point comparison code is based on this excellent article:
+ http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm
+ </para>
+ <para>
+ "ULP" means Unit in the Last Place and in the context of this library refers to
+ the distance between two adjacent floating point numbers. IEEE floating point
+ numbers can only represent a finite subset of natural numbers, with greater
+ accuracy for smaller numbers and lower accuracy for very large numbers.
+ </para>
+ <para>
+ If a comparison is allowed "2 ulps" of deviation, that means the values are
+ allowed to deviate by up to 2 adjacent floating point values, which might be
+ as low as 0.0000001 for small numbers or as high as 10.0 for large numbers.
+ </para>
+ </remarks>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.AreAlmostEqualUlps(System.Single,System.Single,System.Int32)">
+ <summary>Compares two floating point values for equality</summary>
+ <param name="left">First floating point value to be compared</param>
+ <param name="right">Second floating point value t be compared</param>
+ <param name="maxUlps">
+ Maximum number of representable floating point values that are allowed to
+ be between the left and the right floating point values
+ </param>
+ <returns>True if both numbers are equal or close to being equal</returns>
+ <remarks>
+ <para>
+ Floating point values can only represent a finite subset of natural numbers.
+ For example, the values 2.00000000 and 2.00000024 can be stored in a float,
+ but nothing inbetween them.
+ </para>
+ <para>
+ This comparison will count how many possible floating point values are between
+ the left and the right number. If the number of possible values between both
+ numbers is less than or equal to maxUlps, then the numbers are considered as
+ being equal.
+ </para>
+ <para>
+ Implementation partially follows the code outlined here:
+ http://www.anttirt.net/2007/08/19/proper-floating-point-comparisons/
+ </para>
+ </remarks>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.AreAlmostEqualUlps(System.Double,System.Double,System.Int64)">
+ <summary>Compares two double precision floating point values for equality</summary>
+ <param name="left">First double precision floating point value to be compared</param>
+ <param name="right">Second double precision floating point value t be compared</param>
+ <param name="maxUlps">
+ Maximum number of representable double precision floating point values that are
+ allowed to be between the left and the right double precision floating point values
+ </param>
+ <returns>True if both numbers are equal or close to being equal</returns>
+ <remarks>
+ <para>
+ Double precision floating point values can only represent a limited series of
+ natural numbers. For example, the values 2.0000000000000000 and 2.0000000000000004
+ can be stored in a double, but nothing inbetween them.
+ </para>
+ <para>
+ This comparison will count how many possible double precision floating point
+ values are between the left and the right number. If the number of possible
+ values between both numbers is less than or equal to maxUlps, then the numbers
+ are considered as being equal.
+ </para>
+ <para>
+ Implementation partially follows the code outlined here:
+ http://www.anttirt.net/2007/08/19/proper-floating-point-comparisons/
+ </para>
+ </remarks>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsInt(System.Single)">
+ <summary>
+ Reinterprets the memory contents of a floating point value as an integer value
+ </summary>
+ <param name="value">
+ Floating point value whose memory contents to reinterpret
+ </param>
+ <returns>
+ The memory contents of the floating point value interpreted as an integer
+ </returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsLong(System.Double)">
+ <summary>
+ Reinterprets the memory contents of a double precision floating point
+ value as an integer value
+ </summary>
+ <param name="value">
+ Double precision floating point value whose memory contents to reinterpret
+ </param>
+ <returns>
+ The memory contents of the double precision floating point value
+ interpreted as an integer
+ </returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsFloat(System.Int32)">
+ <summary>
+ Reinterprets the memory contents of an integer as a floating point value
+ </summary>
+ <param name="value">Integer value whose memory contents to reinterpret</param>
+ <returns>
+ The memory contents of the integer value interpreted as a floating point value
+ </returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsDouble(System.Int64)">
+ <summary>
+ Reinterprets the memory contents of an integer value as a double precision
+ floating point value
+ </summary>
+ <param name="value">Integer whose memory contents to reinterpret</param>
+ <returns>
+ The memory contents of the integer interpreted as a double precision
+ floating point value
+ </returns>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion">
+ <summary>Union of a floating point variable and an integer</summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion.Float">
+ <summary>The union's value as a floating point variable</summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion.Int">
+ <summary>The union's value as an integer</summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion.UInt">
+ <summary>The union's value as an unsigned integer</summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion">
+ <summary>Union of a double precision floating point variable and a long</summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion.Double">
+ <summary>The union's value as a double precision floating point variable</summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion.Long">
+ <summary>The union's value as a long</summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion.ULong">
+ <summary>The union's value as an unsigned long</summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.PredicateConstraint`1">
+ <summary>
+ Predicate constraint wraps a Predicate in a constraint,
+ returning success if the predicate is true.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PredicateConstraint`1.#ctor(System.Predicate{`0})">
+ <summary>
+ Construct a PredicateConstraint from a predicate
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PredicateConstraint`1.Matches(System.Object)">
+ <summary>
+ Determines whether the predicate succeeds when applied
+ to the actual value.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PredicateConstraint`1.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Writes the description to a MessageWriter
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TestCaseData">
+ <summary>
+ The TestCaseData class represents a set of arguments
+ and other parameter info to be used for a parameterized
+ test case. It provides a number of instance modifiers
+ for use in initializing the test case.
+
+ Note: Instance modifiers are getters that return
+ the same instance after modifying it's state.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.ITestCaseData">
+ <summary>
+ The ITestCaseData interface is implemented by a class
+ that is able to return complete testcases for use by
+ a parameterized test method.
+
+ NOTE: This interface is used in both the framework
+ and the core, even though that results in two different
+ types. However, sharing the source code guarantees that
+ the various implementations will be compatible and that
+ the core is able to reflect successfully over the
+ framework implementations of ITestCaseData.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ITestCaseData.Arguments">
+ <summary>
+ Gets the argument list to be provided to the test
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ITestCaseData.Result">
+ <summary>
+ Gets the expected result
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ITestCaseData.ExpectedException">
+ <summary>
+ Gets the expected exception Type
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ITestCaseData.ExpectedExceptionName">
+ <summary>
+ Gets the FullName of the expected exception
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ITestCaseData.TestName">
+ <summary>
+ Gets the name to be used for the test
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ITestCaseData.Description">
+ <summary>
+ Gets the description of the test
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ITestCaseData.Ignored">
+ <summary>
+ Gets a value indicating whether this <see cref="T:NUnit.Framework.ITestCaseData"/> is ignored.
+ </summary>
+ <value><c>true</c> if ignored; otherwise, <c>false</c>.</value>
+ </member>
+ <member name="P:NUnit.Framework.ITestCaseData.IgnoreReason">
+ <summary>
+ Gets the ignore reason.
+ </summary>
+ <value>The ignore reason.</value>
+ </member>
+ <member name="F:NUnit.Framework.TestCaseData.arguments">
+ <summary>
+ The argument list to be provided to the test
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TestCaseData.result">
+ <summary>
+ The expected result to be returned
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TestCaseData.expectedExceptionType">
+ <summary>
+ The expected exception Type
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TestCaseData.expectedExceptionName">
+ <summary>
+ The FullName of the expected exception
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TestCaseData.testName">
+ <summary>
+ The name to be used for the test
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TestCaseData.description">
+ <summary>
+ The description of the test
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TestCaseData.properties">
+ <summary>
+ A dictionary of properties, used to add information
+ to tests without requiring the class to change.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TestCaseData.isIgnored">
+ <summary>
+ If true, indicates that the test case is to be ignored
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TestCaseData.ignoreReason">
+ <summary>
+ The reason for ignoring a test case
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.#ctor(System.Object[])">
+ <summary>
+ Initializes a new instance of the <see cref="T:TestCaseData"/> class.
+ </summary>
+ <param name="args">The arguments.</param>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.#ctor(System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:TestCaseData"/> class.
+ </summary>
+ <param name="arg">The argument.</param>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.#ctor(System.Object,System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:TestCaseData"/> class.
+ </summary>
+ <param name="arg1">The first argument.</param>
+ <param name="arg2">The second argument.</param>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.#ctor(System.Object,System.Object,System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:TestCaseData"/> class.
+ </summary>
+ <param name="arg1">The first argument.</param>
+ <param name="arg2">The second argument.</param>
+ <param name="arg3">The third argument.</param>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.Returns(System.Object)">
+ <summary>
+ Sets the expected result for the test
+ </summary>
+ <param name="result">The expected result</param>
+ <returns>A modified TestCaseData</returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.Throws(System.Type)">
+ <summary>
+ Sets the expected exception type for the test
+ </summary>
+ <param name="exceptionType">Type of the expected exception.</param>
+ <returns>The modified TestCaseData instance</returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.Throws(System.String)">
+ <summary>
+ Sets the expected exception type for the test
+ </summary>
+ <param name="exceptionName">FullName of the expected exception.</param>
+ <returns>The modified TestCaseData instance</returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.SetName(System.String)">
+ <summary>
+ Sets the name of the test case
+ </summary>
+ <returns>The modified TestCaseData instance</returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.SetDescription(System.String)">
+ <summary>
+ Sets the description for the test case
+ being constructed.
+ </summary>
+ <param name="description">The description.</param>
+ <returns>The modified TestCaseData instance.</returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.SetCategory(System.String)">
+ <summary>
+ Applies a category to the test
+ </summary>
+ <param name="category"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.SetProperty(System.String,System.String)">
+ <summary>
+ Applies a named property to the test
+ </summary>
+ <param name="propName"></param>
+ <param name="propValue"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.SetProperty(System.String,System.Int32)">
+ <summary>
+ Applies a named property to the test
+ </summary>
+ <param name="propName"></param>
+ <param name="propValue"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.SetProperty(System.String,System.Double)">
+ <summary>
+ Applies a named property to the test
+ </summary>
+ <param name="propName"></param>
+ <param name="propValue"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.Ignore">
+ <summary>
+ Ignores this TestCase.
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.Ignore(System.String)">
+ <summary>
+ Ignores this TestCase, specifying the reason.
+ </summary>
+ <param name="reason">The reason.</param>
+ <returns></returns>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.Arguments">
+ <summary>
+ Gets the argument list to be provided to the test
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.Result">
+ <summary>
+ Gets the expected result
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.ExpectedException">
+ <summary>
+ Gets the expected exception Type
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.ExpectedExceptionName">
+ <summary>
+ Gets the FullName of the expected exception
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.TestName">
+ <summary>
+ Gets the name to be used for the test
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.Description">
+ <summary>
+ Gets the description of the test
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.Ignored">
+ <summary>
+ Gets a value indicating whether this <see cref="T:NUnit.Framework.ITestCaseData"/> is ignored.
+ </summary>
+ <value><c>true</c> if ignored; otherwise, <c>false</c>.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.IgnoreReason">
+ <summary>
+ Gets the ignore reason.
+ </summary>
+ <value>The ignore reason.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.Categories">
+ <summary>
+ Gets a list of categories associated with this test.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.Properties">
+ <summary>
+ Gets the property dictionary for this test
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TestCaseSourceAttribute">
+ <summary>
+ FactoryAttribute indicates the source to be used to
+ provide test cases for a test method.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseSourceAttribute.#ctor(System.String)">
+ <summary>
+ Construct with the name of the factory - for use with languages
+ that don't support params arrays.
+ </summary>
+ <param name="sourceName">An array of the names of the factories that will provide data</param>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseSourceAttribute.#ctor(System.Type,System.String)">
+ <summary>
+ Construct with a Type and name - for use with languages
+ that don't support params arrays.
+ </summary>
+ <param name="sourceType">The Type that will provide data</param>
+ <param name="sourceName">The name of the method, property or field that will provide data</param>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseSourceAttribute.SourceName">
+ <summary>
+ The name of a the method, property or fiend to be used as a source
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseSourceAttribute.SourceType">
+ <summary>
+ A Type to be used as a source
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Has">
+ <summary>
+ Helper class with properties and methods that supply
+ a number of constraints used in Asserts.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Has.Property(System.String)">
+ <summary>
+ Returns a new PropertyConstraintExpression, which will either
+ test for the existence of the named property on the object
+ being tested or apply any following constraint to that property.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Has.Attribute(System.Type)">
+ <summary>
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Has.Attribute``1">
+ <summary>
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Has.Member(System.Object)">
+ <summary>
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Has.No">
+ <summary>
+ Returns a ConstraintExpression that negates any
+ following constraint.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Has.All">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Has.Some">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if at least one of them succeeds.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Has.None">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them fail.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Has.Length">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Length property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Has.Count">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Count property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Has.Message">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Message property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Has.InnerException">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the InnerException property of the object being tested.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.List">
+ <summary>
+ The List class is a helper class with properties and methods
+ that supply a number of constraints used with lists and collections.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.List.Map(System.Collections.ICollection)">
+ <summary>
+ List.Map returns a ListMapper, which can be used to map
+ the original collection to another collection.
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="T:NUnit.Framework.MessageMatch">
+ <summary>
+ Enumeration indicating how the expected message parameter is to be used
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.MessageMatch.Exact">
+ Expect an exact match
+ </member>
+ <member name="F:NUnit.Framework.MessageMatch.Contains">
+ Expect a message containing the parameter string
+ </member>
+ <member name="F:NUnit.Framework.MessageMatch.Regex">
+ Match the regular expression provided as a parameter
+ </member>
+ <member name="F:NUnit.Framework.MessageMatch.StartsWith">
+ Expect a message that starts with the parameter string
+ </member>
+ <member name="T:NUnit.Framework.ExpectedExceptionAttribute">
+ <summary>
+ ExpectedExceptionAttribute
+ </summary>
+
+ </member>
+ <member name="M:NUnit.Framework.ExpectedExceptionAttribute.#ctor">
+ <summary>
+ Constructor for a non-specific exception
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.ExpectedExceptionAttribute.#ctor(System.Type)">
+ <summary>
+ Constructor for a given type of exception
+ </summary>
+ <param name="exceptionType">The type of the expected exception</param>
+ </member>
+ <member name="M:NUnit.Framework.ExpectedExceptionAttribute.#ctor(System.String)">
+ <summary>
+ Constructor for a given exception name
+ </summary>
+ <param name="exceptionName">The full name of the expected exception</param>
+ </member>
+ <member name="P:NUnit.Framework.ExpectedExceptionAttribute.ExpectedException">
+ <summary>
+ Gets or sets the expected exception type
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ExpectedExceptionAttribute.ExpectedExceptionName">
+ <summary>
+ Gets or sets the full Type name of the expected exception
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ExpectedExceptionAttribute.ExpectedMessage">
+ <summary>
+ Gets or sets the expected message text
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ExpectedExceptionAttribute.UserMessage">
+ <summary>
+ Gets or sets the user message displayed in case of failure
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ExpectedExceptionAttribute.MatchType">
+ <summary>
+ Gets or sets the type of match to be performed on the expected message
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ExpectedExceptionAttribute.Handler">
+ <summary>
+ Gets the name of a method to be used as an exception handler
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TestCaseAttribute">
+ <summary>
+ TestCaseAttribute is used to mark parameterized test cases
+ and provide them with their arguments.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object[])">
+ <summary>
+ Construct a TestCaseAttribute with a list of arguments.
+ This constructor is not CLS-Compliant
+ </summary>
+ <param name="arguments"></param>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object)">
+ <summary>
+ Construct a TestCaseAttribute with a single argument
+ </summary>
+ <param name="arg"></param>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object,System.Object)">
+ <summary>
+ Construct a TestCaseAttribute with a two arguments
+ </summary>
+ <param name="arg1"></param>
+ <param name="arg2"></param>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object,System.Object,System.Object)">
+ <summary>
+ Construct a TestCaseAttribute with a three arguments
+ </summary>
+ <param name="arg1"></param>
+ <param name="arg2"></param>
+ <param name="arg3"></param>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.Arguments">
+ <summary>
+ Gets the list of arguments to a test case
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.Result">
+ <summary>
+ Gets or sets the expected result.
+ </summary>
+ <value>The result.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.ExpectedException">
+ <summary>
+ Gets or sets the expected exception.
+ </summary>
+ <value>The expected exception.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.ExpectedExceptionName">
+ <summary>
+ Gets or sets the name the expected exception.
+ </summary>
+ <value>The expected name of the exception.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.ExpectedMessage">
+ <summary>
+ Gets or sets the expected message of the expected exception
+ </summary>
+ <value>The expected message of the exception.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.MatchType">
+ <summary>
+ Gets or sets the type of match to be performed on the expected message
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.Description">
+ <summary>
+ Gets or sets the description.
+ </summary>
+ <value>The description.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.TestName">
+ <summary>
+ Gets or sets the name of the test.
+ </summary>
+ <value>The name of the test.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.Ignore">
+ <summary>
+ Gets or sets the ignored status of the test
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.Ignored">
+ <summary>
+ Gets or sets the ignored status of the test
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.IgnoreReason">
+ <summary>
+ Gets the ignore reason.
+ </summary>
+ <value>The ignore reason.</value>
+ </member>
+ <member name="T:NUnit.Framework.SuccessException">
+ <summary>
+ Thrown when an assertion failed.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.SuccessException.#ctor(System.String)">
+ <param name="message"></param>
+ </member>
+ <member name="M:NUnit.Framework.SuccessException.#ctor(System.String,System.Exception)">
+ <param name="message">The error message that explains
+ the reason for the exception</param>
+ <param name="inner">The exception that caused the
+ current exception</param>
+ </member>
+ <member name="M:NUnit.Framework.SuccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+ <summary>
+ Serialization Constructor
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.InconclusiveException">
+ <summary>
+ Thrown when a test executes inconclusively.
+ </summary>
+
+ </member>
+ <member name="M:NUnit.Framework.InconclusiveException.#ctor(System.String)">
+ <param name="message">The error message that explains
+ the reason for the exception</param>
+ </member>
+ <member name="M:NUnit.Framework.InconclusiveException.#ctor(System.String,System.Exception)">
+ <param name="message">The error message that explains
+ the reason for the exception</param>
+ <param name="inner">The exception that caused the
+ current exception</param>
+ </member>
+ <member name="M:NUnit.Framework.InconclusiveException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+ <summary>
+ Serialization Constructor
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TestDelegate">
+ <summary>
+ Delegate used by tests that execute code and
+ capture any thrown exception.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Assert">
+ <summary>
+ The Assert class contains a collection of static methods that
+ implement the most common assertions used in NUnit.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Assert.#ctor">
+ <summary>
+ We don't actually want any instances of this object, but some people
+ like to inherit from it to add other static methods. Hence, the
+ protected constructor disallows any instances of this object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Equals(System.Object,System.Object)">
+ <summary>
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.ReferenceEquals(System.Object,System.Object)">
+ <summary>
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AssertDoublesAreEqual(System.Double,System.Double,System.Double,System.String,System.Object[])">
+ <summary>
+ Helper for Assert.AreEqual(double expected, double actual, ...)
+ allowing code generation to work consistently.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="delta">The maximum acceptable difference between the
+ the expected and the actual</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Pass(System.String,System.Object[])">
+ <summary>
+ Throws a <see cref="T:NUnit.Framework.SuccessException"/> with the message and arguments
+ that are passed in. This allows a test to be cut short, with a result
+ of success returned to NUnit.
+ </summary>
+ <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Pass(System.String)">
+ <summary>
+ Throws a <see cref="T:NUnit.Framework.SuccessException"/> with the message and arguments
+ that are passed in. This allows a test to be cut short, with a result
+ of success returned to NUnit.
+ </summary>
+ <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Pass">
+ <summary>
+ Throws a <see cref="T:NUnit.Framework.SuccessException"/> with the message and arguments
+ that are passed in. This allows a test to be cut short, with a result
+ of success returned to NUnit.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Fail(System.String,System.Object[])">
+ <summary>
+ Throws an <see cref="T:NUnit.Framework.AssertionException"/> with the message and arguments
+ that are passed in. This is used by the other Assert functions.
+ </summary>
+ <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Fail(System.String)">
+ <summary>
+ Throws an <see cref="T:NUnit.Framework.AssertionException"/> with the message that is
+ passed in. This is used by the other Assert functions.
+ </summary>
+ <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Fail">
+ <summary>
+ Throws an <see cref="T:NUnit.Framework.AssertionException"/>.
+ This is used by the other Assert functions.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Ignore(System.String,System.Object[])">
+ <summary>
+ Throws an <see cref="T:NUnit.Framework.IgnoreException"/> with the message and arguments
+ that are passed in. This causes the test to be reported as ignored.
+ </summary>
+ <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Ignore(System.String)">
+ <summary>
+ Throws an <see cref="T:NUnit.Framework.IgnoreException"/> with the message that is
+ passed in. This causes the test to be reported as ignored.
+ </summary>
+ <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Ignore">
+ <summary>
+ Throws an <see cref="T:NUnit.Framework.IgnoreException"/>.
+ This causes the test to be reported as ignored.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Inconclusive(System.String,System.Object[])">
+ <summary>
+ Throws an <see cref="T:NUnit.Framework.InconclusiveException"/> with the message and arguments
+ that are passed in. This causes the test to be reported as inconclusive.
+ </summary>
+ <param name="message">The message to initialize the <see cref="T:NUnit.Framework.InconclusiveException"/> with.</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Inconclusive(System.String)">
+ <summary>
+ Throws an <see cref="T:NUnit.Framework.InconclusiveException"/> with the message that is
+ passed in. This causes the test to be reported as inconclusive.
+ </summary>
+ <param name="message">The message to initialize the <see cref="T:NUnit.Framework.InconclusiveException"/> with.</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Inconclusive">
+ <summary>
+ Throws an <see cref="T:NUnit.Framework.InconclusiveException"/>.
+ This causes the test to be reported as Inconclusive.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expression">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expression">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expression">A Constraint expression to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expr">A Constraint expression to be applied</param>
+ <param name="del">An ActualValueDelegate returning the value to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expr">A Constraint expression to be applied</param>
+ <param name="del">An ActualValueDelegate returning the value to be tested</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="del">An ActualValueDelegate returning the value to be tested</param>
+ <param name="expr">A Constraint expression to be applied</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expression">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+ <summary>
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expression">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+ <summary>
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expression">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(System.Boolean,System.String,System.Object[])">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display if the condition is false</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(System.Boolean,System.String)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display if the condition is false</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(System.Boolean)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(NUnit.Framework.TestDelegate,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Asserts that the code represented by a delegate throws an exception
+ that satisfies the constraint provided.
+ </summary>
+ <param name="code">A TestDelegate to be executed</param>
+ <param name="constraint">A ThrowsConstraint used in the test</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Throws(NUnit.Framework.Constraints.IResolveConstraint,NUnit.Framework.TestDelegate,System.String,System.Object[])">
+ <summary>
+ Verifies that a delegate throws a particular exception when called.
+ </summary>
+ <param name="expression">A constraint to be satisfied by the exception</param>
+ <param name="code">A TestSnippet delegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Throws(NUnit.Framework.Constraints.IResolveConstraint,NUnit.Framework.TestDelegate,System.String)">
+ <summary>
+ Verifies that a delegate throws a particular exception when called.
+ </summary>
+ <param name="expression">A constraint to be satisfied by the exception</param>
+ <param name="code">A TestSnippet delegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Throws(NUnit.Framework.Constraints.IResolveConstraint,NUnit.Framework.TestDelegate)">
+ <summary>
+ Verifies that a delegate throws a particular exception when called.
+ </summary>
+ <param name="expression">A constraint to be satisfied by the exception</param>
+ <param name="code">A TestSnippet delegate</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Throws(System.Type,NUnit.Framework.TestDelegate,System.String,System.Object[])">
+ <summary>
+ Verifies that a delegate throws a particular exception when called.
+ </summary>
+ <param name="expectedExceptionType">The exception Type expected</param>
+ <param name="code">A TestSnippet delegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Throws(System.Type,NUnit.Framework.TestDelegate,System.String)">
+ <summary>
+ Verifies that a delegate throws a particular exception when called.
+ </summary>
+ <param name="expectedExceptionType">The exception Type expected</param>
+ <param name="code">A TestSnippet delegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Throws(System.Type,NUnit.Framework.TestDelegate)">
+ <summary>
+ Verifies that a delegate throws a particular exception when called.
+ </summary>
+ <param name="expectedExceptionType">The exception Type expected</param>
+ <param name="code">A TestSnippet delegate</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Throws``1(NUnit.Framework.TestDelegate,System.String,System.Object[])">
+ <summary>
+ Verifies that a delegate throws a particular exception when called.
+ </summary>
+ <typeparam name="T">Type of the expected exception</typeparam>
+ <param name="code">A TestSnippet delegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Throws``1(NUnit.Framework.TestDelegate,System.String)">
+ <summary>
+ Verifies that a delegate throws a particular exception when called.
+ </summary>
+ <typeparam name="T">Type of the expected exception</typeparam>
+ <param name="code">A TestSnippet delegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Throws``1(NUnit.Framework.TestDelegate)">
+ <summary>
+ Verifies that a delegate throws a particular exception when called.
+ </summary>
+ <typeparam name="T">Type of the expected exception</typeparam>
+ <param name="code">A TestSnippet delegate</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Catch(NUnit.Framework.TestDelegate,System.String,System.Object[])">
+ <summary>
+ Verifies that a delegate throws an exception when called
+ and returns it.
+ </summary>
+ <param name="code">A TestDelegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Catch(NUnit.Framework.TestDelegate,System.String)">
+ <summary>
+ Verifies that a delegate throws an exception when called
+ and returns it.
+ </summary>
+ <param name="code">A TestDelegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Catch(NUnit.Framework.TestDelegate)">
+ <summary>
+ Verifies that a delegate throws an exception when called
+ and returns it.
+ </summary>
+ <param name="code">A TestDelegate</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Catch(System.Type,NUnit.Framework.TestDelegate,System.String,System.Object[])">
+ <summary>
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+ </summary>
+ <param name="expectedExceptionType">The expected Exception Type</param>
+ <param name="code">A TestDelegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Catch(System.Type,NUnit.Framework.TestDelegate,System.String)">
+ <summary>
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+ </summary>
+ <param name="expectedExceptionType">The expected Exception Type</param>
+ <param name="code">A TestDelegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Catch(System.Type,NUnit.Framework.TestDelegate)">
+ <summary>
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+ </summary>
+ <param name="expectedExceptionType">The expected Exception Type</param>
+ <param name="code">A TestDelegate</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Catch``1(NUnit.Framework.TestDelegate,System.String,System.Object[])">
+ <summary>
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+ </summary>
+ <typeparam name="T">The expected Exception Type</typeparam>
+ <param name="code">A TestDelegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Catch``1(NUnit.Framework.TestDelegate,System.String)">
+ <summary>
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+ </summary>
+ <typeparam name="T">The expected Exception Type</typeparam>
+ <param name="code">A TestDelegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Catch``1(NUnit.Framework.TestDelegate)">
+ <summary>
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+ </summary>
+ <typeparam name="T">The expected Exception Type</typeparam>
+ <param name="code">A TestDelegate</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.DoesNotThrow(NUnit.Framework.TestDelegate,System.String,System.Object[])">
+ <summary>
+ Verifies that a delegate does not throw an exception
+ </summary>
+ <param name="code">A TestSnippet delegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.DoesNotThrow(NUnit.Framework.TestDelegate,System.String)">
+ <summary>
+ Verifies that a delegate does not throw an exception.
+ </summary>
+ <param name="code">A TestSnippet delegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.DoesNotThrow(NUnit.Framework.TestDelegate)">
+ <summary>
+ Verifies that a delegate does not throw an exception.
+ </summary>
+ <param name="code">A TestSnippet delegate</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.True(System.Boolean,System.String,System.Object[])">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.True(System.Boolean,System.String)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.True(System.Boolean)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsTrue(System.Boolean,System.String,System.Object[])">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsTrue(System.Boolean,System.String)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsTrue(System.Boolean)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.False(System.Boolean,System.String,System.Object[])">
+ <summary>
+ Asserts that a condition is false. If the condition is true the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.False(System.Boolean,System.String)">
+ <summary>
+ Asserts that a condition is false. If the condition is true the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.False(System.Boolean)">
+ <summary>
+ Asserts that a condition is false. If the condition is true the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsFalse(System.Boolean,System.String,System.Object[])">
+ <summary>
+ Asserts that a condition is false. If the condition is true the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsFalse(System.Boolean,System.String)">
+ <summary>
+ Asserts that a condition is false. If the condition is true the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsFalse(System.Boolean)">
+ <summary>
+ Asserts that a condition is false. If the condition is true the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.NotNull(System.Object,System.String,System.Object[])">
+ <summary>
+ Verifies that the object that is passed in is not equal to <code>null</code>
+ If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.NotNull(System.Object,System.String)">
+ <summary>
+ Verifies that the object that is passed in is not equal to <code>null</code>
+ If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.NotNull(System.Object)">
+ <summary>
+ Verifies that the object that is passed in is not equal to <code>null</code>
+ If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotNull(System.Object,System.String,System.Object[])">
+ <summary>
+ Verifies that the object that is passed in is not equal to <code>null</code>
+ If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotNull(System.Object,System.String)">
+ <summary>
+ Verifies that the object that is passed in is not equal to <code>null</code>
+ If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotNull(System.Object)">
+ <summary>
+ Verifies that the object that is passed in is not equal to <code>null</code>
+ If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Null(System.Object,System.String,System.Object[])">
+ <summary>
+ Verifies that the object that is passed in is equal to <code>null</code>
+ If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Null(System.Object,System.String)">
+ <summary>
+ Verifies that the object that is passed in is equal to <code>null</code>
+ If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Null(System.Object)">
+ <summary>
+ Verifies that the object that is passed in is equal to <code>null</code>
+ If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNull(System.Object,System.String,System.Object[])">
+ <summary>
+ Verifies that the object that is passed in is equal to <code>null</code>
+ If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNull(System.Object,System.String)">
+ <summary>
+ Verifies that the object that is passed in is equal to <code>null</code>
+ If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNull(System.Object)">
+ <summary>
+ Verifies that the object that is passed in is equal to <code>null</code>
+ If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNaN(System.Double,System.String,System.Object[])">
+ <summary>
+ Verifies that the double that is passed in is an <code>NaN</code> value.
+ If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="aDouble">The value that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNaN(System.Double,System.String)">
+ <summary>
+ Verifies that the double that is passed in is an <code>NaN</code> value.
+ If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="aDouble">The value that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNaN(System.Double)">
+ <summary>
+ Verifies that the double that is passed in is an <code>NaN</code> value.
+ If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="aDouble">The value that is to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNaN(System.Nullable{System.Double},System.String,System.Object[])">
+ <summary>
+ Verifies that the double that is passed in is an <code>NaN</code> value.
+ If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="aDouble">The value that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNaN(System.Nullable{System.Double},System.String)">
+ <summary>
+ Verifies that the double that is passed in is an <code>NaN</code> value.
+ If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="aDouble">The value that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNaN(System.Nullable{System.Double})">
+ <summary>
+ Verifies that the double that is passed in is an <code>NaN</code> value.
+ If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="aDouble">The value that is to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsEmpty(System.String,System.String,System.Object[])">
+ <summary>
+ Assert that a string is empty - that is equal to string.Empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsEmpty(System.String,System.String)">
+ <summary>
+ Assert that a string is empty - that is equal to string.Empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsEmpty(System.String)">
+ <summary>
+ Assert that a string is empty - that is equal to string.Empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsEmpty(System.Collections.ICollection,System.String,System.Object[])">
+ <summary>
+ Assert that an array, list or other collection is empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing ICollection</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsEmpty(System.Collections.ICollection,System.String)">
+ <summary>
+ Assert that an array, list or other collection is empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing ICollection</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsEmpty(System.Collections.ICollection)">
+ <summary>
+ Assert that an array, list or other collection is empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing ICollection</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.String,System.String,System.Object[])">
+ <summary>
+ Assert that a string is not empty - that is not equal to string.Empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.String,System.String)">
+ <summary>
+ Assert that a string is not empty - that is not equal to string.Empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.String)">
+ <summary>
+ Assert that a string is not empty - that is not equal to string.Empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.Collections.ICollection,System.String,System.Object[])">
+ <summary>
+ Assert that an array, list or other collection is not empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing ICollection</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.Collections.ICollection,System.String)">
+ <summary>
+ Assert that an array, list or other collection is not empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing ICollection</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.Collections.ICollection)">
+ <summary>
+ Assert that an array, list or other collection is not empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing ICollection</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNullOrEmpty(System.String,System.String,System.Object[])">
+ <summary>
+ Assert that a string is either null or equal to string.Empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNullOrEmpty(System.String,System.String)">
+ <summary>
+ Assert that a string is either null or equal to string.Empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNullOrEmpty(System.String)">
+ <summary>
+ Assert that a string is either null or equal to string.Empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotNullOrEmpty(System.String,System.String,System.Object[])">
+ <summary>
+ Assert that a string is not null or empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotNullOrEmpty(System.String,System.String)">
+ <summary>
+ Assert that a string is not null or empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotNullOrEmpty(System.String)">
+ <summary>
+ Assert that a string is not null or empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsAssignableFrom(System.Type,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object may be assigned a value of a given Type.
+ </summary>
+ <param name="expected">The expected Type.</param>
+ <param name="actual">The object under examination</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsAssignableFrom(System.Type,System.Object,System.String)">
+ <summary>
+ Asserts that an object may be assigned a value of a given Type.
+ </summary>
+ <param name="expected">The expected Type.</param>
+ <param name="actual">The object under examination</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsAssignableFrom(System.Type,System.Object)">
+ <summary>
+ Asserts that an object may be assigned a value of a given Type.
+ </summary>
+ <param name="expected">The expected Type.</param>
+ <param name="actual">The object under examination</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsAssignableFrom``1(System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object may be assigned a value of a given Type.
+ </summary>
+ <typeparam name="T">The expected Type.</typeparam>
+ <param name="actual">The object under examination</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsAssignableFrom``1(System.Object,System.String)">
+ <summary>
+ Asserts that an object may be assigned a value of a given Type.
+ </summary>
+ <typeparam name="T">The expected Type.</typeparam>
+ <param name="actual">The object under examination</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsAssignableFrom``1(System.Object)">
+ <summary>
+ Asserts that an object may be assigned a value of a given Type.
+ </summary>
+ <typeparam name="T">The expected Type.</typeparam>
+ <param name="actual">The object under examination</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom(System.Type,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object may not be assigned a value of a given Type.
+ </summary>
+ <param name="expected">The expected Type.</param>
+ <param name="actual">The object under examination</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom(System.Type,System.Object,System.String)">
+ <summary>
+ Asserts that an object may not be assigned a value of a given Type.
+ </summary>
+ <param name="expected">The expected Type.</param>
+ <param name="actual">The object under examination</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom(System.Type,System.Object)">
+ <summary>
+ Asserts that an object may not be assigned a value of a given Type.
+ </summary>
+ <param name="expected">The expected Type.</param>
+ <param name="actual">The object under examination</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom``1(System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object may not be assigned a value of a given Type.
+ </summary>
+ <typeparam name="T">The expected Type.</typeparam>
+ <param name="actual">The object under examination</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom``1(System.Object,System.String)">
+ <summary>
+ Asserts that an object may not be assigned a value of a given Type.
+ </summary>
+ <typeparam name="T">The expected Type.</typeparam>
+ <param name="actual">The object under examination</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom``1(System.Object)">
+ <summary>
+ Asserts that an object may not be assigned a value of a given Type.
+ </summary>
+ <typeparam name="T">The expected Type.</typeparam>
+ <param name="actual">The object under examination</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsInstanceOf(System.Type,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object is an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsInstanceOf(System.Type,System.Object,System.String)">
+ <summary>
+ Asserts that an object is an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsInstanceOf(System.Type,System.Object)">
+ <summary>
+ Asserts that an object is an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsInstanceOfType(System.Type,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object is an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsInstanceOfType(System.Type,System.Object,System.String)">
+ <summary>
+ Asserts that an object is an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsInstanceOfType(System.Type,System.Object)">
+ <summary>
+ Asserts that an object is an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsInstanceOf``1(System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object is an instance of a given type.
+ </summary>
+ <typeparam name="T">The expected Type</typeparam>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsInstanceOf``1(System.Object,System.String)">
+ <summary>
+ Asserts that an object is an instance of a given type.
+ </summary>
+ <typeparam name="T">The expected Type</typeparam>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsInstanceOf``1(System.Object)">
+ <summary>
+ Asserts that an object is an instance of a given type.
+ </summary>
+ <typeparam name="T">The expected Type</typeparam>
+ <param name="actual">The object being examined</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotInstanceOf(System.Type,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object is not an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotInstanceOf(System.Type,System.Object,System.String)">
+ <summary>
+ Asserts that an object is not an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotInstanceOf(System.Type,System.Object)">
+ <summary>
+ Asserts that an object is not an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotInstanceOfType(System.Type,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object is not an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotInstanceOfType(System.Type,System.Object,System.String)">
+ <summary>
+ Asserts that an object is not an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotInstanceOfType(System.Type,System.Object)">
+ <summary>
+ Asserts that an object is not an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotInstanceOf``1(System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object is not an instance of a given type.
+ </summary>
+ <typeparam name="T">The expected Type</typeparam>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotInstanceOf``1(System.Object,System.String)">
+ <summary>
+ Asserts that an object is not an instance of a given type.
+ </summary>
+ <typeparam name="T">The expected Type</typeparam>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotInstanceOf``1(System.Object)">
+ <summary>
+ Asserts that an object is not an instance of a given type.
+ </summary>
+ <typeparam name="T">The expected Type</typeparam>
+ <param name="actual">The object being examined</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Int32,System.Int32,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Int32,System.Int32,System.String)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Int32,System.Int32)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Int64,System.Int64,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Int64,System.Int64,System.String)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Int64,System.Int64)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt32,System.UInt32,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt32,System.UInt32,System.String)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt32,System.UInt32)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt64,System.UInt64,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt64,System.UInt64,System.String)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt64,System.UInt64)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Decimal,System.Decimal,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Decimal,System.Decimal,System.String)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Decimal,System.Decimal)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Double,System.Double,System.String,System.Object[])">
+ <summary>
+ Verifies that two doubles are equal considering a delta. If the
+ expected value is infinity then the delta value is ignored. If
+ they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is
+ thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="delta">The maximum acceptable difference between the
+ the expected and the actual</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Double,System.Double,System.String)">
+ <summary>
+ Verifies that two doubles are equal considering a delta. If the
+ expected value is infinity then the delta value is ignored. If
+ they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is
+ thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="delta">The maximum acceptable difference between the
+ the expected and the actual</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Double,System.Double)">
+ <summary>
+ Verifies that two doubles are equal considering a delta. If the
+ expected value is infinity then the delta value is ignored. If
+ they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is
+ thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="delta">The maximum acceptable difference between the
+ the expected and the actual</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Nullable{System.Double},System.Double,System.String,System.Object[])">
+ <summary>
+ Verifies that two doubles are equal considering a delta. If the
+ expected value is infinity then the delta value is ignored. If
+ they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is
+ thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="delta">The maximum acceptable difference between the
+ the expected and the actual</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Nullable{System.Double},System.Double,System.String)">
+ <summary>
+ Verifies that two doubles are equal considering a delta. If the
+ expected value is infinity then the delta value is ignored. If
+ they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is
+ thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="delta">The maximum acceptable difference between the
+ the expected and the actual</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Nullable{System.Double},System.Double)">
+ <summary>
+ Verifies that two doubles are equal considering a delta. If the
+ expected value is infinity then the delta value is ignored. If
+ they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is
+ thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="delta">The maximum acceptable difference between the
+ the expected and the actual</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Object,System.Object,System.String,System.Object[])">
+ <summary>
+ Verifies that two objects are equal. Two objects are considered
+ equal if both are null, or if both have the same value. NUnit
+ has special semantics for some object types.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The value that is expected</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Object,System.Object,System.String)">
+ <summary>
+ Verifies that two objects are equal. Two objects are considered
+ equal if both are null, or if both have the same value. NUnit
+ has special semantics for some object types.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The value that is expected</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Object,System.Object)">
+ <summary>
+ Verifies that two objects are equal. Two objects are considered
+ equal if both are null, or if both have the same value. NUnit
+ has special semantics for some object types.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The value that is expected</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int32,System.Int32,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int32,System.Int32,System.String)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int32,System.Int32)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int64,System.Int64,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int64,System.Int64,System.String)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int64,System.Int64)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt32,System.UInt32,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt32,System.UInt32,System.String)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt32,System.UInt32)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt64,System.UInt64,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt64,System.UInt64,System.String)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt64,System.UInt64)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Decimal,System.Decimal,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Decimal,System.Decimal,System.String)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Decimal,System.Decimal)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Single,System.Single,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Single,System.Single,System.String)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Single,System.Single)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Double,System.Double,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Double,System.Double,System.String)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Double,System.Double)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Object,System.Object,System.String,System.Object[])">
+ <summary>
+ Verifies that two objects are not equal. Two objects are considered
+ equal if both are null, or if both have the same value. NUnit
+ has special semantics for some object types.
+ If they are equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The value that is expected</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Object,System.Object,System.String)">
+ <summary>
+ Verifies that two objects are not equal. Two objects are considered
+ equal if both are null, or if both have the same value. NUnit
+ has special semantics for some object types.
+ If they are equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The value that is expected</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Object,System.Object)">
+ <summary>
+ Verifies that two objects are not equal. Two objects are considered
+ equal if both are null, or if both have the same value. NUnit
+ has special semantics for some object types.
+ If they are equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The value that is expected</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreSame(System.Object,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that two objects refer to the same object. If they
+ are not the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected object</param>
+ <param name="actual">The actual object</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreSame(System.Object,System.Object,System.String)">
+ <summary>
+ Asserts that two objects refer to the same object. If they
+ are not the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected object</param>
+ <param name="actual">The actual object</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreSame(System.Object,System.Object)">
+ <summary>
+ Asserts that two objects refer to the same object. If they
+ are not the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected object</param>
+ <param name="actual">The actual object</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotSame(System.Object,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that two objects do not refer to the same object. If they
+ are the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected object</param>
+ <param name="actual">The actual object</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotSame(System.Object,System.Object,System.String)">
+ <summary>
+ Asserts that two objects do not refer to the same object. If they
+ are the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected object</param>
+ <param name="actual">The actual object</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotSame(System.Object,System.Object)">
+ <summary>
+ Asserts that two objects do not refer to the same object. If they
+ are the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected object</param>
+ <param name="actual">The actual object</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Int32,System.Int32,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Int32,System.Int32,System.String)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Int32,System.Int32)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.UInt32,System.UInt32,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.UInt32,System.UInt32,System.String)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.UInt32,System.UInt32)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Int64,System.Int64,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Int64,System.Int64,System.String)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Int64,System.Int64)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.UInt64,System.UInt64,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.UInt64,System.UInt64,System.String)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.UInt64,System.UInt64)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Decimal,System.Decimal,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Decimal,System.Decimal,System.String)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Decimal,System.Decimal)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Double,System.Double,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Double,System.Double,System.String)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Double,System.Double)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Single,System.Single,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Single,System.Single,System.String)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Single,System.Single)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.IComparable,System.IComparable,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.IComparable,System.IComparable,System.String)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.IComparable,System.IComparable)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Int32,System.Int32,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Int32,System.Int32,System.String)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Int32,System.Int32)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.UInt32,System.UInt32,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.UInt32,System.UInt32,System.String)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.UInt32,System.UInt32)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Int64,System.Int64,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Int64,System.Int64,System.String)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Int64,System.Int64)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.UInt64,System.UInt64,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.UInt64,System.UInt64,System.String)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.UInt64,System.UInt64)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Decimal,System.Decimal,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Decimal,System.Decimal,System.String)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Decimal,System.Decimal)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Double,System.Double,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Double,System.Double,System.String)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Double,System.Double)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Single,System.Single,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Single,System.Single,System.String)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Single,System.Single)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.IComparable,System.IComparable,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.IComparable,System.IComparable,System.String)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.IComparable,System.IComparable)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int32,System.Int32,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int32,System.Int32,System.String)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int32,System.Int32)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt32,System.UInt32,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt32,System.UInt32,System.String)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt32,System.UInt32)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int64,System.Int64,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int64,System.Int64,System.String)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int64,System.Int64)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt64,System.UInt64,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt64,System.UInt64,System.String)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt64,System.UInt64)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Decimal,System.Decimal,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Decimal,System.Decimal,System.String)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Decimal,System.Decimal)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Double,System.Double,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Double,System.Double,System.String)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Double,System.Double)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Single,System.Single,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Single,System.Single,System.String)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Single,System.Single)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.IComparable,System.IComparable,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.IComparable,System.IComparable,System.String)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.IComparable,System.IComparable)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int32,System.Int32,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int32,System.Int32,System.String)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int32,System.Int32)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt32,System.UInt32,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt32,System.UInt32,System.String)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt32,System.UInt32)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int64,System.Int64,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int64,System.Int64,System.String)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int64,System.Int64)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt64,System.UInt64,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt64,System.UInt64,System.String)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt64,System.UInt64)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Decimal,System.Decimal,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Decimal,System.Decimal,System.String)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Decimal,System.Decimal)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Double,System.Double,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Double,System.Double,System.String)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Double,System.Double)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Single,System.Single,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Single,System.Single,System.String)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Single,System.Single)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.IComparable,System.IComparable,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.IComparable,System.IComparable,System.String)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.IComparable,System.IComparable)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Contains(System.Object,System.Collections.ICollection,System.String,System.Object[])">
+ <summary>
+ Asserts that an object is contained in a list.
+ </summary>
+ <param name="expected">The expected object</param>
+ <param name="actual">The list to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Contains(System.Object,System.Collections.ICollection,System.String)">
+ <summary>
+ Asserts that an object is contained in a list.
+ </summary>
+ <param name="expected">The expected object</param>
+ <param name="actual">The list to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Contains(System.Object,System.Collections.ICollection)">
+ <summary>
+ Asserts that an object is contained in a list.
+ </summary>
+ <param name="expected">The expected object</param>
+ <param name="actual">The list to be examined</param>
+ </member>
+ <member name="P:NUnit.Framework.Assert.Counter">
+ <summary>
+ Gets the number of assertions executed so far and
+ resets the counter to zero.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.RequiredAddinAttribute">
+ <summary>
+ RequiredAddinAttribute may be used to indicate the names of any addins
+ that must be present in order to run some or all of the tests in an
+ assembly. If the addin is not loaded, the entire assembly is marked
+ as NotRunnable.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.RequiredAddinAttribute.#ctor(System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:RequiredAddinAttribute"/> class.
+ </summary>
+ <param name="requiredAddin">The required addin.</param>
+ </member>
+ <member name="P:NUnit.Framework.RequiredAddinAttribute.RequiredAddin">
+ <summary>
+ Gets the name of required addin.
+ </summary>
+ <value>The required addin name.</value>
+ </member>
+ <member name="T:NUnit.Framework.CombinatorialAttribute">
+ <summary>
+ Marks a test to use a combinatorial join of any argument
+ data provided. Since this is the default, the attribute is
+ not needed.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.PropertyAttribute">
+ <summary>
+ PropertyAttribute is used to attach information to a test as a name/value pair..
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.String,System.String)">
+ <summary>
+ Construct a PropertyAttribute with a name and string value
+ </summary>
+ <param name="propertyName">The name of the property</param>
+ <param name="propertyValue">The property value</param>
+ </member>
+ <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.String,System.Int32)">
+ <summary>
+ Construct a PropertyAttribute with a name and int value
+ </summary>
+ <param name="propertyName">The name of the property</param>
+ <param name="propertyValue">The property value</param>
+ </member>
+ <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.String,System.Double)">
+ <summary>
+ Construct a PropertyAttribute with a name and double value
+ </summary>
+ <param name="propertyName">The name of the property</param>
+ <param name="propertyValue">The property value</param>
+ </member>
+ <member name="M:NUnit.Framework.PropertyAttribute.#ctor">
+ <summary>
+ Constructor for derived classes that set the
+ property dictionary directly.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.Object)">
+ <summary>
+ Constructor for use by derived classes that use the
+ name of the type as the property name. Derived classes
+ must ensure that the Type of the property value is
+ a standard type supported by the BCL. Any custom
+ types will cause a serialization Exception when
+ in the client.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.PropertyAttribute.Properties">
+ <summary>
+ Gets the property dictionary for this attribute
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.CombinatorialAttribute.#ctor">
+ <summary>
+ Default constructor
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.PairwiseAttribute">
+ <summary>
+ Marks a test to use a combinatorial join of any argument
+ data provided. Since this is the default, the attribute is
+ not needed.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.PairwiseAttribute.#ctor">
+ <summary>
+ Default constructor
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.SequentialAttribute">
+ <summary>
+ Marks a test to use a combinatorial join of any argument
+ data provided. Since this is the default, the attribute is
+ not needed.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.SequentialAttribute.#ctor">
+ <summary>
+ Default constructor
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TestAttribute">
+ <summary>
+ Adding this attribute to a method within a <seealso cref="T:NUnit.Framework.TestFixtureAttribute"/>
+ class makes the method callable from the NUnit test runner. There is a property
+ called Description which is optional which you can provide a more detailed test
+ description. This class cannot be inherited.
+ </summary>
+
+ <example>
+ [TestFixture]
+ public class Fixture
+ {
+ [Test]
+ public void MethodToTest()
+ {}
+
+ [Test(Description = "more detailed description")]
+ publc void TestDescriptionMethod()
+ {}
+ }
+ </example>
+
+ </member>
+ <member name="P:NUnit.Framework.TestAttribute.Description">
+ <summary>
+ Descriptive text for this test
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TestFixtureAttribute">
+ <example>
+ [TestFixture]
+ public class ExampleClass
+ {}
+ </example>
+ </member>
+ <member name="M:NUnit.Framework.TestFixtureAttribute.#ctor">
+ <summary>
+ Default constructor
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.TestFixtureAttribute.#ctor(System.Object[])">
+ <summary>
+ Construct with a object[] representing a set of arguments.
+ In .NET 2.0, the arguments may later be separated into
+ type arguments and constructor arguments.
+ </summary>
+ <param name="arguments"></param>
+ </member>
+ <member name="P:NUnit.Framework.TestFixtureAttribute.Description">
+ <summary>
+ Descriptive text for this fixture
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestFixtureAttribute.Arguments">
+ <summary>
+ The arguments originally provided to the attribute
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestFixtureAttribute.Ignore">
+ <summary>
+ Gets or sets a value indicating whether this <see cref="T:NUnit.Framework.TestFixtureAttribute"/> should be ignored.
+ </summary>
+ <value><c>true</c> if ignore; otherwise, <c>false</c>.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestFixtureAttribute.IgnoreReason">
+ <summary>
+ Gets or sets the ignore reason. May set Ignored as a side effect.
+ </summary>
+ <value>The ignore reason.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestFixtureAttribute.TypeArgs">
+ <summary>
+ Get or set the type arguments. If not set
+ explicitly, any leading arguments that are
+ Types are taken as type arguments.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.CollectionAssert">
+ <summary>
+ A set of Assert methods operationg on one or more collections
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.Equals(System.Object,System.Object)">
+ <summary>
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.ReferenceEquals(System.Object,System.Object)">
+ <summary>
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreInstancesOfType(System.Collections.IEnumerable,System.Type)">
+ <summary>
+ Asserts that all items contained in collection are of the type specified by expectedType.
+ </summary>
+ <param name="collection">IEnumerable containing objects to be considered</param>
+ <param name="expectedType">System.Type that all objects in collection must be instances of</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreInstancesOfType(System.Collections.IEnumerable,System.Type,System.String)">
+ <summary>
+ Asserts that all items contained in collection are of the type specified by expectedType.
+ </summary>
+ <param name="collection">IEnumerable containing objects to be considered</param>
+ <param name="expectedType">System.Type that all objects in collection must be instances of</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreInstancesOfType(System.Collections.IEnumerable,System.Type,System.String,System.Object[])">
+ <summary>
+ Asserts that all items contained in collection are of the type specified by expectedType.
+ </summary>
+ <param name="collection">IEnumerable containing objects to be considered</param>
+ <param name="expectedType">System.Type that all objects in collection must be instances of</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreNotNull(System.Collections.IEnumerable)">
+ <summary>
+ Asserts that all items contained in collection are not equal to null.
+ </summary>
+ <param name="collection">IEnumerable containing objects to be considered</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreNotNull(System.Collections.IEnumerable,System.String)">
+ <summary>
+ Asserts that all items contained in collection are not equal to null.
+ </summary>
+ <param name="collection">IEnumerable containing objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreNotNull(System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Asserts that all items contained in collection are not equal to null.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreUnique(System.Collections.IEnumerable)">
+ <summary>
+ Ensures that every object contained in collection exists within the collection
+ once and only once.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreUnique(System.Collections.IEnumerable,System.String)">
+ <summary>
+ Ensures that every object contained in collection exists within the collection
+ once and only once.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreUnique(System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Ensures that every object contained in collection exists within the collection
+ once and only once.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable)">
+ <summary>
+ Asserts that expected and actual are exactly equal. The collections must have the same count,
+ and contain the exact same objects in the same order.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer)">
+ <summary>
+ Asserts that expected and actual are exactly equal. The collections must have the same count,
+ and contain the exact same objects in the same order.
+ If comparer is not null then it will be used to compare the objects.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+ <summary>
+ Asserts that expected and actual are exactly equal. The collections must have the same count,
+ and contain the exact same objects in the same order.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer,System.String)">
+ <summary>
+ Asserts that expected and actual are exactly equal. The collections must have the same count,
+ and contain the exact same objects in the same order.
+ If comparer is not null then it will be used to compare the objects.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Asserts that expected and actual are exactly equal. The collections must have the same count,
+ and contain the exact same objects in the same order.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer,System.String,System.Object[])">
+ <summary>
+ Asserts that expected and actual are exactly equal. The collections must have the same count,
+ and contain the exact same objects in the same order.
+ If comparer is not null then it will be used to compare the objects.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable)">
+ <summary>
+ Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+ <summary>
+ Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable)">
+ <summary>
+ Asserts that expected and actual are not exactly equal.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer)">
+ <summary>
+ Asserts that expected and actual are not exactly equal.
+ If comparer is not null then it will be used to compare the objects.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+ <summary>
+ Asserts that expected and actual are not exactly equal.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer,System.String)">
+ <summary>
+ Asserts that expected and actual are not exactly equal.
+ If comparer is not null then it will be used to compare the objects.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Asserts that expected and actual are not exactly equal.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer,System.String,System.Object[])">
+ <summary>
+ Asserts that expected and actual are not exactly equal.
+ If comparer is not null then it will be used to compare the objects.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreNotEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable)">
+ <summary>
+ Asserts that expected and actual are not equivalent.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreNotEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+ <summary>
+ Asserts that expected and actual are not equivalent.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreNotEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Asserts that expected and actual are not equivalent.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.Contains(System.Collections.IEnumerable,System.Object)">
+ <summary>
+ Asserts that collection contains actual as an item.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ <param name="actual">Object to be found within collection</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.Contains(System.Collections.IEnumerable,System.Object,System.String)">
+ <summary>
+ Asserts that collection contains actual as an item.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ <param name="actual">Object to be found within collection</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.Contains(System.Collections.IEnumerable,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that collection contains actual as an item.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ <param name="actual">Object to be found within collection</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.DoesNotContain(System.Collections.IEnumerable,System.Object)">
+ <summary>
+ Asserts that collection does not contain actual as an item.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ <param name="actual">Object that cannot exist within collection</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.DoesNotContain(System.Collections.IEnumerable,System.Object,System.String)">
+ <summary>
+ Asserts that collection does not contain actual as an item.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ <param name="actual">Object that cannot exist within collection</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.DoesNotContain(System.Collections.IEnumerable,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that collection does not contain actual as an item.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ <param name="actual">Object that cannot exist within collection</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsNotSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable)">
+ <summary>
+ Asserts that superset is not a subject of subset.
+ </summary>
+ <param name="subset">The IEnumerable superset to be considered</param>
+ <param name="superset">The IEnumerable subset to be considered</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsNotSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+ <summary>
+ Asserts that superset is not a subject of subset.
+ </summary>
+ <param name="subset">The IEnumerable superset to be considered</param>
+ <param name="superset">The IEnumerable subset to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsNotSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Asserts that superset is not a subject of subset.
+ </summary>
+ <param name="subset">The IEnumerable superset to be considered</param>
+ <param name="superset">The IEnumerable subset to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable)">
+ <summary>
+ Asserts that superset is a subset of subset.
+ </summary>
+ <param name="subset">The IEnumerable superset to be considered</param>
+ <param name="superset">The IEnumerable subset to be considered</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+ <summary>
+ Asserts that superset is a subset of subset.
+ </summary>
+ <param name="subset">The IEnumerable superset to be considered</param>
+ <param name="superset">The IEnumerable subset to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Asserts that superset is a subset of subset.
+ </summary>
+ <param name="subset">The IEnumerable superset to be considered</param>
+ <param name="superset">The IEnumerable subset to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsEmpty(System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Assert that an array, list or other collection is empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ <param name="message">The message to be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsEmpty(System.Collections.IEnumerable,System.String)">
+ <summary>
+ Assert that an array, list or other collection is empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ <param name="message">The message to be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsEmpty(System.Collections.IEnumerable)">
+ <summary>
+ Assert that an array,list or other collection is empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsNotEmpty(System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Assert that an array, list or other collection is empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ <param name="message">The message to be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsNotEmpty(System.Collections.IEnumerable,System.String)">
+ <summary>
+ Assert that an array, list or other collection is empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ <param name="message">The message to be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsNotEmpty(System.Collections.IEnumerable)">
+ <summary>
+ Assert that an array,list or other collection is empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Assert that an array, list or other collection is ordered
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ <param name="message">The message to be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.String)">
+ <summary>
+ Assert that an array, list or other collection is ordered
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ <param name="message">The message to be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable)">
+ <summary>
+ Assert that an array, list or other collection is ordered
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.Collections.IComparer,System.String,System.Object[])">
+ <summary>
+ Assert that an array, list or other collection is ordered
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ <param name="comparer">A custom comparer to perform the comparisons</param>
+ <param name="message">The message to be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.Collections.IComparer,System.String)">
+ <summary>
+ Assert that an array, list or other collection is ordered
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ <param name="comparer">A custom comparer to perform the comparisons</param>
+ <param name="message">The message to be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.Collections.IComparer)">
+ <summary>
+ Assert that an array, list or other collection is ordered
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ <param name="comparer">A custom comparer to perform the comparisons</param>
+ </member>
+ <member name="T:NUnit.Framework.ParameterDataAttribute">
+ <summary>
+ Abstract base class for attributes that apply to parameters
+ and supply data for the parameter.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.ParameterDataAttribute.GetData(System.Reflection.ParameterInfo)">
+ <summary>
+ Gets the data to be provided to the specified parameter
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.ValuesAttribute">
+ <summary>
+ ValuesAttribute is used to provide literal arguments for
+ an individual parameter of a test.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.ValuesAttribute.data">
+ <summary>
+ The collection of data to be returned. Must
+ be set by any derived attribute classes.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object)">
+ <summary>
+ Construct with one argument
+ </summary>
+ <param name="arg1"></param>
+ </member>
+ <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object,System.Object)">
+ <summary>
+ Construct with two arguments
+ </summary>
+ <param name="arg1"></param>
+ <param name="arg2"></param>
+ </member>
+ <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object,System.Object,System.Object)">
+ <summary>
+ Construct with three arguments
+ </summary>
+ <param name="arg1"></param>
+ <param name="arg2"></param>
+ <param name="arg3"></param>
+ </member>
+ <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object[])">
+ <summary>
+ Construct with an array of arguments
+ </summary>
+ <param name="args"></param>
+ </member>
+ <member name="M:NUnit.Framework.ValuesAttribute.GetData(System.Reflection.ParameterInfo)">
+ <summary>
+ Get the collection of values to be used as arguments
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.AssertionException">
+ <summary>
+ Thrown when an assertion failed.
+ </summary>
+
+ </member>
+ <member name="M:NUnit.Framework.AssertionException.#ctor(System.String)">
+ <param name="message">The error message that explains
+ the reason for the exception</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionException.#ctor(System.String,System.Exception)">
+ <param name="message">The error message that explains
+ the reason for the exception</param>
+ <param name="inner">The exception that caused the
+ current exception</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+ <summary>
+ Serialization Constructor
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TimeoutAttribute">
+ <summary>
+ WUsed on a method, marks the test with a timeout value in milliseconds.
+ The test will be run in a separate thread and is cancelled if the timeout
+ is exceeded. Used on a method or assembly, sets the default timeout
+ for all contained test methods.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.TimeoutAttribute.#ctor(System.Int32)">
+ <summary>
+ Construct a TimeoutAttribute given a time in milliseconds
+ </summary>
+ <param name="timeout">The timeout value in milliseconds</param>
+ </member>
+ <member name="T:NUnit.Framework.RequiresSTAAttribute">
+ <summary>
+ Marks a test that must run in the STA, causing it
+ to run in a separate thread if necessary.
+
+ On methods, you may also use STAThreadAttribute
+ to serve the same purpose.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.RequiresSTAAttribute.#ctor">
+ <summary>
+ Construct a RequiresSTAAttribute
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.RequiresMTAAttribute">
+ <summary>
+ Marks a test that must run in the MTA, causing it
+ to run in a separate thread if necessary.
+
+ On methods, you may also use MTAThreadAttribute
+ to serve the same purpose.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.RequiresMTAAttribute.#ctor">
+ <summary>
+ Construct a RequiresMTAAttribute
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.RequiresThreadAttribute">
+ <summary>
+ Marks a test that must run on a separate thread.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.RequiresThreadAttribute.#ctor">
+ <summary>
+ Construct a RequiresThreadAttribute
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.RequiresThreadAttribute.#ctor(System.Threading.ApartmentState)">
+ <summary>
+ Construct a RequiresThreadAttribute, specifying the apartment
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.AssertionHelper">
+ <summary>
+ AssertionHelper is an optional base class for user tests,
+ allowing the use of shorter names for constraints and
+ asserts and avoiding conflict with the definition of
+ <see cref="T:NUnit.Framework.Is"/>, from which it inherits much of its
+ behavior, in certain mock object frameworks.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Object,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure. Works
+ identically to <see cref="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint)"/>
+ </summary>
+ <param name="constraint">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure. Works
+ identically to <see cref="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String)"/>
+ </summary>
+ <param name="constraint">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure. Works
+ identically to <see cref="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])"/>
+ </summary>
+ <param name="constraint">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expr">A Constraint expression to be applied</param>
+ <param name="del">An ActualValueDelegate returning the value to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expr">A Constraint expression to be applied</param>
+ <param name="del">An ActualValueDelegate returning the value to be tested</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="del">An ActualValueDelegate returning the value to be tested</param>
+ <param name="expr">A Constraint expression to be applied</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect``1(``0@,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="constraint">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+ <summary>
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="constraint">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+ <summary>
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expression">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Boolean,System.String,System.Object[])">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>. Works Identically to
+ <see cref="M:NUnit.Framework.Assert.That(System.Boolean,System.String,System.Object[])"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display if the condition is false</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Boolean,System.String)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>. Works Identically to
+ <see cref="M:NUnit.Framework.Assert.That(System.Boolean,System.String)"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display if the condition is false</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Boolean)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>. Works Identically to <see cref="M:NUnit.Framework.Assert.That(System.Boolean)"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(NUnit.Framework.TestDelegate,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Asserts that the code represented by a delegate throws an exception
+ that satisfies the constraint provided.
+ </summary>
+ <param name="code">A TestDelegate to be executed</param>
+ <param name="constraint">A ThrowsConstraint used in the test</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Map(System.Collections.ICollection)">
+ <summary>
+ Returns a ListMapper based on a collection.
+ </summary>
+ <param name="original">The original collection</param>
+ <returns></returns>
+ </member>
+ <member name="T:NUnit.Framework.CategoryAttribute">
+ <summary>
+ Attribute used to apply a category to a test
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.CategoryAttribute.categoryName">
+ <summary>
+ The name of the category
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.CategoryAttribute.#ctor(System.String)">
+ <summary>
+ Construct attribute for a given category
+ </summary>
+ <param name="name">The name of the category</param>
+ </member>
+ <member name="M:NUnit.Framework.CategoryAttribute.#ctor">
+ <summary>
+ Protected constructor uses the Type name as the name
+ of the category.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.CategoryAttribute.Name">
+ <summary>
+ The name of the category
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.RandomAttribute">
+ <summary>
+ RandomAttribute is used to supply a set of random values
+ to a single parameter of a parameterized test.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.RandomAttribute.#ctor(System.Int32)">
+ <summary>
+ Construct a set of doubles from 0.0 to 1.0,
+ specifying only the count.
+ </summary>
+ <param name="count"></param>
+ </member>
+ <member name="M:NUnit.Framework.RandomAttribute.#ctor(System.Double,System.Double,System.Int32)">
+ <summary>
+ Construct a set of doubles from min to max
+ </summary>
+ <param name="min"></param>
+ <param name="max"></param>
+ <param name="count"></param>
+ </member>
+ <member name="M:NUnit.Framework.RandomAttribute.#ctor(System.Int32,System.Int32,System.Int32)">
+ <summary>
+ Construct a set of ints from min to max
+ </summary>
+ <param name="min"></param>
+ <param name="max"></param>
+ <param name="count"></param>
+ </member>
+ <member name="M:NUnit.Framework.RandomAttribute.GetData(System.Reflection.ParameterInfo)">
+ <summary>
+ Get the collection of values to be used as arguments
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.DescriptionAttribute">
+ <summary>
+ Attribute used to provide descriptive text about a
+ test case or fixture.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.DescriptionAttribute.#ctor(System.String)">
+ <summary>
+ Construct the attribute
+ </summary>
+ <param name="description">Text describing the test</param>
+ </member>
+ <member name="P:NUnit.Framework.DescriptionAttribute.Description">
+ <summary>
+ Gets the test description
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.ExplicitAttribute">
+ <summary>
+ ExplicitAttribute marks a test or test fixture so that it will
+ only be run if explicitly executed from the gui or command line
+ or if it is included by use of a filter. The test will not be
+ run simply because an enclosing suite is run.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.ExplicitAttribute.#ctor">
+ <summary>
+ Default constructor
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.ExplicitAttribute.#ctor(System.String)">
+ <summary>
+ Constructor with a reason
+ </summary>
+ <param name="reason">The reason test is marked explicit</param>
+ </member>
+ <member name="P:NUnit.Framework.ExplicitAttribute.Reason">
+ <summary>
+ The reason test is marked explicit
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Assume">
+ <summary>
+ Provides static methods to express the assumptions
+ that must be met for a test to give a meaningful
+ result. If an assumption is not met, the test
+ should produce an inconclusive result.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Assume.Equals(System.Object,System.Object)">
+ <summary>
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.ReferenceEquals(System.Object,System.Object)">
+ <summary>
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+ </summary>
+ <param name="expression">A Constraint expression to be applied</param>
+ <param name="actual">The actual value to test</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+ </summary>
+ <param name="expression">A Constraint expression to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+ </summary>
+ <param name="expression">A Constraint expression to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+ </summary>
+ <param name="expr">A Constraint expression to be applied</param>
+ <param name="del">An ActualValueDelegate returning the value to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+ </summary>
+ <param name="expr">A Constraint expression to be applied</param>
+ <param name="del">An ActualValueDelegate returning the value to be tested</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+ </summary>
+ <param name="del">An ActualValueDelegate returning the value to be tested</param>
+ <param name="expr">A Constraint expression to be applied</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+ </summary>
+ <param name="expression">A Constraint expression to be applied</param>
+ <param name="actual">The actual value to test</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+ <summary>
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+ </summary>
+ <param name="expression">A Constraint expression to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+ <summary>
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+ </summary>
+ <param name="expression">A Constraint expression to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(System.Boolean,System.String,System.Object[])">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.InconclusiveException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display if the condition is false</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(System.Boolean,System.String)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.InconclusiveException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display if the condition is false</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(System.Boolean)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the
+ method throws an <see cref="T:NUnit.Framework.InconclusiveException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(NUnit.Framework.TestDelegate,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Asserts that the code represented by a delegate throws an exception
+ that satisfies the constraint provided.
+ </summary>
+ <param name="code">A TestDelegate to be executed</param>
+ <param name="constraint">A ThrowsConstraint used in the test</param>
+ </member>
+ <member name="T:NUnit.Framework.GlobalSettings">
+ <summary>
+ GlobalSettings is a place for setting default values used
+ by the framework in performing asserts.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.GlobalSettings.DefaultFloatingPointTolerance">
+ <summary>
+ Default tolerance for floating point equality
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Is">
+ <summary>
+ Helper class with properties and methods that supply
+ a number of constraints used in Asserts.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.EqualTo(System.Object)">
+ <summary>
+ Returns a constraint that tests two items for equality
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.SameAs(System.Object)">
+ <summary>
+ Returns a constraint that tests that two references are the same object
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.GreaterThan(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is greater than the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.GreaterThanOrEqualTo(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.AtLeast(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.LessThan(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is less than the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.LessThanOrEqualTo(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.AtMost(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.TypeOf(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.TypeOf``1">
+ <summary>
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.InstanceOf(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.InstanceOf``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.InstanceOfType(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.InstanceOfType``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.AssignableFrom(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.AssignableFrom``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.AssignableTo(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.AssignableTo``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.EquivalentTo(System.Collections.IEnumerable)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is a collection containing the same elements as the
+ collection supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.SubsetOf(System.Collections.IEnumerable)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is a subset of the collection supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.StringContaining(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.StringStarting(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.StringEnding(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.StringMatching(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.SamePath(System.String)">
+ <summary>
+ Returns a constraint that tests whether the path provided
+ is the same as an expected path after canonicalization.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.SamePathOrUnder(System.String)">
+ <summary>
+ Returns a constraint that tests whether the path provided
+ is the same path or under an expected path after canonicalization.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.InRange(System.IComparable,System.IComparable)">
+ <summary>
+ Returns a constraint that tests whether the actual value falls
+ within a specified range.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.Not">
+ <summary>
+ Returns a ConstraintExpression that negates any
+ following constraint.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.All">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.Null">
+ <summary>
+ Returns a constraint that tests for null
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.True">
+ <summary>
+ Returns a constraint that tests for True
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.False">
+ <summary>
+ Returns a constraint that tests for False
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.NaN">
+ <summary>
+ Returns a constraint that tests for NaN
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.Empty">
+ <summary>
+ Returns a constraint that tests for empty
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.Unique">
+ <summary>
+ Returns a constraint that tests whether a collection
+ contains all unique items.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.BinarySerializable">
+ <summary>
+ Returns a constraint that tests whether an object graph is serializable in binary format.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.XmlSerializable">
+ <summary>
+ Returns a constraint that tests whether an object graph is serializable in xml format.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.Ordered">
+ <summary>
+ Returns a constraint that tests whether a collection is ordered
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.IExpectException">
+ <summary>
+ Interface implemented by a user fixture in order to
+ validate any expected exceptions. It is only called
+ for test methods marked with the ExpectedException
+ attribute.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.IExpectException.HandleException(System.Exception)">
+ <summary>
+ Method to handle an expected exception
+ </summary>
+ <param name="ex">The exception to be handled</param>
+ </member>
+ <member name="T:NUnit.Framework.IgnoreAttribute">
+ <summary>
+ Attribute used to mark a test that is to be ignored.
+ Ignored tests result in a warning message when the
+ tests are run.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.IgnoreAttribute.#ctor">
+ <summary>
+ Constructs the attribute without giving a reason
+ for ignoring the test.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.IgnoreAttribute.#ctor(System.String)">
+ <summary>
+ Constructs the attribute giving a reason for ignoring the test
+ </summary>
+ <param name="reason">The reason for ignoring the test</param>
+ </member>
+ <member name="P:NUnit.Framework.IgnoreAttribute.Reason">
+ <summary>
+ The reason for ignoring a test
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.IgnoreException">
+ <summary>
+ Thrown when an assertion failed.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.IgnoreException.#ctor(System.String)">
+ <param name="message"></param>
+ </member>
+ <member name="M:NUnit.Framework.IgnoreException.#ctor(System.String,System.Exception)">
+ <param name="message">The error message that explains
+ the reason for the exception</param>
+ <param name="inner">The exception that caused the
+ current exception</param>
+ </member>
+ <member name="M:NUnit.Framework.IgnoreException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+ <summary>
+ Serialization Constructor
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.IncludeExcludeAttribute">
+ <summary>
+ Abstract base for Attributes that are used to include tests
+ in the test run based on environmental settings.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.IncludeExcludeAttribute.#ctor">
+ <summary>
+ Constructor with no included items specified, for use
+ with named property syntax.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.IncludeExcludeAttribute.#ctor(System.String)">
+ <summary>
+ Constructor taking one or more included items
+ </summary>
+ <param name="include">Comma-delimited list of included items</param>
+ </member>
+ <member name="P:NUnit.Framework.IncludeExcludeAttribute.Include">
+ <summary>
+ Name of the item that is needed in order for
+ a test to run. Multiple itemss may be given,
+ separated by a comma.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.IncludeExcludeAttribute.Exclude">
+ <summary>
+ Name of the item to be excluded. Multiple items
+ may be given, separated by a comma.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.IncludeExcludeAttribute.Reason">
+ <summary>
+ The reason for including or excluding the test
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.PlatformAttribute">
+ <summary>
+ PlatformAttribute is used to mark a test fixture or an
+ individual method as applying to a particular platform only.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.PlatformAttribute.#ctor">
+ <summary>
+ Constructor with no platforms specified, for use
+ with named property syntax.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.PlatformAttribute.#ctor(System.String)">
+ <summary>
+ Constructor taking one or more platforms
+ </summary>
+ <param name="platforms">Comma-deliminted list of platforms</param>
+ </member>
+ <member name="T:NUnit.Framework.CultureAttribute">
+ <summary>
+ CultureAttribute is used to mark a test fixture or an
+ individual method as applying to a particular Culture only.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.CultureAttribute.#ctor">
+ <summary>
+ Constructor with no cultures specified, for use
+ with named property syntax.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.CultureAttribute.#ctor(System.String)">
+ <summary>
+ Constructor taking one or more cultures
+ </summary>
+ <param name="cultures">Comma-deliminted list of cultures</param>
+ </member>
+ <member name="T:NUnit.Framework.RangeAttribute">
+ <summary>
+ RangeAttribute is used to supply a range of values to an
+ individual parameter of a parameterized test.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Int32,System.Int32)">
+ <summary>
+ Construct a range of ints using default step of 1
+ </summary>
+ <param name="from"></param>
+ <param name="to"></param>
+ </member>
+ <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Int32,System.Int32,System.Int32)">
+ <summary>
+ Construct a range of ints specifying the step size
+ </summary>
+ <param name="from"></param>
+ <param name="to"></param>
+ <param name="step"></param>
+ </member>
+ <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Int64,System.Int64,System.Int64)">
+ <summary>
+ Construct a range of longs
+ </summary>
+ <param name="from"></param>
+ <param name="to"></param>
+ <param name="step"></param>
+ </member>
+ <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Double,System.Double,System.Double)">
+ <summary>
+ Construct a range of doubles
+ </summary>
+ <param name="from"></param>
+ <param name="to"></param>
+ <param name="step"></param>
+ </member>
+ <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Single,System.Single,System.Single)">
+ <summary>
+ Construct a range of floats
+ </summary>
+ <param name="from"></param>
+ <param name="to"></param>
+ <param name="step"></param>
+ </member>
+ <member name="T:NUnit.Framework.SetCultureAttribute">
+ <summary>
+ Summary description for SetCultureAttribute.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.SetCultureAttribute.#ctor(System.String)">
+ <summary>
+ Construct given the name of a culture
+ </summary>
+ <param name="culture"></param>
+ </member>
+ <member name="T:NUnit.Framework.ValueSourceAttribute">
+ <summary>
+ ValueSourceAttribute indicates the source to be used to
+ provide data for one parameter of a test method.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.ValueSourceAttribute.#ctor(System.String)">
+ <summary>
+ Construct with the name of the factory - for use with languages
+ that don't support params arrays.
+ </summary>
+ <param name="sourceName">The name of the data source to be used</param>
+ </member>
+ <member name="M:NUnit.Framework.ValueSourceAttribute.#ctor(System.Type,System.String)">
+ <summary>
+ Construct with a Type and name - for use with languages
+ that don't support params arrays.
+ </summary>
+ <param name="sourceType">The Type that will provide data</param>
+ <param name="sourceName">The name of the method, property or field that will provide data</param>
+ </member>
+ <member name="P:NUnit.Framework.ValueSourceAttribute.SourceName">
+ <summary>
+ The name of a the method, property or fiend to be used as a source
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ValueSourceAttribute.SourceType">
+ <summary>
+ A Type to be used as a source
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TextMessageWriter">
+ <summary>
+ TextMessageWriter writes constraint descriptions and messages
+ in displayable form as a text stream. It tailors the display
+ of individual message components to form the standard message
+ format of NUnit assertion failure messages.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TextMessageWriter.Pfx_Expected">
+ <summary>
+ Prefix used for the expected value line of a message
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TextMessageWriter.Pfx_Actual">
+ <summary>
+ Prefix used for the actual value line of a message
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TextMessageWriter.PrefixLength">
+ <summary>
+ Length of a message prefix
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.#ctor">
+ <summary>
+ Construct a TextMessageWriter
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.#ctor(System.String,System.Object[])">
+ <summary>
+ Construct a TextMessageWriter, specifying a user message
+ and optional formatting arguments.
+ </summary>
+ <param name="userMessage"></param>
+ <param name="args"></param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteMessageLine(System.Int32,System.String,System.Object[])">
+ <summary>
+ Method to write single line message with optional args, usually
+ written to precede the general failure message, at a givel
+ indentation level.
+ </summary>
+ <param name="level">The indentation level of the message</param>
+ <param name="message">The message to be written</param>
+ <param name="args">Any arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.DisplayDifferences(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Display Expected and Actual lines for a constraint. This
+ is called by MessageWriter's default implementation of
+ WriteMessageTo and provides the generic two-line display.
+ </summary>
+ <param name="constraint">The constraint that failed</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.DisplayDifferences(System.Object,System.Object)">
+ <summary>
+ Display Expected and Actual lines for given values. This
+ method may be called by constraints that need more control over
+ the display of actual and expected values than is provided
+ by the default implementation.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value causing the failure</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.DisplayDifferences(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance)">
+ <summary>
+ Display Expected and Actual lines for given values, including
+ a tolerance value on the expected line.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value causing the failure</param>
+ <param name="tolerance">The tolerance within which the test was made</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.DisplayStringDifferences(System.String,System.String,System.Int32,System.Boolean,System.Boolean)">
+ <summary>
+ Display the expected and actual string values on separate lines.
+ If the mismatch parameter is >=0, an additional line is displayed
+ line containing a caret that points to the mismatch point.
+ </summary>
+ <param name="expected">The expected string value</param>
+ <param name="actual">The actual string value</param>
+ <param name="mismatch">The point at which the strings don't match or -1</param>
+ <param name="ignoreCase">If true, case is ignored in string comparisons</param>
+ <param name="clipping">If true, clip the strings to fit the max line length</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteConnector(System.String)">
+ <summary>
+ Writes the text for a connector.
+ </summary>
+ <param name="connector">The connector.</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WritePredicate(System.String)">
+ <summary>
+ Writes the text for a predicate.
+ </summary>
+ <param name="predicate">The predicate.</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteModifier(System.String)">
+ <summary>
+ Write the text for a modifier.
+ </summary>
+ <param name="modifier">The modifier.</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteExpectedValue(System.Object)">
+ <summary>
+ Writes the text for an expected value.
+ </summary>
+ <param name="expected">The expected value.</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteActualValue(System.Object)">
+ <summary>
+ Writes the text for an actual value.
+ </summary>
+ <param name="actual">The actual value.</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteValue(System.Object)">
+ <summary>
+ Writes the text for a generalized value.
+ </summary>
+ <param name="val">The value.</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteCollectionElements(System.Collections.ICollection,System.Int32,System.Int32)">
+ <summary>
+ Writes the text for a collection value,
+ starting at a particular point, to a max length
+ </summary>
+ <param name="collection">The collection containing elements to write.</param>
+ <param name="start">The starting point of the elements to write</param>
+ <param name="max">The maximum number of elements to write</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteExpectedLine(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Write the generic 'Expected' line for a constraint
+ </summary>
+ <param name="constraint">The constraint that failed</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteExpectedLine(System.Object)">
+ <summary>
+ Write the generic 'Expected' line for a given value
+ </summary>
+ <param name="expected">The expected value</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteExpectedLine(System.Object,NUnit.Framework.Constraints.Tolerance)">
+ <summary>
+ Write the generic 'Expected' line for a given value
+ and tolerance.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="tolerance">The tolerance within which the test was made</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteActualLine(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Write the generic 'Actual' line for a constraint
+ </summary>
+ <param name="constraint">The constraint for which the actual value is to be written</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteActualLine(System.Object)">
+ <summary>
+ Write the generic 'Actual' line for a given value
+ </summary>
+ <param name="actual">The actual value causing a failure</param>
+ </member>
+ <member name="P:NUnit.Framework.TextMessageWriter.MaxLineLength">
+ <summary>
+ Gets or sets the maximum line length for this writer
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.StringAssert">
+ <summary>
+ Basic Asserts on strings.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.Equals(System.Object,System.Object)">
+ <summary>
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.ReferenceEquals(System.Object,System.Object)">
+ <summary>
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.Contains(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that a string is found within another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.Contains(System.String,System.String,System.String)">
+ <summary>
+ Asserts that a string is found within another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.Contains(System.String,System.String)">
+ <summary>
+ Asserts that a string is found within another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotContain(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that a string is not found within another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotContain(System.String,System.String,System.String)">
+ <summary>
+ Asserts that a string is found within another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotContain(System.String,System.String)">
+ <summary>
+ Asserts that a string is found within another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.StartsWith(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that a string starts with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.StartsWith(System.String,System.String,System.String)">
+ <summary>
+ Asserts that a string starts with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.StartsWith(System.String,System.String)">
+ <summary>
+ Asserts that a string starts with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotStartWith(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that a string does not start with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotStartWith(System.String,System.String,System.String)">
+ <summary>
+ Asserts that a string does not start with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotStartWith(System.String,System.String)">
+ <summary>
+ Asserts that a string does not start with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.EndsWith(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that a string ends with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.EndsWith(System.String,System.String,System.String)">
+ <summary>
+ Asserts that a string ends with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.EndsWith(System.String,System.String)">
+ <summary>
+ Asserts that a string ends with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotEndWith(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that a string does not end with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotEndWith(System.String,System.String,System.String)">
+ <summary>
+ Asserts that a string does not end with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotEndWith(System.String,System.String)">
+ <summary>
+ Asserts that a string does not end with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.AreEqualIgnoringCase(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that two strings are equal, without regard to case.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The actual string</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.AreEqualIgnoringCase(System.String,System.String,System.String)">
+ <summary>
+ Asserts that two strings are equal, without regard to case.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The actual string</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.AreEqualIgnoringCase(System.String,System.String)">
+ <summary>
+ Asserts that two strings are equal, without regard to case.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The actual string</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.AreNotEqualIgnoringCase(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that two strings are not equal, without regard to case.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The actual string</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.AreNotEqualIgnoringCase(System.String,System.String,System.String)">
+ <summary>
+ Asserts that two strings are Notequal, without regard to case.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The actual string</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.AreNotEqualIgnoringCase(System.String,System.String)">
+ <summary>
+ Asserts that two strings are not equal, without regard to case.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The actual string</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.IsMatch(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that a string matches an expected regular expression pattern.
+ </summary>
+ <param name="pattern">The regex pattern to be matched</param>
+ <param name="actual">The actual string</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.IsMatch(System.String,System.String,System.String)">
+ <summary>
+ Asserts that a string matches an expected regular expression pattern.
+ </summary>
+ <param name="pattern">The regex pattern to be matched</param>
+ <param name="actual">The actual string</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.IsMatch(System.String,System.String)">
+ <summary>
+ Asserts that a string matches an expected regular expression pattern.
+ </summary>
+ <param name="pattern">The regex pattern to be matched</param>
+ <param name="actual">The actual string</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotMatch(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that a string does not match an expected regular expression pattern.
+ </summary>
+ <param name="pattern">The regex pattern to be used</param>
+ <param name="actual">The actual string</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotMatch(System.String,System.String,System.String)">
+ <summary>
+ Asserts that a string does not match an expected regular expression pattern.
+ </summary>
+ <param name="pattern">The regex pattern to be used</param>
+ <param name="actual">The actual string</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotMatch(System.String,System.String)">
+ <summary>
+ Asserts that a string does not match an expected regular expression pattern.
+ </summary>
+ <param name="pattern">The regex pattern to be used</param>
+ <param name="actual">The actual string</param>
+ </member>
+ <member name="T:NUnit.Framework.SetUpAttribute">
+ <summary>
+ Attribute used to mark a class that contains one-time SetUp
+ and/or TearDown methods that apply to all the tests in a
+ namespace or an assembly.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.SetUpFixtureAttribute">
+ <summary>
+ SetUpFixtureAttribute is used to identify a SetUpFixture
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.RepeatAttribute">
+ <summary>
+ RepeatAttribute may be applied to test case in order
+ to run it multiple times.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.RepeatAttribute.#ctor(System.Int32)">
+ <summary>
+ Construct a RepeatAttribute
+ </summary>
+ <param name="count">The number of times to run the test</param>
+ </member>
+ <member name="T:NUnit.Framework.SuiteAttribute">
+ <summary>
+ Attribute used to mark a static (shared in VB) property
+ that returns a list of tests.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TearDownAttribute">
+ <summary>
+ Attribute used to identify a method that is called
+ immediately after each test is run. The method is
+ guaranteed to be called, even if an exception is thrown.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Iz">
+ <summary>
+ The Iz class is a synonym for Is intended for use in VB,
+ which regards Is as a keyword.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Throws">
+ <summary>
+ Helper class with properties and methods that supply
+ constraints that operate on exceptions.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Throws.TypeOf(System.Type)">
+ <summary>
+ Creates a constraint specifying the exact type of exception expected
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Throws.TypeOf``1">
+ <summary>
+ Creates a constraint specifying the exact type of exception expected
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Throws.InstanceOf(System.Type)">
+ <summary>
+ Creates a constraint specifying the type of exception expected
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Throws.InstanceOf``1">
+ <summary>
+ Creates a constraint specifying the type of exception expected
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Throws.Exception">
+ <summary>
+ Creates a constraint specifying an expected exception
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Throws.InnerException">
+ <summary>
+ Creates a constraint specifying an exception with a given InnerException
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Throws.TargetInvocationException">
+ <summary>
+ Creates a constraint specifying an expected TargetInvocationException
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Throws.ArgumentException">
+ <summary>
+ Creates a constraint specifying an expected TargetInvocationException
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Throws.InvalidOperationException">
+ <summary>
+ Creates a constraint specifying an expected TargetInvocationException
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Throws.Nothing">
+ <summary>
+ Creates a constraint specifying that no exception is thrown
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.ListMapper">
+ <summary>
+ ListMapper is used to transform a collection used as an actual argument
+ producing another collection to be used in the assertion.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.ListMapper.#ctor(System.Collections.ICollection)">
+ <summary>
+ Construct a ListMapper based on a collection
+ </summary>
+ <param name="original">The collection to be transformed</param>
+ </member>
+ <member name="M:NUnit.Framework.ListMapper.Property(System.String)">
+ <summary>
+ Produces a collection containing all the values of a property
+ </summary>
+ <param name="name">The collection of property values</param>
+ <returns></returns>
+ </member>
+ <member name="T:NUnit.Framework.TestFixtureSetUpAttribute">
+ <summary>
+ Attribute used to identify a method that is
+ called before any tests in a fixture are run.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TestFixtureTearDownAttribute">
+ <summary>
+ Attribute used to identify a method that is called after
+ all the tests in a fixture have run. The method is
+ guaranteed to be called, even if an exception is thrown.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Text">
+ <summary>
+ Helper class with static methods used to supply constraints
+ that operate on strings.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Text.Contains(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Text.DoesNotContain(System.String)">
+ <summary>
+ Returns a constraint that fails if the actual
+ value contains the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Text.StartsWith(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Text.DoesNotStartWith(System.String)">
+ <summary>
+ Returns a constraint that fails if the actual
+ value starts with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Text.EndsWith(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Text.DoesNotEndWith(System.String)">
+ <summary>
+ Returns a constraint that fails if the actual
+ value ends with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Text.Matches(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Text.DoesNotMatch(System.String)">
+ <summary>
+ Returns a constraint that fails if the actual
+ value matches the pattern supplied as an argument.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Text.All">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.MaxTimeAttribute">
+ <summary>
+ Summary description for MaxTimeAttribute.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.MaxTimeAttribute.#ctor(System.Int32)">
+ <summary>
+ Construct a MaxTimeAttribute, given a time in milliseconds.
+ </summary>
+ <param name="milliseconds">The maximum elapsed time in milliseconds</param>
+ </member>
+ <member name="T:NUnit.Framework.SetUICultureAttribute">
+ <summary>
+ Summary description for SetUICultureAttribute.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.SetUICultureAttribute.#ctor(System.String)">
+ <summary>
+ Construct given the name of a culture
+ </summary>
+ <param name="culture"></param>
+ </member>
+ <member name="T:NUnit.Framework.DirectoryAssert">
+ <summary>
+ Summary description for DirectoryAssert
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.Equals(System.Object,System.Object)">
+ <summary>
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.ReferenceEquals(System.Object,System.Object)">
+ <summary>
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.#ctor">
+ <summary>
+ We don't actually want any instances of this object, but some people
+ like to inherit from it to add other static methods. Hence, the
+ protected constructor disallows any instances of this object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String,System.Object[])">
+ <summary>
+ Verifies that two directories are equal. Two directories are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory containing the value that is expected</param>
+ <param name="actual">A directory containing the actual value</param>
+ <param name="message">The message to display if directories are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String)">
+ <summary>
+ Verifies that two directories are equal. Two directories are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory containing the value that is expected</param>
+ <param name="actual">A directory containing the actual value</param>
+ <param name="message">The message to display if directories are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
+ <summary>
+ Verifies that two directories are equal. Two directories are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory containing the value that is expected</param>
+ <param name="actual">A directory containing the actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Verifies that two directories are equal. Two directories are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory path string containing the value that is expected</param>
+ <param name="actual">A directory path string containing the actual value</param>
+ <param name="message">The message to display if directories are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.String,System.String,System.String)">
+ <summary>
+ Verifies that two directories are equal. Two directories are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory path string containing the value that is expected</param>
+ <param name="actual">A directory path string containing the actual value</param>
+ <param name="message">The message to display if directories are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.String,System.String)">
+ <summary>
+ Verifies that two directories are equal. Two directories are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory path string containing the value that is expected</param>
+ <param name="actual">A directory path string containing the actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String,System.Object[])">
+ <summary>
+ Asserts that two directories are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory containing the value that is expected</param>
+ <param name="actual">A directory containing the actual value</param>
+ <param name="message">The message to display if directories are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String)">
+ <summary>
+ Asserts that two directories are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory containing the value that is expected</param>
+ <param name="actual">A directory containing the actual value</param>
+ <param name="message">The message to display if directories are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
+ <summary>
+ Asserts that two directories are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory containing the value that is expected</param>
+ <param name="actual">A directory containing the actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that two directories are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory path string containing the value that is expected</param>
+ <param name="actual">A directory path string containing the actual value</param>
+ <param name="message">The message to display if directories are equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.String,System.String,System.String)">
+ <summary>
+ Asserts that two directories are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory path string containing the value that is expected</param>
+ <param name="actual">A directory path string containing the actual value</param>
+ <param name="message">The message to display if directories are equal</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.String,System.String)">
+ <summary>
+ Asserts that two directories are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory path string containing the value that is expected</param>
+ <param name="actual">A directory path string containing the actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.IO.DirectoryInfo,System.String,System.Object[])">
+ <summary>
+ Asserts that the directory is empty. If it is not empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="message">The message to display if directories are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.IO.DirectoryInfo,System.String)">
+ <summary>
+ Asserts that the directory is empty. If it is not empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="message">The message to display if directories are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.IO.DirectoryInfo)">
+ <summary>
+ Asserts that the directory is empty. If it is not empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that the directory is empty. If it is not empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="message">The message to display if directories are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.String,System.String)">
+ <summary>
+ Asserts that the directory is empty. If it is not empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="message">The message to display if directories are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.String)">
+ <summary>
+ Asserts that the directory is empty. If it is not empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.IO.DirectoryInfo,System.String,System.Object[])">
+ <summary>
+ Asserts that the directory is not empty. If it is empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="message">The message to display if directories are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.IO.DirectoryInfo,System.String)">
+ <summary>
+ Asserts that the directory is not empty. If it is empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="message">The message to display if directories are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.IO.DirectoryInfo)">
+ <summary>
+ Asserts that the directory is not empty. If it is empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that the directory is not empty. If it is empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="message">The message to display if directories are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.String,System.String)">
+ <summary>
+ Asserts that the directory is not empty. If it is empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="message">The message to display if directories are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.String)">
+ <summary>
+ Asserts that the directory is not empty. If it is empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String,System.Object[])">
+ <summary>
+ Asserts that path contains actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ <param name="message">The message to display if directory is not within the path</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String)">
+ <summary>
+ Asserts that path contains actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ <param name="message">The message to display if directory is not within the path</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
+ <summary>
+ Asserts that path contains actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that path contains actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ <param name="message">The message to display if directory is not within the path</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.String,System.String,System.String)">
+ <summary>
+ Asserts that path contains actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ <param name="message">The message to display if directory is not within the path</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.String,System.String)">
+ <summary>
+ Asserts that path contains actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String,System.Object[])">
+ <summary>
+ Asserts that path does not contain actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ <param name="message">The message to display if directory is not within the path</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String)">
+ <summary>
+ Asserts that path does not contain actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ <param name="message">The message to display if directory is not within the path</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
+ <summary>
+ Asserts that path does not contain actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that path does not contain actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ <param name="message">The message to display if directory is not within the path</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.String,System.String,System.String)">
+ <summary>
+ Asserts that path does not contain actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ <param name="message">The message to display if directory is not within the path</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.String,System.String)">
+ <summary>
+ Asserts that path does not contain actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ </member>
+ <member name="T:NUnit.Framework.SpecialValue">
+ <summary>
+ The SpecialValue enum is used to represent TestCase arguments
+ that cannot be used as arguments to an Attribute.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.SpecialValue.Null">
+ <summary>
+ Null represents a null value, which cannot be used as an
+ argument to an attriute under .NET 1.x
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.FileAssert">
+ <summary>
+ Summary description for FileAssert.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.Equals(System.Object,System.Object)">
+ <summary>
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.ReferenceEquals(System.Object,System.Object)">
+ <summary>
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.#ctor">
+ <summary>
+ We don't actually want any instances of this object, but some people
+ like to inherit from it to add other static methods. Hence, the
+ protected constructor disallows any instances of this object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.Stream,System.IO.Stream,System.String,System.Object[])">
+ <summary>
+ Verifies that two Streams are equal. Two Streams are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected Stream</param>
+ <param name="actual">The actual Stream</param>
+ <param name="message">The message to display if Streams are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.Stream,System.IO.Stream,System.String)">
+ <summary>
+ Verifies that two Streams are equal. Two Streams are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected Stream</param>
+ <param name="actual">The actual Stream</param>
+ <param name="message">The message to display if objects are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.Stream,System.IO.Stream)">
+ <summary>
+ Verifies that two Streams are equal. Two Streams are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected Stream</param>
+ <param name="actual">The actual Stream</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.FileInfo,System.IO.FileInfo,System.String,System.Object[])">
+ <summary>
+ Verifies that two files are equal. Two files are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A file containing the value that is expected</param>
+ <param name="actual">A file containing the actual value</param>
+ <param name="message">The message to display if Streams are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.FileInfo,System.IO.FileInfo,System.String)">
+ <summary>
+ Verifies that two files are equal. Two files are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A file containing the value that is expected</param>
+ <param name="actual">A file containing the actual value</param>
+ <param name="message">The message to display if objects are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.FileInfo,System.IO.FileInfo)">
+ <summary>
+ Verifies that two files are equal. Two files are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A file containing the value that is expected</param>
+ <param name="actual">A file containing the actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreEqual(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Verifies that two files are equal. Two files are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The path to a file containing the value that is expected</param>
+ <param name="actual">The path to a file containing the actual value</param>
+ <param name="message">The message to display if Streams are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreEqual(System.String,System.String,System.String)">
+ <summary>
+ Verifies that two files are equal. Two files are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The path to a file containing the value that is expected</param>
+ <param name="actual">The path to a file containing the actual value</param>
+ <param name="message">The message to display if objects are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreEqual(System.String,System.String)">
+ <summary>
+ Verifies that two files are equal. Two files are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The path to a file containing the value that is expected</param>
+ <param name="actual">The path to a file containing the actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.Stream,System.IO.Stream,System.String,System.Object[])">
+ <summary>
+ Asserts that two Streams are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected Stream</param>
+ <param name="actual">The actual Stream</param>
+ <param name="message">The message to be displayed when the two Stream are the same.</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.Stream,System.IO.Stream,System.String)">
+ <summary>
+ Asserts that two Streams are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected Stream</param>
+ <param name="actual">The actual Stream</param>
+ <param name="message">The message to be displayed when the Streams are the same.</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.Stream,System.IO.Stream)">
+ <summary>
+ Asserts that two Streams are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected Stream</param>
+ <param name="actual">The actual Stream</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.FileInfo,System.IO.FileInfo,System.String,System.Object[])">
+ <summary>
+ Asserts that two files are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A file containing the value that is expected</param>
+ <param name="actual">A file containing the actual value</param>
+ <param name="message">The message to display if Streams are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.FileInfo,System.IO.FileInfo,System.String)">
+ <summary>
+ Asserts that two files are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A file containing the value that is expected</param>
+ <param name="actual">A file containing the actual value</param>
+ <param name="message">The message to display if objects are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.FileInfo,System.IO.FileInfo)">
+ <summary>
+ Asserts that two files are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A file containing the value that is expected</param>
+ <param name="actual">A file containing the actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that two files are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The path to a file containing the value that is expected</param>
+ <param name="actual">The path to a file containing the actual value</param>
+ <param name="message">The message to display if Streams are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.String,System.String,System.String)">
+ <summary>
+ Asserts that two files are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The path to a file containing the value that is expected</param>
+ <param name="actual">The path to a file containing the actual value</param>
+ <param name="message">The message to display if objects are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.String,System.String)">
+ <summary>
+ Asserts that two files are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The path to a file containing the value that is expected</param>
+ <param name="actual">The path to a file containing the actual value</param>
+ </member>
+ <member name="T:NUnit.Framework.TheoryAttribute">
+ <summary>
+ Adding this attribute to a method within a <seealso cref="T:NUnit.Framework.TestFixtureAttribute"/>
+ class makes the method callable from the NUnit test runner. There is a property
+ called Description which is optional which you can provide a more detailed test
+ description. This class cannot be inherited.
+ </summary>
+
+ <example>
+ [TestFixture]
+ public class Fixture
+ {
+ [Test]
+ public void MethodToTest()
+ {}
+
+ [Test(Description = "more detailed description")]
+ publc void TestDescriptionMethod()
+ {}
+ }
+ </example>
+
+ </member>
+ <member name="T:NUnit.Framework.Randomizer">
+ <summary>
+ Randomizer returns a set of random values in a repeatable
+ way, to allow re-running of tests if necessary.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Randomizer.GetRandomizer(System.Reflection.MemberInfo)">
+ <summary>
+ Get a randomizer for a particular member, returning
+ one that has already been created if it exists.
+ This ensures that the same values are generated
+ each time the tests are reloaded.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Randomizer.GetRandomizer(System.Reflection.ParameterInfo)">
+ <summary>
+ Get a randomizer for a particular parameter, returning
+ one that has already been created if it exists.
+ This ensures that the same values are generated
+ each time the tests are reloaded.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Randomizer.#ctor">
+ <summary>
+ Construct a randomizer using a random seed
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Randomizer.#ctor(System.Int32)">
+ <summary>
+ Construct a randomizer using a specified seed
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Randomizer.GetDoubles(System.Int32)">
+ <summary>
+ Return an array of random doubles between 0.0 and 1.0.
+ </summary>
+ <param name="count"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Randomizer.GetDoubles(System.Double,System.Double,System.Int32)">
+ <summary>
+ Return an array of random doubles with values in a specified range.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Randomizer.GetInts(System.Int32,System.Int32,System.Int32)">
+ <summary>
+ Return an array of random ints with values in a specified range.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Randomizer.RandomSeed">
+ <summary>
+ Get a random seed for use in creating a randomizer.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.DatapointAttribute">
+ <summary>
+ Used to mark a field for use as a datapoint when executing a theory
+ within the same fixture that requires an argument of the field's Type.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.DatapointsAttribute">
+ <summary>
+ Used to mark an array as containing a set of datapoints to be used
+ executing a theory within the same fixture that requires an argument
+ of the Type of the array elements.
+ </summary>
+ </member>
+ </members>
+</doc>
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Types/ObjectContainerTests.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Types/ObjectContainerTests.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/Types/ObjectContainerTests.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using Moq;
+
+namespace FreeSWITCH.Managed.Tests.Types
+{
+ [TestFixture]
+ public class ObjectContainerTests
+ {
+ [Test]
+ public void CreateSimpleObject()
+ {
+ ObjectContainer locator = new ObjectContainer();
+ var result = locator.Create<object>();
+ Assert.IsAssignableFrom<object>(result);
+ }
+
+ [Test]
+ public void CreateComplexObject()
+ {
+ ObjectContainer locator = new ObjectContainer();
+ var dc = new Mock<IDirectoryController>();
+ var log = new Mock<ILoggerContainer>();
+ var log1 = new Mock<ILogger>();
+ var ml = new Mock<IModuleLoader>();
+ locator.Register<IDirectoryController>(c => { return dc.Object; });
+ locator.Register<ILoggerContainer>(c => { return log.Object; });
+ locator.Register<ILogger>(c => { return log1.Object; });
+ locator.Register<IModuleLoader>(c => { return ml.Object; });
+ var result = locator.Create<DefaultLoader>();
+ Assert.IsAssignableFrom<DefaultLoader>(result);
+ }
+
+ [Test]
+ public void CreateSingletonObject()
+ {
+ ObjectContainer locator = new ObjectContainer();
+ locator.DeclareSingleton(typeof(object));
+ var result = locator.Create<object>();
+ Assert.IsAssignableFrom<object>(result);
+ var result2 = locator.Create<object>();
+ Assert.AreSame(result, result2);
+ }
+
+ [Test]
+ public void RegisterSingletonObject()
+ {
+ ObjectContainer locator = new ObjectContainer();
+ locator.RegisterSingleton<object>(c => { return new object(); });
+ var result = locator.Create<object>();
+ Assert.IsAssignableFrom<object>(result);
+ var result2 = locator.Create<object>();
+ Assert.AreSame(result, result2);
+ }
+
+ [Test]
+ public void ToString_NoParameters_ReturnsDescription()
+ {
+ ObjectContainer locator = new ObjectContainer();
+ locator.RegisterSingleton<object>(c => { return new object(); });
+ var log = new Mock<ILogger>();
+ locator.Register<ILogger>(c => { return log.Object; });
+ locator.Configuration["Object"]=new object();
+ var result = locator.ToString();
+ Assert.IsInstanceOf<string>(result);
+ //Console.WriteLine(result);
+ }
+
+ [Test]
+ public void RegisterReplacesPreviousRegistration
+ ()
+ {
+ ObjectContainer locator = new ObjectContainer();
+ var log = new Mock<ILogger>();
+ locator.Register<ILogger>(c => { return log.Object; });
+ var log2 = new Mock<ILogger>();
+ locator.Register<ILogger>(c => { return log2.Object; });
+ var result = locator.Create<ILogger>();
+ Assert.AreSame(result,log2.Object);
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/bin/Debug/FreeSWITCH.Managed.Tests.dll
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/bin/Debug/FreeSWITCH.Managed.Tests.dll.VisualState.xml (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/bin/Debug/FreeSWITCH.Managed.Tests.dll.VisualState.xml (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/bin/Debug/FreeSWITCH.Managed.Tests.dll.VisualState.xml 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<VisualState xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" ShowCheckBoxes="false">
+ <TopNode>[0-1094]C:\RTI Development\FreeSWITCH.Managed\UnitTests\bin\Debug\FreeSWITCH.Managed.Tests.dll</TopNode>
+ <SelectedNode>[0-1096]FreeSWITCH.Managed</SelectedNode>
+ <ExcludeCategories>false</ExcludeCategories>
+ <Nodes>
+ <Node UniqueName="[0-1094]C:\RTI Development\FreeSWITCH.Managed\UnitTests\bin\Debug\FreeSWITCH.Managed.Tests.dll" Expanded="true" />
+ <Node UniqueName="[0-1095]FreeSWITCH" Expanded="true" />
+ <Node UniqueName="[0-1096]FreeSWITCH.Managed" Expanded="true" />
+ <Node UniqueName="[0-1097]FreeSWITCH.Managed.Tests" Expanded="true" />
+ <Node UniqueName="[0-1098]FreeSWITCH.Managed.Tests.Directors" Expanded="true" />
+ <Node UniqueName="[0-1009]FreeSWITCH.Managed.Tests.Directors.ExecuteBackgroundCommandDirectorTests" Expanded="true" />
+ <Node UniqueName="[0-1000]FreeSWITCH.Managed.Tests.Directors.LogDirectorTests" Expanded="true" />
+ <Node UniqueName="[0-1099]FreeSWITCH.Managed.Tests.ModuleAppdomains" Expanded="true" />
+ <Node UniqueName="[0-1103]FreeSWITCH.Managed.Tests.ModuleAppdomains.AssemblyComposers" Expanded="true" />
+ <Node UniqueName="[0-1102]FreeSWITCH.Managed.Tests.ModuleAppdomains.PluginHandlers" Expanded="true" />
+ <Node UniqueName="[0-1100]FreeSWITCH.Managed.Tests.ModuleAppdomains.PluginTypes" Expanded="true" />
+ <Node UniqueName="[0-1104]FreeSWITCH.Managed.Tests.PrimaryAppdomain" Expanded="true" />
+ <Node UniqueName="[0-1061]FreeSWITCH.Managed.Tests.PrimaryAppdomain.DefaultServiceLocatorTests" Expanded="true" />
+ <Node UniqueName="[0-1101]FreeSWITCH.Managed.Tests.Types" Expanded="true" />
+ </Nodes>
+</VisualState>
\ No newline at end of file
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/bin/Debug/FreeSWITCH.Managed.Tests.pdb
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/bin/Debug/FreeSWITCH.Managed.dll
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/bin/Debug/FreeSWITCH.Managed.pdb
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/bin/Debug/Moq.dll
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/bin/Debug/Moq.pdb
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/bin/Debug/Moq.xml (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/bin/Debug/Moq.xml (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/bin/Debug/Moq.xml 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,3467 @@
+<?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<string>()))
+ .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<string>(),
+ It.IsAny<string>()))
+ .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<string>(),
+ It.IsAny<string>(),
+ It.IsAny<int>()))
+ .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<string>(),
+ It.IsAny<string>(),
+ It.IsAny<int>(),
+ It.IsAny<bool>()))
+ .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<ICommand>();
+ 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<ICommand>();
+ 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<IContainer>();
+
+ mock.Setup(add => add.Add(It.IsAny<string>(), It.IsAny<object>()))
+ .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<IContainer>();
+ // 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 => add.Add(It.IsAny<string>(), It.IsAny<object>()))
+ .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 => 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 => 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<Order> 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<IRepository<Order>>();
+
+ mock.Setup(x => x.Save(Orders.Contains(order)))
+ .Throws<ArgumentException>();
+ </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<Order> 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<Order> Contains(Order order)
+ {
+ return null;
+ }
+
+ public static bool Contains(IEnumerable<Order> orders, Order order)
+ {
+ return orders.Contains(order);
+ }
+ }
+ </code>
+ And the concrete test using this matcher:
+ <code>
+ var order = new Order { ... };
+ var mock = new Mock<IRepository<Order>>();
+
+ mock.Setup(x => x.Save(Orders.Contains(order)))
+ .Throws<ArgumentException>();
+
+ // 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<string>()))
+ .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<string>(),
+ It.IsAny<string>()))
+ .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<string>(),
+ It.IsAny<string>(),
+ It.IsAny<int>()))
+ .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<string>(),
+ It.IsAny<string>(),
+ It.IsAny<int>(),
+ It.IsAny<bool>()))
+ .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 => 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 => x.Execute(""))
+ .Throws<ArgumentException>();
+ </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<string>()))
+ .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<string>(),
+ It.IsAny<string>()))
+ .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<string>(),
+ It.IsAny<string>(),
+ It.IsAny<int>()))
+ .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<string>(),
+ It.IsAny<string>(),
+ It.IsAny<int>(),
+ It.IsAny<bool>()))
+ .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<ICommand>();
+ mock.Setup(foo => 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 => x.Remove(It.IsAny<string>())).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 => x.Do(It.Is<int>(i => 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 => x.GetUser(It.Is<int>(i => i < 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 => x.HasInventory(
+ It.IsAny<string>(),
+ 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 => 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 => 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<HttpRequestBase> request = Mock.Get(context.Request);
+ mock.Setup(req => 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<IWarehouse>();
+ this.Setup(x => 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<IWarehouse>();
+ this.Setup(x => 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<IOrdersView>();
+ var mockedEvent = mockView.CreateEventHandler<OrderEventArgs>();
+
+ 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<OrderEventArgs>();
+ // 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<IOrdersView>();
+ 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<IFoo>();
+ var bar = factory.Create<IBar>();
+
+ // no need to call Verifiable() on the setup
+ // as we'll be validating all of them anyway.
+ foo.Setup(f => f.Do());
+ bar.Setup(b => 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<IFoo>();
+ var bar = factory.Create<IBar>();
+
+ // this setup will be verified when we verify the factory
+ foo.Setup(f => f.Do()).Verifiable();
+
+ // this setup will NOT be verified
+ foo.Setup(f => f.Calculate());
+
+ // this setup will be verified when we verify the factory
+ bar.Setup(b => 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<IFoo>(MockBehavior.Loose);
+ var bar = factory.Create<IBar>();
+
+ // 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<IFoo>();
+ // 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<MyBase>("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<IFoo>(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<MyBase>(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'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'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'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 => 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<T>..
+ </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 => x.{1}).Returns(value);
+ mock.SetupGet(x => x.{1}).Returns(value); //equivalent to previous one
+ mock.SetupSet(x => 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<{2}>(x => x.{1}).Returns(value);
+ mock.SetupGet(x => x.{1}).Returns(value); //equivalent to previous one
+ mock.SetupSet(x => 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<string>())
+ .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<string>())
+ .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<int>(i => 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<int>(i => i < 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<string>(),
+ 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<Order>.Create(
+ o => o.GrandTotal >= 5000,
+ /* a friendly expression to render on failures */
+ () => IsBigOrder());
+ }
+ </code>
+ This method can be used in any mock setup invocation:
+ <code>
+ mock.Setup(m => m.Submit(IsBigOrder()).Throws<UnauthorizedAccessException>();
+ </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<Order> Contains(Order order)
+ {
+ return Match<IEnumerable<Order>>.Create(orders => 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<IRepository<Order>>();
+
+ mock.Setup(x => x.Save(Orders.Contains(order)))
+ .Throws<ArgumentException>();
+ </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="Match{T}.Create(condition,renderExpression"]/*"/>
+ </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="Match{T}.Convert"]/*"/>
+ </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<IWarehouse>();
+
+ mock.Setup(x => 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<IWarehouse>();
+
+ // shows how to expect a value within a range
+ mock.Setup(x => x.HasInventory(
+ It.IsAny<string>(),
+ It.IsInRange(0, 100, Range.Inclusive)))
+ .Returns(false);
+
+ // shows how to throw for unexpected calls.
+ mock.Setup(x => x.Remove(
+ It.IsAny<string>(),
+ It.IsAny<int>()))
+ .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<IFormatProvider>();</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<MyProvider>(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<IFormatProvider>(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<MyProvider>(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<IProcessor>();
+ mock.Setup(x => 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 => 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 => 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 => 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 => 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<IHaveValue>();
+ mock.Stub(v => 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<IHaveValue>();
+ mock.SetupProperty(v => 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<IProcessor>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't call Execute with a "ping" string argument.
+ mock.Verify(proc => 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<IProcessor>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't call Execute with a "ping" string argument.
+ mock.Verify(proc => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't call HasInventory.
+ mock.Verify(warehouse => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't call HasInventory.
+ mock.Verify(warehouse => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't retrieve the IsClosed property.
+ mock.VerifyGet(warehouse => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't retrieve the IsClosed property.
+ mock.VerifyGet(warehouse => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't set the IsClosed property.
+ mock.VerifySet(warehouse => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't set the IsClosed property.
+ mock.VerifySet(warehouse => 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<IProcessor>();
+ mock.Setup(x => x.Execute("ping"));
+
+ // add IDisposable interface
+ var disposable = mock.As<IDisposable>();
+ disposable.Setup(d => 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<IViewModel>();
+
+ mock.Raise(x => 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<IOrdersView>();
+ 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 => 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<IViewModel>();
+
+ mock.Raise(x => 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 => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't set the IsClosed property.
+ mock.VerifySet(warehouse => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't set the IsClosed property.
+ mock.VerifySet(warehouse => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't set the IsClosed property.
+ mock.VerifySet(warehouse => 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<IWarehouse>();
+ // exercise mock
+ //...
+ // Will throw if the test code didn't set the IsClosed property.
+ mock.VerifySet(warehouse => 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>
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/bin/Debug/TestResult.xml (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/bin/Debug/TestResult.xml (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/bin/Debug/TestResult.xml 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,198 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<!--This file represents the results of running a test suite-->
+<test-results name="C:\RTI Development\FreeSWITCH.Managed\UnitTests\bin\Debug\FreeSWITCH.Managed.Tests.dll" total="76" errors="0" failures="0" not-run="0" inconclusive="0" ignored="0" skipped="0" invalid="0" date="2009-09-27" time="13:38:58">
+ <environment nunit-version="2.5.2.9222" clr-version="2.0.50727.3082" os-version="Microsoft Windows NT 5.2.3790 Service Pack 2" platform="Win32NT" cwd="C:\RTI Development\FreeSWITCH.Managed\UnitTests\bin\Debug" machine-name="JOSH-FREESWITCH" user="Administrator" user-domain="JOSH-FREESWITCH" />
+ <culture-info current-culture="en-US" current-uiculture="en-US" />
+ <test-suite name="C:\RTI Development\FreeSWITCH.Managed\UnitTests\bin\Debug\FreeSWITCH.Managed.Tests.dll" executed="True" success="True" time="2.594" asserts="0">
+ <results>
+ <test-suite name="FreeSWITCH" executed="True" success="True" time="2.578" asserts="0">
+ <results>
+ <test-suite name="Managed" executed="True" success="True" time="2.547" asserts="0">
+ <results>
+ <test-suite name="Tests" executed="True" success="True" time="2.516" asserts="0">
+ <results>
+ <test-suite name="AppdomainExplorationTests" executed="True" success="True" time="0.234" asserts="0">
+ <results>
+ <test-case name="FreeSWITCH.Managed.Tests.AppdomainExplorationTests.CreateAndUnwrapInstance" executed="True" success="True" time="0.078" asserts="0" />
+ <test-case name="FreeSWITCH.Managed.Tests.AppdomainExplorationTests.CreateAndUnwrapInterface" executed="True" success="True" time="0.016" asserts="0" />
+ <test-case name="FreeSWITCH.Managed.Tests.AppdomainExplorationTests.CreateAndUnwrapProxy" executed="True" success="True" time="0.016" asserts="0" />
+ <test-case name="FreeSWITCH.Managed.Tests.AppdomainExplorationTests.CreateAndUnwrapProxyInterface" executed="True" success="True" time="0.031" asserts="0" />
+ <test-case name="FreeSWITCH.Managed.Tests.AppdomainExplorationTests.CreateAndUnwrapProxyInterfaceWithLocalWriter" executed="True" success="True" time="0.031" asserts="0" />
+ </results>
+ </test-suite>
+ <test-suite name="CoreDelegatesTests" executed="True" success="True" time="0.016" asserts="0">
+ <results>
+ <test-case name="FreeSWITCH.Managed.Tests.CoreDelegatesTests.InitializeCoreDelegatesMethodExists" executed="True" success="True" time="0.016" asserts="0" />
+ </results>
+ </test-suite>
+ <test-suite name="DefaultLoaderTests" executed="True" success="True" time="0.063" asserts="0">
+ <results>
+ <test-case name="FreeSWITCH.Managed.Tests.DefaultLoaderTests.Load_Empty_ReturnsTrue" executed="True" success="True" time="0.016" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.DefaultLoaderTests.Load_Empty_SetsRunDelegateToExecuteBackgroundCommand" executed="True" success="True" time="0.000" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.DefaultLoaderTests.Load_Empty_SetsRunDelegateToExecuteCommand" executed="True" success="True" time="0.016" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.DefaultLoaderTests.Load_Empty_SetsRunDelegateToReloadCommand" executed="True" success="True" time="0.000" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.DefaultLoaderTests.Load_Empty_SetsRunDelegateToRunCommand" executed="True" success="True" time="0.000" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.DefaultLoaderTests.SingletonFactory" executed="True" success="True" time="0.000" asserts="1" />
+ </results>
+ </test-suite>
+ <test-suite name="Directors" executed="True" success="True" time="1.609" asserts="0">
+ <results>
+ <test-suite name="ExecuteBackgroundCommandDirectorTests" executed="True" success="True" time="1.141" asserts="0">
+ <results>
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.ExecuteBackgroundCommandDirectorTests.ClassContainsCommandsCollection" executed="True" success="True" time="0.500" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.ExecuteBackgroundCommandDirectorTests.ExecuteBackground_Empty_ReturnsTrue" executed="True" success="True" time="0.000" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.ExecuteBackgroundCommandDirectorTests.ExecuteBackground_ExceptionThrowingCommand_LogsError" executed="True" success="True" time="0.578" asserts="0" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.ExecuteBackgroundCommandDirectorTests.ExecuteBackground_ExceptionThrowingCommand_ReturnsFalse" executed="True" success="True" time="0.016" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.ExecuteBackgroundCommandDirectorTests.ExecuteBackground_FalseReturningCommand_ReturnsFalse" executed="True" success="True" time="0.000" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.ExecuteBackgroundCommandDirectorTests.ExecuteBackground_MultipleCommands_RunsAll" executed="True" success="True" time="0.000" asserts="0" />
+ </results>
+ </test-suite>
+ <test-suite name="ExecuteCommandDirectorTests" executed="True" success="True" time="0.094" asserts="0">
+ <results>
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.ExecuteCommandDirectorTests.ClassContainsCommandsCollection" executed="True" success="True" time="0.000" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.ExecuteCommandDirectorTests.Execute_Empty_ReturnsTrue" executed="True" success="True" time="0.016" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.ExecuteCommandDirectorTests.Execute_ExceptionThrowingCommand_LogsError" executed="True" success="True" time="0.031" asserts="0" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.ExecuteCommandDirectorTests.Execute_ExceptionThrowingCommand_ReturnsFalse" executed="True" success="True" time="0.000" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.ExecuteCommandDirectorTests.Execute_FalseReturningCommand_ReturnsFalse" executed="True" success="True" time="0.000" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.ExecuteCommandDirectorTests.Execute_MultipleCommands_RunsAll" executed="True" success="True" time="0.016" asserts="1" />
+ </results>
+ </test-suite>
+ <test-suite name="LogDirectorTests" executed="True" success="True" time="0.078" asserts="0">
+ <results>
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.LogDirectorTests.Alert_Message_CallsLogger" executed="True" success="True" time="0.016" asserts="0" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.LogDirectorTests.ClassContainsCommandsCollection" executed="True" success="True" time="0.000" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.LogDirectorTests.Critical_Message_CallsLogger" executed="True" success="True" time="0.000" asserts="0" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.LogDirectorTests.Debug_Message_CallsLogger" executed="True" success="True" time="0.000" asserts="0" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.LogDirectorTests.Error_Message_CallsLogger" executed="True" success="True" time="0.000" asserts="0" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.LogDirectorTests.Info_LoggerWithException_Continues" executed="True" success="True" time="0.000" asserts="0" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.LogDirectorTests.Notice_Message_CallsLogger" executed="True" success="True" time="0.000" asserts="0" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.LogDirectorTests.Warning_Message_CallsLogger" executed="True" success="True" time="0.016" asserts="0" />
+ </results>
+ </test-suite>
+ <test-suite name="ReloadCommandDirectorTests" executed="True" success="True" time="0.141" asserts="0">
+ <results>
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.ReloadCommandDirectorTests.ClassContainsCommandsCollection" executed="True" success="True" time="0.000" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.ReloadCommandDirectorTests.Reload_Empty_ReturnsTrue" executed="True" success="True" time="0.000" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.ReloadCommandDirectorTests.Reload_ExceptionThrowingCommand_LogsError" executed="True" success="True" time="0.031" asserts="0" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.ReloadCommandDirectorTests.Reload_ExceptionThrowingCommand_ReturnsFalse" executed="True" success="True" time="0.000" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.ReloadCommandDirectorTests.Reload_FalseReturningCommand_ReturnsFalse" executed="True" success="True" time="0.016" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.ReloadCommandDirectorTests.Reload_MultipleCommands_RunsAll" executed="True" success="True" time="0.016" asserts="0" />
+ </results>
+ </test-suite>
+ <test-suite name="RunCommandDirectorTests" executed="True" success="True" time="0.156" asserts="0">
+ <results>
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.RunCommandDirectorTests.ClassContainsCommandsCollection" executed="True" success="True" time="0.000" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.RunCommandDirectorTests.Run_Empty_ReturnsTrue" executed="True" success="True" time="0.000" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.RunCommandDirectorTests.Run_ExceptionThrowingCommand_LogsError" executed="True" success="True" time="0.047" asserts="0" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.RunCommandDirectorTests.Run_ExceptionThrowingCommand_ReturnsFalse" executed="True" success="True" time="0.016" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.RunCommandDirectorTests.Run_FalseReturningCommand_ReturnsFalse" executed="True" success="True" time="0.000" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Directors.RunCommandDirectorTests.Run_MultipleCommands_RunsAll" executed="True" success="True" time="0.016" asserts="0" />
+ </results>
+ </test-suite>
+ </results>
+ </test-suite>
+ <test-suite name="LoaderTests" executed="True" success="True" time="0.016" asserts="0">
+ <results>
+ <test-case name="FreeSWITCH.Managed.Tests.LoaderTests.LoadMethodExists" executed="True" success="True" time="0.000" asserts="0" />
+ </results>
+ </test-suite>
+ <test-suite name="ModuleAppdomains" executed="True" success="True" time="0.141" asserts="0">
+ <results>
+ <test-suite name="AssemblyCompilerTests" executed="True" success="True" time="0.000" asserts="0">
+ <results>
+ <test-case name="FreeSWITCH.Managed.Tests.ModuleAppdomains.AssemblyCompilerTests.Constructor_Requires_ILogger" executed="True" success="True" time="0.000" asserts="1" />
+ </results>
+ </test-suite>
+ <test-suite name="AssemblyComposers" executed="True" success="True" time="0.031" asserts="0">
+ <results>
+ <test-suite name="ScriptAssemblyComposerTests" executed="True" success="True" time="0.016" asserts="0">
+ <results>
+ <test-case name="FreeSWITCH.Managed.Tests.ModuleAppdomains.AssemblyComposers.ScriptAssemblyComposerTests.Constructor_Requires_IAssemblyCompiler" executed="True" success="True" time="0.016" asserts="1" />
+ </results>
+ </test-suite>
+ </results>
+ </test-suite>
+ <test-suite name="ModuleProxyTests" executed="True" success="True" time="0.016" asserts="0">
+ <results>
+ <test-case name="FreeSWITCH.Managed.Tests.ModuleAppdomains.ModuleProxyTests.ClassHasDefaultConstructor" executed="True" success="True" time="0.000" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.ModuleAppdomains.ModuleProxyTests.Logger_Get_ReturnsLogDirectorFromContainer" executed="True" success="True" time="0.016" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.ModuleAppdomains.ModuleProxyTests.Logger_Get_ReturnsLoggerFromContainer" executed="True" success="True" time="0.000" asserts="1" />
+ </results>
+ </test-suite>
+ <test-suite name="ModuleServiceLocatorTests" executed="True" success="True" time="0.047" asserts="0">
+ <results>
+ <test-case name="FreeSWITCH.Managed.Tests.ModuleAppdomains.ModuleServiceLocatorTests.LocatorResolvesAssemblyComposerDictionary" executed="True" success="True" time="0.000" asserts="7" />
+ <test-case name="FreeSWITCH.Managed.Tests.ModuleAppdomains.ModuleServiceLocatorTests.LocatorResolvesIDirectoryController" executed="True" success="True" time="0.000" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.ModuleAppdomains.ModuleServiceLocatorTests.LocatorResolvesILogger" executed="True" success="True" time="0.000" asserts="2" />
+ <test-case name="FreeSWITCH.Managed.Tests.ModuleAppdomains.ModuleServiceLocatorTests.LocatorResolvesLogDirector" executed="True" success="True" time="0.000" asserts="2" />
+ <test-case name="FreeSWITCH.Managed.Tests.ModuleAppdomains.ModuleServiceLocatorTests.LocatorResolvesPluginHandlerOrchestrator" executed="True" success="True" time="0.016" asserts="2" />
+ </results>
+ </test-suite>
+ <test-suite name="PluginHandlers" executed="True" success="True" time="0.016" asserts="0">
+ <results>
+ <test-suite name="DefaultPluginHandlerTests" executed="True" success="True" time="0.000" asserts="0">
+ <results>
+ <test-case name="FreeSWITCH.Managed.Tests.ModuleAppdomains.PluginHandlers.DefaultPluginHandlerTests.ConstructorRequiresILogger" executed="True" success="True" time="0.000" asserts="1" />
+ </results>
+ </test-suite>
+ <test-suite name="RunNotifyPluginHandlerTests" executed="True" success="True" time="0.016" asserts="0">
+ <results>
+ <test-case name="FreeSWITCH.Managed.Tests.ModuleAppdomains.PluginHandlers.RunNotifyPluginHandlerTests.NoReload_Get_ReturnsFalse" executed="True" success="True" time="0.000" asserts="1" />
+ </results>
+ </test-suite>
+ </results>
+ </test-suite>
+ <test-suite name="PluginTypes" executed="True" success="True" time="0.031" asserts="0">
+ <results>
+ <test-suite name="DefaultPluginExecutorTests" executed="True" success="True" time="0.031" asserts="0">
+ <results>
+ <test-case name="FreeSWITCH.Managed.Tests.ModuleAppdomains.PluginTypes.DefaultPluginExecutorTests.Constructor_Requires_ILogger" executed="True" success="True" time="0.031" asserts="1" />
+ </results>
+ </test-suite>
+ </results>
+ </test-suite>
+ </results>
+ </test-suite>
+ <test-suite name="PrimaryAppdomain" executed="True" success="True" time="0.234" asserts="0">
+ <results>
+ <test-suite name="DefaultServiceLocatorTests" executed="True" success="True" time="0.234" asserts="0">
+ <results>
+ <test-case name="FreeSWITCH.Managed.Tests.PrimaryAppdomain.DefaultServiceLocatorTests.LocatorResolvesAssemblyResolver" executed="True" success="True" time="0.016" asserts="2" />
+ <test-case name="FreeSWITCH.Managed.Tests.PrimaryAppdomain.DefaultServiceLocatorTests.LocatorResolvesDefaultPluginDirectoryWatcher" executed="True" success="True" time="0.016" asserts="2" />
+ <test-case name="FreeSWITCH.Managed.Tests.PrimaryAppdomain.DefaultServiceLocatorTests.LocatorResolvesExecuteBackgroundCommandDirector" executed="True" success="True" time="0.000" asserts="2" />
+ <test-case name="FreeSWITCH.Managed.Tests.PrimaryAppdomain.DefaultServiceLocatorTests.LocatorResolvesExecuteCommandDirector" executed="True" success="True" time="0.000" asserts="2" />
+ <test-case name="FreeSWITCH.Managed.Tests.PrimaryAppdomain.DefaultServiceLocatorTests.LocatorResolvesIAppDomainFactory" executed="True" success="True" time="0.016" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.PrimaryAppdomain.DefaultServiceLocatorTests.LocatorResolvesIDirectoryController" executed="True" success="True" time="0.016" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.PrimaryAppdomain.DefaultServiceLocatorTests.LocatorResolvesIModuleLoader" executed="True" success="True" time="0.016" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.PrimaryAppdomain.DefaultServiceLocatorTests.LocatorResolvesLogger" executed="True" success="True" time="0.000" asserts="3" />
+ <test-case name="FreeSWITCH.Managed.Tests.PrimaryAppdomain.DefaultServiceLocatorTests.LocatorResolvesModuleList" executed="True" success="True" time="0.016" asserts="2" />
+ <test-case name="FreeSWITCH.Managed.Tests.PrimaryAppdomain.DefaultServiceLocatorTests.LocatorResolvesModuleProxyTypeDictionary" executed="True" success="True" time="0.016" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.PrimaryAppdomain.DefaultServiceLocatorTests.LocatorResolvesReloadCommandDirector" executed="True" success="True" time="0.016" asserts="2" />
+ <test-case name="FreeSWITCH.Managed.Tests.PrimaryAppdomain.DefaultServiceLocatorTests.LocatorResolvesRunCommandDirector" executed="True" success="True" time="0.016" asserts="2" />
+ </results>
+ </test-suite>
+ </results>
+ </test-suite>
+ <test-suite name="Types" executed="True" success="True" time="0.125" asserts="0">
+ <results>
+ <test-suite name="ObjectContainerTests" executed="True" success="True" time="0.125" asserts="0">
+ <results>
+ <test-case name="FreeSWITCH.Managed.Tests.Types.ObjectContainerTests.CreateComplexObject" executed="True" success="True" time="0.094" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Types.ObjectContainerTests.CreateSimpleObject" executed="True" success="True" time="0.016" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Types.ObjectContainerTests.CreateSingletonObject" executed="True" success="True" time="0.000" asserts="2" />
+ <test-case name="FreeSWITCH.Managed.Tests.Types.ObjectContainerTests.RegisterReplacesPreviousRegistration" executed="True" success="True" time="0.000" asserts="1" />
+ <test-case name="FreeSWITCH.Managed.Tests.Types.ObjectContainerTests.RegisterSingletonObject" executed="True" success="True" time="0.000" asserts="2" />
+ <test-case name="FreeSWITCH.Managed.Tests.Types.ObjectContainerTests.ToString_NoParameters_ReturnsDescription" executed="True" success="True" time="0.000" asserts="1" />
+ </results>
+ </test-suite>
+ </results>
+ </test-suite>
+ </results>
+ </test-suite>
+ </results>
+ </test-suite>
+ </results>
+ </test-suite>
+ </results>
+ </test-suite>
+</test-results>
\ No newline at end of file
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/bin/Debug/nunit.framework.dll
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/bin/Debug/nunit.framework.xml (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/bin/Debug/nunit.framework.xml (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/bin/Debug/nunit.framework.xml 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,10088 @@
+<?xml version="1.0"?>
+<doc>
+ <assembly>
+ <name>nunit.framework</name>
+ </assembly>
+ <members>
+ <member name="T:NUnit.Framework.Constraints.TypeConstraint">
+ <summary>
+ TypeConstraint is the abstract base for constraints
+ that take a Type as their expected value.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.Constraint">
+ <summary>
+ The Constraint class is the base of all built-in constraints
+ within NUnit. It provides the operator overloads used to combine
+ constraints.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.IResolveConstraint">
+ <summary>
+ The IConstraintExpression interface is implemented by all
+ complete and resolvable constraints and expressions.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.IResolveConstraint.Resolve">
+ <summary>
+ Return the top-level constraint for this expression
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.Constraint.UNSET">
+ <summary>
+ Static UnsetObject used to detect derived constraints
+ failing to set the actual value.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.Constraint.actual">
+ <summary>
+ The actual value being tested against a constraint
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.Constraint.displayName">
+ <summary>
+ The display name of this Constraint for use by ToString()
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.Constraint.argcnt">
+ <summary>
+ Argument fields used by ToString();
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.Constraint.builder">
+ <summary>
+ The builder holding this constraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.#ctor">
+ <summary>
+ Construct a constraint with no arguments
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.#ctor(System.Object)">
+ <summary>
+ Construct a constraint with one argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.#ctor(System.Object,System.Object)">
+ <summary>
+ Construct a constraint with two arguments
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.SetBuilder(NUnit.Framework.Constraints.ConstraintBuilder)">
+ <summary>
+ Sets the ConstraintBuilder holding this constraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.WriteMessageTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the failure message to the MessageWriter provided
+ as an argument. The default implementation simply passes
+ the constraint and the actual value to the writer, which
+ then displays the constraint description and the value.
+
+ Constraints that need to provide additional details,
+ such as where the error occured can override this.
+ </summary>
+ <param name="writer">The MessageWriter on which to display the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.Matches(NUnit.Framework.Constraints.ActualValueDelegate)">
+ <summary>
+ Test whether the constraint is satisfied by an
+ ActualValueDelegate that returns the value to be tested.
+ The default implementation simply evaluates the delegate
+ but derived classes may override it to provide for delayed
+ processing.
+ </summary>
+ <param name="del">An ActualValueDelegate</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.Matches``1(``0@)">
+ <summary>
+ Test whether the constraint is satisfied by a given reference.
+ The default implementation simply dereferences the value but
+ derived classes may override it to provide for delayed processing.
+ </summary>
+ <param name="actual">A reference to the value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter. The default implementation simply writes
+ the raw value of actual, leaving it to the writer to
+ perform any formatting.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.ToString">
+ <summary>
+ Default override of ToString returns the constraint DisplayName
+ followed by any arguments within angle brackets.
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.op_BitwiseAnd(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ This operator creates a constraint that is satisfied only if both
+ argument constraints are satisfied.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.op_BitwiseOr(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ This operator creates a constraint that is satisfied if either
+ of the argument constraints is satisfied.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.op_LogicalNot(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ This operator creates a constraint that is satisfied if the
+ argument constraint is not satisfied.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.After(System.Int32)">
+ <summary>
+ Returns a DelayedConstraint with the specified delay time.
+ </summary>
+ <param name="delayInMilliseconds">The delay in milliseconds.</param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Constraint.After(System.Int32,System.Int32)">
+ <summary>
+ Returns a DelayedConstraint with the specified delay time
+ and polling interval.
+ </summary>
+ <param name="delayInMilliseconds">The delay in milliseconds.</param>
+ <param name="pollingInterval">The interval at which to test the constraint.</param>
+ <returns></returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Constraint.DisplayName">
+ <summary>
+ The display name of this Constraint for use by ToString().
+ The default value is the name of the constraint with
+ trailing "Constraint" removed. Derived classes may set
+ this to another name in their constructors.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Constraint.And">
+ <summary>
+ Returns a ConstraintExpression by appending And
+ to the current constraint.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Constraint.With">
+ <summary>
+ Returns a ConstraintExpression by appending And
+ to the current constraint.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Constraint.Or">
+ <summary>
+ Returns a ConstraintExpression by appending Or
+ to the current constraint.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.Constraint.UnsetObject">
+ <summary>
+ Class used to detect any derived constraints
+ that fail to set the actual value in their
+ Matches override.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.TypeConstraint.expectedType">
+ <summary>
+ The expected Type used by the constraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.TypeConstraint.#ctor(System.Type)">
+ <summary>
+ Construct a TypeConstraint for a given Type
+ </summary>
+ <param name="type"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.TypeConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter. TypeConstraints override this method to write
+ the name of the type.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ExactTypeConstraint">
+ <summary>
+ ExactTypeConstraint is used to test that an object
+ is of the exact type provided in the constructor
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ExactTypeConstraint.#ctor(System.Type)">
+ <summary>
+ Construct an ExactTypeConstraint for a given Type
+ </summary>
+ <param name="type">The expected Type.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ExactTypeConstraint.Matches(System.Object)">
+ <summary>
+ Test that an object is of the exact type specified
+ </summary>
+ <param name="actual">The actual value.</param>
+ <returns>True if the tested object is of the exact type provided, otherwise false.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ExactTypeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer">The MessageWriter to use</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.InstanceOfTypeConstraint">
+ <summary>
+ InstanceOfTypeConstraint is used to test that an object
+ is of the same type provided or derived from it.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.InstanceOfTypeConstraint.#ctor(System.Type)">
+ <summary>
+ Construct an InstanceOfTypeConstraint for the type provided
+ </summary>
+ <param name="type">The expected Type</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.InstanceOfTypeConstraint.Matches(System.Object)">
+ <summary>
+ Test whether an object is of the specified type or a derived type
+ </summary>
+ <param name="actual">The object to be tested</param>
+ <returns>True if the object is of the provided type or derives from it, otherwise false.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.InstanceOfTypeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer">The MessageWriter to use</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.AssignableFromConstraint">
+ <summary>
+ AssignableFromConstraint is used to test that an object
+ can be assigned from a given Type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AssignableFromConstraint.#ctor(System.Type)">
+ <summary>
+ Construct an AssignableFromConstraint for the type provided
+ </summary>
+ <param name="type"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AssignableFromConstraint.Matches(System.Object)">
+ <summary>
+ Test whether an object can be assigned from the specified type
+ </summary>
+ <param name="actual">The object to be tested</param>
+ <returns>True if the object can be assigned a value of the expected Type, otherwise false.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AssignableFromConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer">The MessageWriter to use</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.AssignableToConstraint">
+ <summary>
+ AssignableToConstraint is used to test that an object
+ can be assigned to a given Type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AssignableToConstraint.#ctor(System.Type)">
+ <summary>
+ Construct an AssignableToConstraint for the type provided
+ </summary>
+ <param name="type"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AssignableToConstraint.Matches(System.Object)">
+ <summary>
+ Test whether an object can be assigned to the specified type
+ </summary>
+ <param name="actual">The object to be tested</param>
+ <returns>True if the object can be assigned a value of the expected Type, otherwise false.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AssignableToConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer">The MessageWriter to use</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ConstraintBuilder">
+ <summary>
+ ConstraintBuilder maintains the stacks that are used in
+ processing a ConstraintExpression. An OperatorStack
+ is used to hold operators that are waiting for their
+ operands to be reognized. a ConstraintStack holds
+ input constraints as well as the results of each
+ operator applied.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.#ctor">
+ <summary>
+ Initializes a new instance of the <see cref="T:ConstraintBuilder"/> class.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.Append(NUnit.Framework.Constraints.ConstraintOperator)">
+ <summary>
+ Appends the specified operator to the expression by first
+ reducing the operator stack and then pushing the new
+ operator on the stack.
+ </summary>
+ <param name="op">The operator to push.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.Append(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Appends the specified constraint to the expresson by pushing
+ it on the constraint stack.
+ </summary>
+ <param name="constraint">The constraint to push.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.SetTopOperatorRightContext(System.Object)">
+ <summary>
+ Sets the top operator right context.
+ </summary>
+ <param name="rightContext">The right context.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ReduceOperatorStack(System.Int32)">
+ <summary>
+ Reduces the operator stack until the topmost item
+ precedence is greater than or equal to the target precedence.
+ </summary>
+ <param name="targetPrecedence">The target precedence.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.Resolve">
+ <summary>
+ Resolves this instance, returning a Constraint. If the builder
+ is not currently in a resolvable state, an exception is thrown.
+ </summary>
+ <returns>The resolved constraint</returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.IsResolvable">
+ <summary>
+ Gets a value indicating whether this instance is resolvable.
+ </summary>
+ <value>
+ <c>true</c> if this instance is resolvable; otherwise, <c>false</c>.
+ </value>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack">
+ <summary>
+ OperatorStack is a type-safe stack for holding ConstraintOperators
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">
+ <summary>
+ Initializes a new instance of the <see cref="T:OperatorStack"/> class.
+ </summary>
+ <param name="builder">The builder.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Push(NUnit.Framework.Constraints.ConstraintOperator)">
+ <summary>
+ Pushes the specified operator onto the stack.
+ </summary>
+ <param name="op">The op.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Pop">
+ <summary>
+ Pops the topmost operator from the stack.
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Empty">
+ <summary>
+ Gets a value indicating whether this <see cref="T:OpStack"/> is empty.
+ </summary>
+ <value><c>true</c> if empty; otherwise, <c>false</c>.</value>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Top">
+ <summary>
+ Gets the topmost operator without modifying the stack.
+ </summary>
+ <value>The top.</value>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack">
+ <summary>
+ ConstraintStack is a type-safe stack for holding Constraints
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">
+ <summary>
+ Initializes a new instance of the <see cref="T:ConstraintStack"/> class.
+ </summary>
+ <param name="builder">The builder.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Push(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Pushes the specified constraint. As a side effect,
+ the constraint's builder field is set to the
+ ConstraintBuilder owning this stack.
+ </summary>
+ <param name="constraint">The constraint.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Pop">
+ <summary>
+ Pops this topmost constrait from the stack.
+ As a side effect, the constraint's builder
+ field is set to null.
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Empty">
+ <summary>
+ Gets a value indicating whether this <see cref="T:ConstraintStack"/> is empty.
+ </summary>
+ <value><c>true</c> if empty; otherwise, <c>false</c>.</value>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Top">
+ <summary>
+ Gets the topmost constraint without modifying the stack.
+ </summary>
+ <value>The topmost constraint</value>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ThrowsConstraint">
+ <summary>
+ ThrowsConstraint is used to test the exception thrown by
+ a delegate by applying a constraint to it.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.PrefixConstraint">
+ <summary>
+ Abstract base class used for prefixes
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.PrefixConstraint.baseConstraint">
+ <summary>
+ The base constraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PrefixConstraint.#ctor(NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Construct given a base constraint
+ </summary>
+ <param name="resolvable"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Initializes a new instance of the <see cref="T:ThrowsConstraint"/> class,
+ using a constraint to be applied to the exception.
+ </summary>
+ <param name="baseConstraint">A constraint to apply to the caught exception.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.Matches(System.Object)">
+ <summary>
+ Executes the code of the delegate and captures any exception.
+ If a non-null base constraint was provided, it applies that
+ constraint to the exception.
+ </summary>
+ <param name="actual">A delegate representing the code to be tested</param>
+ <returns>True if an exception is thrown and the constraint succeeds, otherwise false</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.Matches(NUnit.Framework.Constraints.ActualValueDelegate)">
+ <summary>
+ Converts an ActualValueDelegate to a TestDelegate
+ before calling the primary overload.
+ </summary>
+ <param name="del"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter. The default implementation simply writes
+ the raw value of actual, leaving it to the writer to
+ perform any formatting.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.ToString">
+ <summary>
+ Returns the string representation of this constraint
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ThrowsConstraint.ActualException">
+ <summary>
+ Get the actual exception thrown - used by Assert.Throws.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ThrowsNothingConstraint">
+ <summary>
+ ThrowsNothingConstraint tests that a delegate does not
+ throw an exception.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True if no exception is thrown, otherwise false</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter. The default implementation simply writes
+ the raw value of actual, leaving it to the writer to
+ perform any formatting.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.CollectionConstraint">
+ <summary>
+ CollectionConstraint is the abstract base class for
+ constraints that operate on collections.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionConstraint.#ctor">
+ <summary>
+ Construct an empty CollectionConstraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionConstraint.#ctor(System.Object)">
+ <summary>
+ Construct a CollectionConstraint
+ </summary>
+ <param name="arg"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionConstraint.IsEmpty(System.Collections.IEnumerable)">
+ <summary>
+ Determines whether the specified enumerable is empty.
+ </summary>
+ <param name="enumerable">The enumerable.</param>
+ <returns>
+ <c>true</c> if the specified enumerable is empty; otherwise, <c>false</c>.
+ </returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionConstraint.doMatch(System.Collections.IEnumerable)">
+ <summary>
+ Protected method to be implemented by derived classes
+ </summary>
+ <param name="collection"></param>
+ <returns></returns>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.CollectionItemsEqualConstraint">
+ <summary>
+ CollectionItemsEqualConstraint is the abstract base class for all
+ collection constraints that apply some notion of item equality
+ as a part of their operation.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.#ctor">
+ <summary>
+ Construct an empty CollectionConstraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.#ctor(System.Object)">
+ <summary>
+ Construct a CollectionConstraint
+ </summary>
+ <param name="arg"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using(System.Collections.IComparer)">
+ <summary>
+ Flag the constraint to use the supplied IComparer object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
+ <summary>
+ Flag the constraint to use the supplied IComparer object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using``1(System.Comparison{``0})">
+ <summary>
+ Flag the constraint to use the supplied Comparison object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using(System.Collections.IEqualityComparer)">
+ <summary>
+ Flag the constraint to use the supplied IEqualityComparer object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using``1(System.Collections.Generic.IEqualityComparer{``0})">
+ <summary>
+ Flag the constraint to use the supplied IEqualityComparer object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.ItemsEqual(System.Object,System.Object)">
+ <summary>
+ Compares two collection members for equality
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Tally(System.Collections.IEnumerable)">
+ <summary>
+ Return a new CollectionTally for use in making tests
+ </summary>
+ <param name="c">The collection to be included in the tally</param>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.IgnoreCase">
+ <summary>
+ Flag the constraint to ignore case and return self.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.CollectionTally">
+ <summary>
+ CollectionTally counts (tallies) the number of
+ occurences of each object in one or more enumerations.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.CollectionTally.#ctor(NUnit.Framework.Constraints.NUnitEqualityComparer,System.Collections.IEnumerable)">
+ <summary>
+ Construct a CollectionTally object from a comparer and a collection
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.CollectionTally.TryRemove(System.Object)">
+ <summary>
+ Try to remove an object from the tally
+ </summary>
+ <param name="o">The object to remove</param>
+ <returns>True if successful, false if the object was not found</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.CollectionTally.TryRemove(System.Collections.IEnumerable)">
+ <summary>
+ Try to remove a set of objects from the tally
+ </summary>
+ <param name="c">The objects to remove</param>
+ <returns>True if successful, false if any object was not found</returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.CollectionTally.Count">
+ <summary>
+ The number of objects remaining in the tally
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.EmptyCollectionConstraint">
+ <summary>
+ EmptyCollectionConstraint tests whether a collection is empty.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EmptyCollectionConstraint.doMatch(System.Collections.IEnumerable)">
+ <summary>
+ Check that the collection is empty
+ </summary>
+ <param name="collection"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EmptyCollectionConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.UniqueItemsConstraint">
+ <summary>
+ UniqueItemsConstraint tests whether all the items in a
+ collection are unique.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.UniqueItemsConstraint.doMatch(System.Collections.IEnumerable)">
+ <summary>
+ Check that all items are unique.
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.UniqueItemsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.CollectionContainsConstraint">
+ <summary>
+ CollectionContainsConstraint is used to test whether a collection
+ contains an expected object as a member.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionContainsConstraint.#ctor(System.Object)">
+ <summary>
+ Construct a CollectionContainsConstraint
+ </summary>
+ <param name="expected"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionContainsConstraint.doMatch(System.Collections.IEnumerable)">
+ <summary>
+ Test whether the expected item is contained in the collection
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionContainsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a descripton of the constraint to a MessageWriter
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.CollectionEquivalentConstraint">
+ <summary>
+ CollectionEquivalentCOnstraint is used to determine whether two
+ collections are equivalent.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionEquivalentConstraint.#ctor(System.Collections.IEnumerable)">
+ <summary>
+ Construct a CollectionEquivalentConstraint
+ </summary>
+ <param name="expected"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionEquivalentConstraint.doMatch(System.Collections.IEnumerable)">
+ <summary>
+ Test whether two collections are equivalent
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionEquivalentConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.CollectionSubsetConstraint">
+ <summary>
+ CollectionSubsetConstraint is used to determine whether
+ one collection is a subset of another
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionSubsetConstraint.#ctor(System.Collections.IEnumerable)">
+ <summary>
+ Construct a CollectionSubsetConstraint
+ </summary>
+ <param name="expected">The collection that the actual value is expected to be a subset of</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionSubsetConstraint.doMatch(System.Collections.IEnumerable)">
+ <summary>
+ Test whether the actual collection is a subset of
+ the expected collection provided.
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionSubsetConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.CollectionOrderedConstraint">
+ <summary>
+ CollectionOrderedConstraint is used to test whether a collection is ordered.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.#ctor">
+ <summary>
+ Construct a CollectionOrderedConstraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.Using(System.Collections.IComparer)">
+ <summary>
+ Modifies the constraint to use an IComparer and returns self.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
+ <summary>
+ Modifies the constraint to use an IComparer<T> and returns self.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.Using``1(System.Comparison{``0})">
+ <summary>
+ Modifies the constraint to use a Comparison<T> and returns self.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.By(System.String)">
+ <summary>
+ Modifies the constraint to test ordering by the value of
+ a specified property and returns self.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.doMatch(System.Collections.IEnumerable)">
+ <summary>
+ Test whether the collection is ordered
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of the constraint to a MessageWriter
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.ToString">
+ <summary>
+ Returns the string representation of the constraint.
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.CollectionOrderedConstraint.Descending">
+ <summary>
+ If used performs a reverse comparison
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.EmptyDirectoryContraint">
+ <summary>
+ EmptyDirectoryConstraint is used to test that a directory is empty
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EmptyDirectoryContraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EmptyDirectoryContraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EmptyDirectoryContraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter. The default implementation simply writes
+ the raw value of actual, leaving it to the writer to
+ perform any formatting.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.SubDirectoryConstraint">
+ <summary>
+ SubDirectoryConstraint is used to test that one directory is a subdirectory of another.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SubDirectoryConstraint.#ctor(System.IO.DirectoryInfo)">
+ <summary>
+ Initializes a new instance of the <see cref="T:SubDirectoryConstraint"/> class.
+ </summary>
+ <param name="dirInfo">The dir info.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SubDirectoryConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SubDirectoryConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SubDirectoryConstraint.BuildDirectoryList(System.IO.DirectoryInfo)">
+ <summary>
+ Builds a list of DirectoryInfo objects, recursing where necessary
+ </summary>
+ <param name="StartingDirectory">directory to recurse</param>
+ <returns>list of DirectoryInfo objects from the top level</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SubDirectoryConstraint.IsDirectoryOnPath(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
+ <summary>
+ private method to determine whether a directory is within the path
+ </summary>
+ <param name="ParentDirectory">top-level directory to search</param>
+ <param name="SearchDirectory">directory to search for</param>
+ <returns>true if found, false if not</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SubDirectoryConstraint.DirectoriesEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
+ <summary>
+ Method to compare two DirectoryInfo objects
+ </summary>
+ <param name="expected">first directory to compare</param>
+ <param name="actual">second directory to compare</param>
+ <returns>true if equivalent, false if not</returns>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.PathConstraint">
+ <summary>
+ PathConstraint serves as the abstract base of constraints
+ that operate on paths and provides several helper methods.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.PathConstraint.expected">
+ <summary>
+ The expected path used in the constraint
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.PathConstraint.caseInsensitive">
+ <summary>
+ Flag indicating whether a caseInsensitive comparison should be made
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PathConstraint.#ctor(System.String)">
+ <summary>
+ Construct a PathConstraint for a give expected path
+ </summary>
+ <param name="expected">The expected path</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PathConstraint.ToString">
+ <summary>
+ Returns the string representation of this constraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PathConstraint.Canonicalize(System.String)">
+ <summary>
+ Canonicalize the provided path
+ </summary>
+ <param name="path"></param>
+ <returns>The path in standardized form</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PathConstraint.IsSamePath(System.String,System.String)">
+ <summary>
+ Test whether two paths are the same
+ </summary>
+ <param name="path1">The first path</param>
+ <param name="path2">The second path</param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PathConstraint.IsSamePathOrUnder(System.String,System.String)">
+ <summary>
+ Test whether one path is the same as or under another path
+ </summary>
+ <param name="path1">The first path - supposed to be the parent path</param>
+ <param name="path2">The second path - supposed to be the child path</param>
+ <returns></returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.PathConstraint.IgnoreCase">
+ <summary>
+ Modifies the current instance to be case-insensitve
+ and returns it.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.PathConstraint.RespectCase">
+ <summary>
+ Modifies the current instance to be case-sensitve
+ and returns it.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.SamePathConstraint">
+ <summary>
+ Summary description for SamePathConstraint.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SamePathConstraint.#ctor(System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:SamePathConstraint"/> class.
+ </summary>
+ <param name="expected">The expected path</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SamePathConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SamePathConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.SamePathOrUnderConstraint">
+ <summary>
+ SamePathOrUnderConstraint tests that one path is under another
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SamePathOrUnderConstraint.#ctor(System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:SamePathOrUnderConstraint"/> class.
+ </summary>
+ <param name="expected">The expected path</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SamePathOrUnderConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SamePathOrUnderConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.PropertyExistsConstraint">
+ <summary>
+ PropertyExistsConstraint tests that a named property
+ exists on the object provided through Match.
+
+ Originally, PropertyConstraint provided this feature
+ in addition to making optional tests on the vaue
+ of the property. The two constraints are now separate.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.#ctor(System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:PropertyExistConstraint"/> class.
+ </summary>
+ <param name="name">The name of the property.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the property exists for a given object
+ </summary>
+ <param name="actual">The object to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.ToString">
+ <summary>
+ Returns the string representation of the constraint.
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.PropertyConstraint">
+ <summary>
+ PropertyConstraint extracts a named property and uses
+ its value as the actual value for a chained constraint.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyConstraint.#ctor(System.String,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Initializes a new instance of the <see cref="T:PropertyConstraint"/> class.
+ </summary>
+ <param name="name">The name.</param>
+ <param name="baseConstraint">The constraint to apply to the property.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter. The default implementation simply writes
+ the raw value of actual, leaving it to the writer to
+ perform any formatting.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropertyConstraint.ToString">
+ <summary>
+ Returns the string representation of the constraint.
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ConstraintExpression">
+ <summary>
+ ConstraintExpression represents a compound constraint in the
+ process of being constructed from a series of syntactic elements.
+
+ Individual elements are appended to the expression as they are
+ reognized. Once an actual Constraint is appended, the expression
+ returns a resolvable Constraint.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ConstraintExpressionBase">
+ <summary>
+ ConstraintExpressionBase is the abstract base class for the
+ generated ConstraintExpression class, which represents a
+ compound constraint in the process of being constructed
+ from a series of syntactic elements.
+
+ NOTE: ConstraintExpressionBase is aware of some of its
+ derived classes, which is an apparent violation of
+ encapsulation. Ideally, these classes would be a
+ single class, but they must be separated in order to
+ allow parts to be generated under .NET 1.x and to
+ provide proper user feedback in syntactically
+ aware IDEs.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ConstraintExpressionBase.builder">
+ <summary>
+ The ConstraintBuilder holding the elements recognized so far
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.#ctor">
+ <summary>
+ Initializes a new instance of the <see cref="T:ConstraintExpressionBase"/> class.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">
+ <summary>
+ Initializes a new instance of the <see cref="T:ConstraintExpressionBase"/>
+ class passing in a ConstraintBuilder, which may be pre-populated.
+ </summary>
+ <param name="builder">The builder.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.ToString">
+ <summary>
+ Returns a string representation of the expression as it
+ currently stands. This should only be used for testing,
+ since it has the side-effect of resolving the expression.
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.Append(NUnit.Framework.Constraints.ConstraintOperator)">
+ <summary>
+ Appends an operator to the expression and returns the
+ resulting expression itself.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.Append(NUnit.Framework.Constraints.SelfResolvingOperator)">
+ <summary>
+ Appends a self-resolving operator to the expression and
+ returns a new ResolvableConstraintExpression.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.Append(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Appends a constraint to the expression and returns that
+ constraint, which is associated with the current state
+ of the expression being built.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.#ctor">
+ <summary>
+ Initializes a new instance of the <see cref="T:ConstraintExpression"/> class.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">
+ <summary>
+ Initializes a new instance of the <see cref="T:ConstraintExpression"/>
+ class passing in a ConstraintBuilder, which may be pre-populated.
+ </summary>
+ <param name="builder">The builder.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Property(System.String)">
+ <summary>
+ Returns a new PropertyConstraintExpression, which will either
+ test for the existence of the named property on the object
+ being tested or apply any following constraint to that property.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Attribute(System.Type)">
+ <summary>
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Attribute``1">
+ <summary>
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Matches(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Returns the constraint provided as an argument - used to allow custom
+ custom constraints to easily participate in the syntax.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Matches``1(System.Predicate{``0})">
+ <summary>
+ Returns the constraint provided as an argument - used to allow custom
+ custom constraints to easily participate in the syntax.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.EqualTo(System.Object)">
+ <summary>
+ Returns a constraint that tests two items for equality
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SameAs(System.Object)">
+ <summary>
+ Returns a constraint that tests that two references are the same object
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.GreaterThan(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is greater than the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.GreaterThanOrEqualTo(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AtLeast(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.LessThan(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is less than the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.LessThanOrEqualTo(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AtMost(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.TypeOf(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.TypeOf``1">
+ <summary>
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOf(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOf``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOfType(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOfType``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableFrom(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableFrom``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableTo(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableTo``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.EquivalentTo(System.Collections.IEnumerable)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is a collection containing the same elements as the
+ collection supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SubsetOf(System.Collections.IEnumerable)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is a subset of the collection supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Member(System.Object)">
+ <summary>
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Contains(System.Object)">
+ <summary>
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Contains(System.String)">
+ <summary>
+ Returns a new ContainsConstraint. This constraint
+ will, in turn, make use of the appropriate second-level
+ constraint, depending on the type of the actual argument.
+ This overload is only used if the item sought is a string,
+ since any other type implies that we are looking for a
+ collection member.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringContaining(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.ContainsSubstring(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StartsWith(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringStarting(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.EndsWith(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringEnding(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Matches(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringMatching(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SamePath(System.String)">
+ <summary>
+ Returns a constraint that tests whether the path provided
+ is the same as an expected path after canonicalization.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SamePathOrUnder(System.String)">
+ <summary>
+ Returns a constraint that tests whether the path provided
+ is the same path or under an expected path after canonicalization.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InRange(System.IComparable,System.IComparable)">
+ <summary>
+ Returns a constraint that tests whether the actual value falls
+ within a specified range.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Not">
+ <summary>
+ Returns a ConstraintExpression that negates any
+ following constraint.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.No">
+ <summary>
+ Returns a ConstraintExpression that negates any
+ following constraint.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.All">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Some">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if at least one of them succeeds.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.None">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them fail.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Length">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Length property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Count">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Count property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Message">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Message property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.InnerException">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the InnerException property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.With">
+ <summary>
+ With is currently a NOP - reserved for future use.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Null">
+ <summary>
+ Returns a constraint that tests for null
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.True">
+ <summary>
+ Returns a constraint that tests for True
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.False">
+ <summary>
+ Returns a constraint that tests for False
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.NaN">
+ <summary>
+ Returns a constraint that tests for NaN
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Empty">
+ <summary>
+ Returns a constraint that tests for empty
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Unique">
+ <summary>
+ Returns a constraint that tests whether a collection
+ contains all unique items.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.BinarySerializable">
+ <summary>
+ Returns a constraint that tests whether an object graph is serializable in binary format.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.XmlSerializable">
+ <summary>
+ Returns a constraint that tests whether an object graph is serializable in xml format.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Ordered">
+ <summary>
+ Returns a constraint that tests whether a collection is ordered
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.RangeConstraint">
+ <summary>
+ RangeConstraint tests whethe two values are within a
+ specified range.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.RangeConstraint.#ctor(System.IComparable,System.IComparable)">
+ <summary>
+ Initializes a new instance of the <see cref="T:RangeConstraint"/> class.
+ </summary>
+ <param name="from">From.</param>
+ <param name="to">To.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.RangeConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.RangeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.RangeConstraint.Using(System.Collections.IComparer)">
+ <summary>
+ Modifies the constraint to use an IComparer and returns self.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.RangeConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
+ <summary>
+ Modifies the constraint to use an IComparer<T> and returns self.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.RangeConstraint.Using``1(System.Comparison{``0})">
+ <summary>
+ Modifies the constraint to use a Comparison<T> and returns self.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.EqualConstraint">
+ <summary>
+ EqualConstraint is able to compare an actual value with the
+ expected value provided in its constructor. Two objects are
+ considered equal if both are null, or if both have the same
+ value. NUnit has special semantics for some object types.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.EqualConstraint.clipStrings">
+ <summary>
+ If true, strings in error messages will be clipped
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.EqualConstraint.comparer">
+ <summary>
+ NUnitEqualityComparer used to test equality.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.#ctor(System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:NUnit.Framework.Constraints.EqualConstraint"/> class.
+ </summary>
+ <param name="expected">The expected value.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.Within(System.Object)">
+ <summary>
+ Flag the constraint to use a tolerance when determining equality.
+ </summary>
+ <param name="amount">Tolerance value to be used</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.Comparer(System.Collections.IComparer)">
+ <summary>
+ Flag the constraint to use the supplied IComparer object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using(System.Collections.IComparer)">
+ <summary>
+ Flag the constraint to use the supplied IComparer object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
+ <summary>
+ Flag the constraint to use the supplied IComparer object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using``1(System.Comparison{``0})">
+ <summary>
+ Flag the constraint to use the supplied Comparison object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using(System.Collections.IEqualityComparer)">
+ <summary>
+ Flag the constraint to use the supplied IEqualityComparer object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using``1(System.Collections.Generic.IEqualityComparer{``0})">
+ <summary>
+ Flag the constraint to use the supplied IEqualityComparer object.
+ </summary>
+ <param name="comparer">The IComparer object to use.</param>
+ <returns>Self.</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.WriteMessageTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a failure message. Overridden to provide custom
+ failure messages for EqualConstraint.
+ </summary>
+ <param name="writer">The MessageWriter to write to</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write description of this constraint
+ </summary>
+ <param name="writer">The MessageWriter to write to</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.DisplayCollectionDifferences(NUnit.Framework.Constraints.MessageWriter,System.Collections.ICollection,System.Collections.ICollection,System.Int32)">
+ <summary>
+ Display the failure information for two collections that did not match.
+ </summary>
+ <param name="writer">The MessageWriter on which to display</param>
+ <param name="expected">The expected collection.</param>
+ <param name="actual">The actual collection</param>
+ <param name="depth">The depth of this failure in a set of nested collections</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.DisplayCollectionTypesAndSizes(NUnit.Framework.Constraints.MessageWriter,System.Collections.ICollection,System.Collections.ICollection,System.Int32)">
+ <summary>
+ Displays a single line showing the types and sizes of the expected
+ and actual collections or arrays. If both are identical, the value is
+ only shown once.
+ </summary>
+ <param name="writer">The MessageWriter on which to display</param>
+ <param name="expected">The expected collection or array</param>
+ <param name="actual">The actual collection or array</param>
+ <param name="indent">The indentation level for the message line</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualConstraint.DisplayFailurePoint(NUnit.Framework.Constraints.MessageWriter,System.Collections.ICollection,System.Collections.ICollection,System.Int32,System.Int32)">
+ <summary>
+ Displays a single line showing the point in the expected and actual
+ arrays at which the comparison failed. If the arrays have different
+ structures or dimensions, both values are shown.
+ </summary>
+ <param name="writer">The MessageWriter on which to display</param>
+ <param name="expected">The expected array</param>
+ <param name="actual">The actual array</param>
+ <param name="failurePoint">Index of the failure point in the underlying collections</param>
+ <param name="indent">The indentation level for the message line</param>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.IgnoreCase">
+ <summary>
+ Flag the constraint to ignore case and return self.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.NoClip">
+ <summary>
+ Flag the constraint to suppress string clipping
+ and return self.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.AsCollection">
+ <summary>
+ Flag the constraint to compare arrays as collections
+ and return self.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.Ulps">
+ <summary>
+ Switches the .Within() modifier to interpret its tolerance as
+ a distance in representable values (see remarks).
+ </summary>
+ <returns>Self.</returns>
+ <remarks>
+ Ulp stands for "unit in the last place" and describes the minimum
+ amount a given value can change. For any integers, an ulp is 1 whole
+ digit. For floating point values, the accuracy of which is better
+ for smaller numbers and worse for larger numbers, an ulp depends
+ on the size of the number. Using ulps for comparison of floating
+ point results instead of fixed tolerances is safer because it will
+ automatically compensate for the added inaccuracy of larger numbers.
+ </remarks>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.Percent">
+ <summary>
+ Switches the .Within() modifier to interpret its tolerance as
+ a percentage that the actual values is allowed to deviate from
+ the expected value.
+ </summary>
+ <returns>Self</returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.Days">
+ <summary>
+ Causes the tolerance to be interpreted as a TimeSpan in days.
+ </summary>
+ <returns>Self</returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.Hours">
+ <summary>
+ Causes the tolerance to be interpreted as a TimeSpan in hours.
+ </summary>
+ <returns>Self</returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.Minutes">
+ <summary>
+ Causes the tolerance to be interpreted as a TimeSpan in minutes.
+ </summary>
+ <returns>Self</returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.Seconds">
+ <summary>
+ Causes the tolerance to be interpreted as a TimeSpan in seconds.
+ </summary>
+ <returns>Self</returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.Milliseconds">
+ <summary>
+ Causes the tolerance to be interpreted as a TimeSpan in milliseconds.
+ </summary>
+ <returns>Self</returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.EqualConstraint.Ticks">
+ <summary>
+ Causes the tolerance to be interpreted as a TimeSpan in clock ticks.
+ </summary>
+ <returns>Self</returns>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.NotConstraint">
+ <summary>
+ NotConstraint negates the effect of some other constraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NotConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Initializes a new instance of the <see cref="T:NotConstraint"/> class.
+ </summary>
+ <param name="baseConstraint">The base constraint to be negated.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NotConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for if the base constraint fails, false if it succeeds</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NotConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NotConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a MessageWriter.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.AllItemsConstraint">
+ <summary>
+ AllItemsConstraint applies another constraint to each
+ item in a collection, succeeding if they all succeed.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AllItemsConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Construct an AllItemsConstraint on top of an existing constraint
+ </summary>
+ <param name="itemConstraint"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AllItemsConstraint.Matches(System.Object)">
+ <summary>
+ Apply the item constraint to each item in the collection,
+ failing if any item fails.
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AllItemsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.SomeItemsConstraint">
+ <summary>
+ SomeItemsConstraint applies another constraint to each
+ item in a collection, succeeding if any of them succeeds.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SomeItemsConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Construct a SomeItemsConstraint on top of an existing constraint
+ </summary>
+ <param name="itemConstraint"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SomeItemsConstraint.Matches(System.Object)">
+ <summary>
+ Apply the item constraint to each item in the collection,
+ succeeding if any item succeeds.
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SomeItemsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.NoItemConstraint">
+ <summary>
+ NoItemConstraint applies another constraint to each
+ item in a collection, failing if any of them succeeds.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NoItemConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Construct a SomeItemsConstraint on top of an existing constraint
+ </summary>
+ <param name="itemConstraint"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NoItemConstraint.Matches(System.Object)">
+ <summary>
+ Apply the item constraint to each item in the collection,
+ failing if any item fails.
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NoItemConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description of this constraint to a MessageWriter
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ContainsConstraint">
+ <summary>
+ ContainsConstraint tests a whether a string contains a substring
+ or a collection contains an object. It postpones the decision of
+ which test to use until the type of the actual argument is known.
+ This allows testing whether a string is contained in a collection
+ or as a substring of another string using the same syntax.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ContainsConstraint.#ctor(System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:ContainsConstraint"/> class.
+ </summary>
+ <param name="expected">The expected.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ContainsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ContainsConstraint.IgnoreCase">
+ <summary>
+ Flag the constraint to ignore case and return self.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.MsgUtils">
+ <summary>
+ Static methods used in creating messages
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.MsgUtils.ELLIPSIS">
+ <summary>
+ Static string used when strings are clipped
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MsgUtils.GetTypeRepresentation(System.Object)">
+ <summary>
+ Returns the representation of a type as used in NUnitLite.
+ This is the same as Type.ToString() except for arrays,
+ which are displayed with their declared sizes.
+ </summary>
+ <param name="obj"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MsgUtils.EscapeControlChars(System.String)">
+ <summary>
+ Converts any control characters in a string
+ to their escaped representation.
+ </summary>
+ <param name="s">The string to be converted</param>
+ <returns>The converted string</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MsgUtils.GetArrayIndicesAsString(System.Int32[])">
+ <summary>
+ Return the a string representation for a set of indices into an array
+ </summary>
+ <param name="indices">Array of indices for which a string is needed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MsgUtils.GetArrayIndicesFromCollectionIndex(System.Collections.ICollection,System.Int32)">
+ <summary>
+ Get an array of indices representing the point in a collection or
+ array corresponding to a single int index into the collection.
+ </summary>
+ <param name="collection">The collection to which the indices apply</param>
+ <param name="index">Index in the collection</param>
+ <returns>Array of indices</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MsgUtils.ClipString(System.String,System.Int32,System.Int32)">
+ <summary>
+ Clip a string to a given length, starting at a particular offset, returning the clipped
+ string with ellipses representing the removed parts
+ </summary>
+ <param name="s">The string to be clipped</param>
+ <param name="maxStringLength">The maximum permitted length of the result string</param>
+ <param name="clipStart">The point at which to start clipping</param>
+ <returns>The clipped string</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MsgUtils.ClipExpectedAndActual(System.String@,System.String@,System.Int32,System.Int32)">
+ <summary>
+ Clip the expected and actual strings in a coordinated fashion,
+ so that they may be displayed together.
+ </summary>
+ <param name="expected"></param>
+ <param name="actual"></param>
+ <param name="maxDisplayLength"></param>
+ <param name="mismatch"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MsgUtils.FindMismatchPosition(System.String,System.String,System.Int32,System.Boolean)">
+ <summary>
+ Shows the position two strings start to differ. Comparison
+ starts at the start index.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The actual string</param>
+ <param name="istart">The index in the strings at which comparison should start</param>
+ <param name="ignoreCase">Boolean indicating whether case should be ignored</param>
+ <returns>-1 if no mismatch found, or the index where mismatch found</returns>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.BasicConstraint">
+ <summary>
+ BasicConstraint is the abstract base for constraints that
+ perform a simple comparison to a constant value.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BasicConstraint.#ctor(System.Object,System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:BasicConstraint"/> class.
+ </summary>
+ <param name="expected">The expected.</param>
+ <param name="description">The description.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BasicConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BasicConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.NullConstraint">
+ <summary>
+ NullConstraint tests that the actual value is null
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NullConstraint.#ctor">
+ <summary>
+ Initializes a new instance of the <see cref="T:NullConstraint"/> class.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.TrueConstraint">
+ <summary>
+ TrueConstraint tests that the actual value is true
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.TrueConstraint.#ctor">
+ <summary>
+ Initializes a new instance of the <see cref="T:TrueConstraint"/> class.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.FalseConstraint">
+ <summary>
+ FalseConstraint tests that the actual value is false
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.FalseConstraint.#ctor">
+ <summary>
+ Initializes a new instance of the <see cref="T:FalseConstraint"/> class.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.NaNConstraint">
+ <summary>
+ NaNConstraint tests that the actual value is a double or float NaN
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NaNConstraint.Matches(System.Object)">
+ <summary>
+ Test that the actual value is an NaN
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NaNConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a specified writer
+ </summary>
+ <param name="writer"></param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.MessageWriter">
+ <summary>
+ MessageWriter is the abstract base for classes that write
+ constraint descriptions and messages in some form. The
+ class has separate methods for writing various components
+ of a message, allowing implementations to tailor the
+ presentation as needed.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.#ctor">
+ <summary>
+ Construct a MessageWriter given a culture
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteMessageLine(System.String,System.Object[])">
+ <summary>
+ Method to write single line message with optional args, usually
+ written to precede the general failure message.
+ </summary>
+ <param name="message">The message to be written</param>
+ <param name="args">Any arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteMessageLine(System.Int32,System.String,System.Object[])">
+ <summary>
+ Method to write single line message with optional args, usually
+ written to precede the general failure message, at a givel
+ indentation level.
+ </summary>
+ <param name="level">The indentation level of the message</param>
+ <param name="message">The message to be written</param>
+ <param name="args">Any arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayDifferences(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Display Expected and Actual lines for a constraint. This
+ is called by MessageWriter's default implementation of
+ WriteMessageTo and provides the generic two-line display.
+ </summary>
+ <param name="constraint">The constraint that failed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayDifferences(System.Object,System.Object)">
+ <summary>
+ Display Expected and Actual lines for given values. This
+ method may be called by constraints that need more control over
+ the display of actual and expected values than is provided
+ by the default implementation.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value causing the failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayDifferences(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance)">
+ <summary>
+ Display Expected and Actual lines for given values, including
+ a tolerance value on the Expected line.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value causing the failure</param>
+ <param name="tolerance">The tolerance within which the test was made</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayStringDifferences(System.String,System.String,System.Int32,System.Boolean,System.Boolean)">
+ <summary>
+ Display the expected and actual string values on separate lines.
+ If the mismatch parameter is >=0, an additional line is displayed
+ line containing a caret that points to the mismatch point.
+ </summary>
+ <param name="expected">The expected string value</param>
+ <param name="actual">The actual string value</param>
+ <param name="mismatch">The point at which the strings don't match or -1</param>
+ <param name="ignoreCase">If true, case is ignored in locating the point where the strings differ</param>
+ <param name="clipping">If true, the strings should be clipped to fit the line</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteConnector(System.String)">
+ <summary>
+ Writes the text for a connector.
+ </summary>
+ <param name="connector">The connector.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.WritePredicate(System.String)">
+ <summary>
+ Writes the text for a predicate.
+ </summary>
+ <param name="predicate">The predicate.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteExpectedValue(System.Object)">
+ <summary>
+ Writes the text for an expected value.
+ </summary>
+ <param name="expected">The expected value.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteModifier(System.String)">
+ <summary>
+ Writes the text for a modifier
+ </summary>
+ <param name="modifier">The modifier.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteActualValue(System.Object)">
+ <summary>
+ Writes the text for an actual value.
+ </summary>
+ <param name="actual">The actual value.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteValue(System.Object)">
+ <summary>
+ Writes the text for a generalized value.
+ </summary>
+ <param name="val">The value.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteCollectionElements(System.Collections.ICollection,System.Int32,System.Int32)">
+ <summary>
+ Writes the text for a collection value,
+ starting at a particular point, to a max length
+ </summary>
+ <param name="collection">The collection containing elements to write.</param>
+ <param name="start">The starting point of the elements to write</param>
+ <param name="max">The maximum number of elements to write</param>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.MessageWriter.MaxLineLength">
+ <summary>
+ Abstract method to get the max line length
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ToleranceMode">
+ <summary>
+ Modes in which the tolerance value for a comparison can
+ be interpreted.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ToleranceMode.None">
+ <summary>
+ The tolerance was created with a value, without specifying
+ how the value would be used. This is used to prevent setting
+ the mode more than once and is generally changed to Linear
+ upon execution of the test.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ToleranceMode.Linear">
+ <summary>
+ The tolerance is used as a numeric range within which
+ two compared values are considered to be equal.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ToleranceMode.Percent">
+ <summary>
+ Interprets the tolerance as the percentage by which
+ the two compared values my deviate from each other.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ToleranceMode.Ulps">
+ <summary>
+ Compares two values based in their distance in
+ representable numbers.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.Tolerance">
+ <summary>
+ The Tolerance class generalizes the notion of a tolerance
+ within which an equality test succeeds. Normally, it is
+ used with numeric types, but it can be used with any
+ type that supports taking a difference between two
+ objects and comparing that difference to a value.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Tolerance.#ctor(System.Object)">
+ <summary>
+ Constructs a linear tolerance of a specdified amount
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Tolerance.#ctor(System.Object,NUnit.Framework.Constraints.ToleranceMode)">
+ <summary>
+ Constructs a tolerance given an amount and ToleranceMode
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Tolerance.CheckLinearAndNumeric">
+ <summary>
+ Tests that the current Tolerance is linear with a
+ numeric value, throwing an exception if it is not.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Empty">
+ <summary>
+ Returns an empty Tolerance object, equivalent to
+ specifying an exact match.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Mode">
+ <summary>
+ Gets the ToleranceMode for the current Tolerance
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Value">
+ <summary>
+ Gets the value of the current Tolerance instance.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Percent">
+ <summary>
+ Returns a new tolerance, using the current amount as a percentage.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Ulps">
+ <summary>
+ Returns a new tolerance, using the current amount in Ulps.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Days">
+ <summary>
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of days.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Hours">
+ <summary>
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of hours.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Minutes">
+ <summary>
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of minutes.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Seconds">
+ <summary>
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of seconds.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Milliseconds">
+ <summary>
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of milliseconds.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.Ticks">
+ <summary>
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of clock ticks.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.Tolerance.IsEmpty">
+ <summary>
+ Returns true if the current tolerance is empty.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.Numerics">
+ <summary>
+ The Numerics class contains common operations on numeric values.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Numerics.IsNumericType(System.Object)">
+ <summary>
+ Checks the type of the object, returning true if
+ the object is a numeric type.
+ </summary>
+ <param name="obj">The object to check</param>
+ <returns>true if the object is a numeric type</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Numerics.IsFloatingPointNumeric(System.Object)">
+ <summary>
+ Checks the type of the object, returning true if
+ the object is a floating point numeric type.
+ </summary>
+ <param name="obj">The object to check</param>
+ <returns>true if the object is a floating point numeric type</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Numerics.IsFixedPointNumeric(System.Object)">
+ <summary>
+ Checks the type of the object, returning true if
+ the object is a fixed point numeric type.
+ </summary>
+ <param name="obj">The object to check</param>
+ <returns>true if the object is a fixed point numeric type</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Numerics.AreEqual(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance@)">
+ <summary>
+ Test two numeric values for equality, performing the usual numeric
+ conversions and using a provided or default tolerance. If the tolerance
+ provided is Empty, this method may set it to a default tolerance.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="tolerance">A reference to the tolerance in effect</param>
+ <returns>True if the values are equal</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.Numerics.Compare(System.Object,System.Object)">
+ <summary>
+ Compare two numeric values, performing the usual numeric conversions.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <returns>The relationship of the values to each other</returns>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.EmptyConstraint">
+ <summary>
+ EmptyConstraint tests a whether a string or collection is empty,
+ postponing the decision about which test is applied until the
+ type of the actual argument is known.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EmptyConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EmptyConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.StringConstraint">
+ <summary>
+ StringConstraint is the abstract base for constraints
+ that operate on strings. It supports the IgnoreCase
+ modifier for string operations.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.StringConstraint.expected">
+ <summary>
+ The expected value
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.StringConstraint.caseInsensitive">
+ <summary>
+ Indicates whether tests should be case-insensitive
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.StringConstraint.#ctor(System.String)">
+ <summary>
+ Constructs a StringConstraint given an expected value
+ </summary>
+ <param name="expected">The expected value</param>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.StringConstraint.IgnoreCase">
+ <summary>
+ Modify the constraint to ignore case in matching.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.EmptyStringConstraint">
+ <summary>
+ EmptyStringConstraint tests whether a string is empty.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EmptyStringConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EmptyStringConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.NullOrEmptyStringConstraint">
+ <summary>
+ NullEmptyStringConstraint tests whether a string is either null or empty.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NullOrEmptyStringConstraint.#ctor">
+ <summary>
+ Constructs a new NullOrEmptyStringConstraint
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NullOrEmptyStringConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NullOrEmptyStringConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.SubstringConstraint">
+ <summary>
+ SubstringConstraint can test whether a string contains
+ the expected substring.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SubstringConstraint.#ctor(System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:SubstringConstraint"/> class.
+ </summary>
+ <param name="expected">The expected.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SubstringConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SubstringConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.StartsWithConstraint">
+ <summary>
+ StartsWithConstraint can test whether a string starts
+ with an expected substring.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.StartsWithConstraint.#ctor(System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:StartsWithConstraint"/> class.
+ </summary>
+ <param name="expected">The expected string</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.StartsWithConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is matched by the actual value.
+ This is a template method, which calls the IsMatch method
+ of the derived class.
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.StartsWithConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.EndsWithConstraint">
+ <summary>
+ EndsWithConstraint can test whether a string ends
+ with an expected substring.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EndsWithConstraint.#ctor(System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:EndsWithConstraint"/> class.
+ </summary>
+ <param name="expected">The expected string</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EndsWithConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is matched by the actual value.
+ This is a template method, which calls the IsMatch method
+ of the derived class.
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EndsWithConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.RegexConstraint">
+ <summary>
+ RegexConstraint can test whether a string matches
+ the pattern provided.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.RegexConstraint.#ctor(System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:RegexConstraint"/> class.
+ </summary>
+ <param name="pattern">The pattern.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.RegexConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.RegexConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ComparisonConstraint">
+ <summary>
+ Abstract base class for constraints that compare values to
+ determine if one is greater than, equal to or less than
+ the other.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.expected">
+ <summary>
+ The value against which a comparison is to be made
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.ltOK">
+ <summary>
+ If true, less than returns success
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.eqOK">
+ <summary>
+ if true, equal returns success
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.gtOK">
+ <summary>
+ if true, greater than returns success
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.predicate">
+ <summary>
+ The predicate used as a part of the description
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.comparer">
+ <summary>
+ ComparisonAdapter to be used in making the comparison
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.#ctor(System.Object,System.Boolean,System.Boolean,System.Boolean,System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:ComparisonConstraint"/> class.
+ </summary>
+ <param name="value">The value against which to make a comparison.</param>
+ <param name="ltOK">if set to <c>true</c> less succeeds.</param>
+ <param name="eqOK">if set to <c>true</c> equal succeeds.</param>
+ <param name="gtOK">if set to <c>true</c> greater succeeds.</param>
+ <param name="predicate">String used in describing the constraint.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Using(System.Collections.IComparer)">
+ <summary>
+ Modifies the constraint to use an IComparer and returns self
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
+ <summary>
+ Modifies the constraint to use an IComparer<T> and returns self
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Using``1(System.Comparison{``0})">
+ <summary>
+ Modifies the constraint to use a Comparison<T> and returns self
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.GreaterThanConstraint">
+ <summary>
+ Tests whether a value is greater than the value supplied to its constructor
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.GreaterThanConstraint.#ctor(System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:GreaterThanConstraint"/> class.
+ </summary>
+ <param name="expected">The expected value.</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.GreaterThanOrEqualConstraint">
+ <summary>
+ Tests whether a value is greater than or equal to the value supplied to its constructor
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.GreaterThanOrEqualConstraint.#ctor(System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:GreaterThanOrEqualConstraint"/> class.
+ </summary>
+ <param name="expected">The expected value.</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.LessThanConstraint">
+ <summary>
+ Tests whether a value is less than the value supplied to its constructor
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.LessThanConstraint.#ctor(System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:LessThanConstraint"/> class.
+ </summary>
+ <param name="expected">The expected value.</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.LessThanOrEqualConstraint">
+ <summary>
+ Tests whether a value is less than or equal to the value supplied to its constructor
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.LessThanOrEqualConstraint.#ctor(System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:LessThanOrEqualConstraint"/> class.
+ </summary>
+ <param name="expected">The expected value.</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.SameAsConstraint">
+ <summary>
+ SameAsConstraint tests whether an object is identical to
+ the object passed to its constructor
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SameAsConstraint.#ctor(System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:SameAsConstraint"/> class.
+ </summary>
+ <param name="expected">The expected object.</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SameAsConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SameAsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.BinaryConstraint">
+ <summary>
+ BinaryConstraint is the abstract base of all constraints
+ that combine two other constraints in some fashion.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.BinaryConstraint.left">
+ <summary>
+ The first constraint being combined
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.BinaryConstraint.right">
+ <summary>
+ The second constraint being combined
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BinaryConstraint.#ctor(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Construct a BinaryConstraint from two other constraints
+ </summary>
+ <param name="left">The first constraint</param>
+ <param name="right">The second constraint</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.AndConstraint">
+ <summary>
+ AndConstraint succeeds only if both members succeed.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AndConstraint.#ctor(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Create an AndConstraint from two other constraints
+ </summary>
+ <param name="left">The first constraint</param>
+ <param name="right">The second constraint</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AndConstraint.Matches(System.Object)">
+ <summary>
+ Apply both member constraints to an actual value, succeeding
+ succeeding only if both of them succeed.
+ </summary>
+ <param name="actual">The actual value</param>
+ <returns>True if the constraints both succeeded</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AndConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description for this contraint to a MessageWriter
+ </summary>
+ <param name="writer">The MessageWriter to receive the description</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AndConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter. The default implementation simply writes
+ the raw value of actual, leaving it to the writer to
+ perform any formatting.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.OrConstraint">
+ <summary>
+ OrConstraint succeeds if either member succeeds
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.OrConstraint.#ctor(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Create an OrConstraint from two other constraints
+ </summary>
+ <param name="left">The first constraint</param>
+ <param name="right">The second constraint</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.OrConstraint.Matches(System.Object)">
+ <summary>
+ Apply the member constraints to an actual value, succeeding
+ succeeding as soon as one of them succeeds.
+ </summary>
+ <param name="actual">The actual value</param>
+ <returns>True if either constraint succeeded</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.OrConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write a description for this contraint to a MessageWriter
+ </summary>
+ <param name="writer">The MessageWriter to receive the description</param>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ConstraintFactory">
+ <summary>
+ Helper class with properties and methods that supply
+ a number of constraints used in Asserts.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Property(System.String)">
+ <summary>
+ Returns a new PropertyConstraintExpression, which will either
+ test for the existence of the named property on the object
+ being tested or apply any following constraint to that property.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Attribute(System.Type)">
+ <summary>
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Attribute``1">
+ <summary>
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.EqualTo(System.Object)">
+ <summary>
+ Returns a constraint that tests two items for equality
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SameAs(System.Object)">
+ <summary>
+ Returns a constraint that tests that two references are the same object
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.GreaterThan(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is greater than the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.GreaterThanOrEqualTo(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AtLeast(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.LessThan(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is less than the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.LessThanOrEqualTo(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AtMost(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.TypeOf(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.TypeOf``1">
+ <summary>
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOf(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOf``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOfType(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOfType``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableFrom(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableFrom``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableTo(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableTo``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.EquivalentTo(System.Collections.IEnumerable)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is a collection containing the same elements as the
+ collection supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SubsetOf(System.Collections.IEnumerable)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is a subset of the collection supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Member(System.Object)">
+ <summary>
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Contains(System.Object)">
+ <summary>
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Contains(System.String)">
+ <summary>
+ Returns a new ContainsConstraint. This constraint
+ will, in turn, make use of the appropriate second-level
+ constraint, depending on the type of the actual argument.
+ This overload is only used if the item sought is a string,
+ since any other type implies that we are looking for a
+ collection member.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringContaining(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.ContainsSubstring(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotContain(System.String)">
+ <summary>
+ Returns a constraint that fails if the actual
+ value contains the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StartsWith(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringStarting(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotStartWith(System.String)">
+ <summary>
+ Returns a constraint that fails if the actual
+ value starts with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.EndsWith(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringEnding(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotEndWith(System.String)">
+ <summary>
+ Returns a constraint that fails if the actual
+ value ends with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Matches(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringMatching(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotMatch(System.String)">
+ <summary>
+ Returns a constraint that fails if the actual
+ value matches the pattern supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SamePath(System.String)">
+ <summary>
+ Returns a constraint that tests whether the path provided
+ is the same as an expected path after canonicalization.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SamePathOrUnder(System.String)">
+ <summary>
+ Returns a constraint that tests whether the path provided
+ is the same path or under an expected path after canonicalization.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InRange(System.IComparable,System.IComparable)">
+ <summary>
+ Returns a constraint that tests whether the actual value falls
+ within a specified range.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Not">
+ <summary>
+ Returns a ConstraintExpression that negates any
+ following constraint.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.No">
+ <summary>
+ Returns a ConstraintExpression that negates any
+ following constraint.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.All">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Some">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if at least one of them succeeds.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.None">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them fail.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Length">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Length property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Count">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Count property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Message">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Message property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.InnerException">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the InnerException property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Null">
+ <summary>
+ Returns a constraint that tests for null
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.True">
+ <summary>
+ Returns a constraint that tests for True
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.False">
+ <summary>
+ Returns a constraint that tests for False
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.NaN">
+ <summary>
+ Returns a constraint that tests for NaN
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Empty">
+ <summary>
+ Returns a constraint that tests for empty
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Unique">
+ <summary>
+ Returns a constraint that tests whether a collection
+ contains all unique items.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.BinarySerializable">
+ <summary>
+ Returns a constraint that tests whether an object graph is serializable in binary format.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.XmlSerializable">
+ <summary>
+ Returns a constraint that tests whether an object graph is serializable in xml format.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Ordered">
+ <summary>
+ Returns a constraint that tests whether a collection is ordered
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.DelayedConstraint">
+ <summary>
+ Applies a delay to the match so that a match can be evaluated in the future.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.DelayedConstraint.#ctor(NUnit.Framework.Constraints.Constraint,System.Int32)">
+ <summary>
+ Creates a new DelayedConstraint
+ </summary>
+ <param name="baseConstraint">The inner constraint two decorate</param>
+ <param name="delayInMilliseconds">The time interval after which the match is performed</param>
+ <exception cref="T:System.InvalidOperationException">If the value of <paramref name="delayInMilliseconds"/> is less than 0</exception>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.DelayedConstraint.#ctor(NUnit.Framework.Constraints.Constraint,System.Int32,System.Int32)">
+ <summary>
+ Creates a new DelayedConstraint
+ </summary>
+ <param name="baseConstraint">The inner constraint two decorate</param>
+ <param name="delayInMilliseconds">The time interval after which the match is performed</param>
+ <param name="pollingInterval">The time interval used for polling</param>
+ <exception cref="T:System.InvalidOperationException">If the value of <paramref name="delayInMilliseconds"/> is less than 0</exception>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.DelayedConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for if the base constraint fails, false if it succeeds</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.DelayedConstraint.Matches(NUnit.Framework.Constraints.ActualValueDelegate)">
+ <summary>
+ Test whether the constraint is satisfied by a delegate
+ </summary>
+ <param name="del">The delegate whose value is to be tested</param>
+ <returns>True for if the base constraint fails, false if it succeeds</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.DelayedConstraint.Matches``1(``0@)">
+ <summary>
+ Test whether the constraint is satisfied by a given reference.
+ Overridden to wait for the specified delay period before
+ calling the base constraint with the dereferenced value.
+ </summary>
+ <param name="actual">A reference to the value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.DelayedConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.DelayedConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a MessageWriter.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.DelayedConstraint.ToString">
+ <summary>
+ Returns the string representation of the constraint.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.NUnitComparer">
+ <summary>
+ NUnitComparer encapsulates NUnit's default behavior
+ in comparing two objects.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NUnitComparer.Compare(System.Object,System.Object)">
+ <summary>
+ Compares two objects
+ </summary>
+ <param name="x"></param>
+ <param name="y"></param>
+ <returns></returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.NUnitComparer.Default">
+ <summary>
+ Returns the default NUnitComparer.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ActualValueDelegate">
+ <summary>
+ Delegate used to delay evaluation of the actual value
+ to be used in evaluating a constraint
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.NUnitEqualityComparer">
+ <summary>
+ NUnitEqualityComparer encapsulates NUnit's handling of
+ equality tests between objects.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.caseInsensitive">
+ <summary>
+ If true, all string comparisons will ignore case
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.compareAsCollection">
+ <summary>
+ If true, arrays will be treated as collections, allowing
+ those of different dimensions to be compared
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.tolerance">
+ <summary>
+ If non-zero, equality comparisons within the specified
+ tolerance will succeed.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.NUnitEqualityComparer.externalComparer">
+ <summary>
+ Comparison object used in comparisons for some constraints.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NUnitEqualityComparer.ObjectsEqual(System.Object,System.Object)">
+ <summary>
+ Compares two objects for equality.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NUnitEqualityComparer.ArraysEqual(System.Array,System.Array)">
+ <summary>
+ Helper method to compare two arrays
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NUnitEqualityComparer.DirectoriesEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
+ <summary>
+ Method to compare two DirectoryInfo objects
+ </summary>
+ <param name="x">first directory to compare</param>
+ <param name="y">second directory to compare</param>
+ <returns>true if equivalent, false if not</returns>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.Default">
+ <summary>
+ Returns the default NUnitEqualityComparer
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.IgnoreCase">
+ <summary>
+ Gets and sets a flag indicating whether case should
+ be ignored in determining equality.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.CompareAsCollection">
+ <summary>
+ Gets and sets a flag indicating that arrays should be
+ compared as collections, without regard to their shape.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.ExternalComparer">
+ <summary>
+ Gets and sets an external comparer to be used to
+ test for equality. It is applied to members of
+ collections, in place of NUnit's own logic.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.Tolerance">
+ <summary>
+ Gets and sets a tolerance used to compare objects of
+ certin types.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.NUnitEqualityComparer.FailurePoints">
+ <summary>
+ Gets the list of failure points for the last Match performed.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ComparisonAdapter">
+ <summary>
+ ComparisonAdapter class centralizes all comparisons of
+ values in NUnit, adapting to the use of any provided
+ IComparer, IComparer<T> or Comparison<T>
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.For(System.Collections.IComparer)">
+ <summary>
+ Returns a ComparisonAdapter that wraps an IComparer
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.For``1(System.Collections.Generic.IComparer{``0})">
+ <summary>
+ Returns a ComparisonAdapter that wraps an IComparer<T>
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.For``1(System.Comparison{``0})">
+ <summary>
+ Returns a ComparisonAdapter that wraps a Comparison<T>
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.Compare(System.Object,System.Object)">
+ <summary>
+ Compares two objects
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ComparisonAdapter.Default">
+ <summary>
+ Gets the default ComparisonAdapter, which wraps an
+ NUnitComparer object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter.#ctor(System.Collections.IComparer)">
+ <summary>
+ Construct a ComparisonAdapter for an IComparer
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter.Compare(System.Object,System.Object)">
+ <summary>
+ Compares two objects
+ </summary>
+ <param name="expected"></param>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.DefaultComparisonAdapter.#ctor">
+ <summary>
+ Construct a default ComparisonAdapter
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter`1">
+ <summary>
+ ComparisonAdapter<T> extends ComparisonAdapter and
+ allows use of an IComparer<T> or Comparison<T>
+ to actually perform the comparison.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter`1.#ctor(System.Collections.Generic.IComparer{`0})">
+ <summary>
+ Construct a ComparisonAdapter for an IComparer<T>
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparerAdapter`1.Compare(System.Object,System.Object)">
+ <summary>
+ Compare a Type T to an object
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparisonAdapterForComparison`1.#ctor(System.Comparison{`0})">
+ <summary>
+ Construct a ComparisonAdapter for a Comparison<T>
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ComparisonAdapter.ComparisonAdapterForComparison`1.Compare(System.Object,System.Object)">
+ <summary>
+ Compare a Type T to an object
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ConstraintOperator">
+ <summary>
+ The ConstraintOperator class is used internally by a
+ ConstraintBuilder to represent an operator that
+ modifies or combines constraints.
+
+ Constraint operators use left and right precedence
+ values to determine whether the top operator on the
+ stack should be reduced before pushing a new operator.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ConstraintOperator.left_precedence">
+ <summary>
+ The precedence value used when the operator
+ is about to be pushed to the stack.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.ConstraintOperator.right_precedence">
+ <summary>
+ The precedence value used when the operator
+ is on the top of the stack.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ConstraintOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
+ <summary>
+ Reduce produces a constraint from the operator and
+ any arguments. It takes the arguments from the constraint
+ stack and pushes the resulting constraint on it.
+ </summary>
+ <param name="stack"></param>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintOperator.LeftContext">
+ <summary>
+ The syntax element preceding this operator
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintOperator.RightContext">
+ <summary>
+ The syntax element folowing this operator
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintOperator.LeftPrecedence">
+ <summary>
+ The precedence value used when the operator
+ is about to be pushed to the stack.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ConstraintOperator.RightPrecedence">
+ <summary>
+ The precedence value used when the operator
+ is on the top of the stack.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.PrefixOperator">
+ <summary>
+ PrefixOperator takes a single constraint and modifies
+ it's action in some way.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PrefixOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
+ <summary>
+ Reduce produces a constraint from the operator and
+ any arguments. It takes the arguments from the constraint
+ stack and pushes the resulting constraint on it.
+ </summary>
+ <param name="stack"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PrefixOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Returns the constraint created by applying this
+ prefix to another constraint.
+ </summary>
+ <param name="constraint"></param>
+ <returns></returns>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.NotOperator">
+ <summary>
+ Negates the test of the constraint it wraps.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NotOperator.#ctor">
+ <summary>
+ Constructs a new NotOperator
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NotOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Returns a NotConstraint applied to its argument.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.CollectionOperator">
+ <summary>
+ Abstract base for operators that indicate how to
+ apply a constraint to items in a collection.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.CollectionOperator.#ctor">
+ <summary>
+ Constructs a CollectionOperator
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.AllOperator">
+ <summary>
+ Represents a constraint that succeeds if all the
+ members of a collection match a base constraint.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AllOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Returns a constraint that will apply the argument
+ to the members of a collection, succeeding if
+ they all succeed.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.SomeOperator">
+ <summary>
+ Represents a constraint that succeeds if any of the
+ members of a collection match a base constraint.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.SomeOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Returns a constraint that will apply the argument
+ to the members of a collection, succeeding if
+ any of them succeed.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.NoneOperator">
+ <summary>
+ Represents a constraint that succeeds if none of the
+ members of a collection match a base constraint.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.NoneOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Returns a constraint that will apply the argument
+ to the members of a collection, succeeding if
+ none of them succeed.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.WithOperator">
+ <summary>
+ Represents a constraint that simply wraps the
+ constraint provided as an argument, without any
+ further functionality, but which modifes the
+ order of evaluation because of its precedence.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.WithOperator.#ctor">
+ <summary>
+ Constructor for the WithOperator
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.WithOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Returns a constraint that wraps its argument
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.SelfResolvingOperator">
+ <summary>
+ Abstract base class for operators that are able to reduce to a
+ constraint whether or not another syntactic element follows.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.PropOperator">
+ <summary>
+ Operator used to test for the presence of a named Property
+ on an object and optionally apply further tests to the
+ value of that property.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropOperator.#ctor(System.String)">
+ <summary>
+ Constructs a PropOperator for a particular named property
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PropOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
+ <summary>
+ Reduce produces a constraint from the operator and
+ any arguments. It takes the arguments from the constraint
+ stack and pushes the resulting constraint on it.
+ </summary>
+ <param name="stack"></param>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.PropOperator.Name">
+ <summary>
+ Gets the name of the property to which the operator applies
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.AttributeOperator">
+ <summary>
+ Operator that tests for the presence of a particular attribute
+ on a type and optionally applies further tests to the attribute.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeOperator.#ctor(System.Type)">
+ <summary>
+ Construct an AttributeOperator for a particular Type
+ </summary>
+ <param name="type">The Type of attribute tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
+ <summary>
+ Reduce produces a constraint from the operator and
+ any arguments. It takes the arguments from the constraint
+ stack and pushes the resulting constraint on it.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ThrowsOperator">
+ <summary>
+ Operator that tests that an exception is thrown and
+ optionally applies further tests to the exception.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsOperator.#ctor">
+ <summary>
+ Construct a ThrowsOperator
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ThrowsOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
+ <summary>
+ Reduce produces a constraint from the operator and
+ any arguments. It takes the arguments from the constraint
+ stack and pushes the resulting constraint on it.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.BinaryOperator">
+ <summary>
+ Abstract base class for all binary operators
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BinaryOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
+ <summary>
+ Reduce produces a constraint from the operator and
+ any arguments. It takes the arguments from the constraint
+ stack and pushes the resulting constraint on it.
+ </summary>
+ <param name="stack"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BinaryOperator.ApplyOperator(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Abstract method that produces a constraint by applying
+ the operator to its left and right constraint arguments.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.BinaryOperator.LeftPrecedence">
+ <summary>
+ Gets the left precedence of the operator
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.BinaryOperator.RightPrecedence">
+ <summary>
+ Gets the right precedence of the operator
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.AndOperator">
+ <summary>
+ Operator that requires both it's arguments to succeed
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AndOperator.#ctor">
+ <summary>
+ Construct an AndOperator
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AndOperator.ApplyOperator(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Apply the operator to produce an AndConstraint
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.OrOperator">
+ <summary>
+ Operator that requires at least one of it's arguments to succeed
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.OrOperator.#ctor">
+ <summary>
+ Construct an OrOperator
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.OrOperator.ApplyOperator(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Apply the operator to produce an OrConstraint
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.BinarySerializableConstraint">
+ <summary>
+ BinarySerializableConstraint tests whether
+ an object is serializable in binary format.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter. The default implementation simply writes
+ the raw value of actual, leaving it to the writer to
+ perform any formatting.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.ToString">
+ <summary>
+ Returns the string representation
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.XmlSerializableConstraint">
+ <summary>
+ BinarySerializableConstraint tests whether
+ an object is serializable in binary format.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.Matches(System.Object)">
+ <summary>
+ Test whether the constraint is satisfied by a given value
+ </summary>
+ <param name="actual">The value to be tested</param>
+ <returns>True for success, false for failure</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the constraint description to a MessageWriter
+ </summary>
+ <param name="writer">The writer on which the description is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Write the actual value for a failing constraint test to a
+ MessageWriter. The default implementation simply writes
+ the raw value of actual, leaving it to the writer to
+ perform any formatting.
+ </summary>
+ <param name="writer">The writer on which the actual value is displayed</param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.XmlSerializableConstraint.ToString">
+ <summary>
+ Returns the string representation of this constraint
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.ResolvableConstraintExpression">
+ <summary>
+ ResolvableConstraintExpression is used to represent a compound
+ constraint being constructed at a point where the last operator
+ may either terminate the expression or may have additional
+ qualifying constraints added to it.
+
+ It is used, for example, for a Property element or for
+ an Exception element, either of which may be optionally
+ followed by constraints that apply to the property or
+ exception.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.#ctor">
+ <summary>
+ Create a new instance of ResolvableConstraintExpression
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">
+ <summary>
+ Create a new instance of ResolvableConstraintExpression,
+ passing in a pre-populated ConstraintBuilder.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.ResolvableConstraintExpression.NUnit#Framework#Constraints#IResolveConstraint#Resolve">
+ <summary>
+ Resolve the current expression to a Constraint
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ResolvableConstraintExpression.And">
+ <summary>
+ Appends an And Operator to the expression
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Constraints.ResolvableConstraintExpression.Or">
+ <summary>
+ Appends an Or operator to the expression.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.EqualityAdapter">
+ <summary>
+ EqualityAdapter class handles all equality comparisons
+ that use an IEqualityComparer, IEqualityComparer<T>
+ or a ComparisonAdapter.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualityAdapter.ObjectsEqual(System.Object,System.Object)">
+ <summary>
+ Compares two objects, returning true if they are equal
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For(System.Collections.IComparer)">
+ <summary>
+ Returns an EqualityAdapter that wraps an IComparer.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For(System.Collections.IEqualityComparer)">
+ <summary>
+ Returns an EqualityAdapter that wraps an IEqualityComparer.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For``1(System.Collections.Generic.IEqualityComparer{``0})">
+ <summary>
+ Returns an EqualityAdapter that wraps an IEqualityComparer<T>.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For``1(System.Collections.Generic.IComparer{``0})">
+ <summary>
+ Returns an EqualityAdapter that wraps an IComparer<T>.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.EqualityAdapter.For``1(System.Comparison{``0})">
+ <summary>
+ Returns an EqualityAdapter that wraps a Comparison<T>.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.AttributeExistsConstraint">
+ <summary>
+ AttributeExistsConstraint tests for the presence of a
+ specified attribute on a Type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeExistsConstraint.#ctor(System.Type)">
+ <summary>
+ Constructs an AttributeExistsConstraint for a specific attribute Type
+ </summary>
+ <param name="type"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeExistsConstraint.Matches(System.Object)">
+ <summary>
+ Tests whether the object provides the expected attribute.
+ </summary>
+ <param name="actual">A Type, MethodInfo, or other ICustomAttributeProvider</param>
+ <returns>True if the expected attribute is present, otherwise false</returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeExistsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Writes the description of the constraint to the specified writer
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.AttributeConstraint">
+ <summary>
+ AttributeConstraint tests that a specified attribute is present
+ on a Type or other provider and that the value of the attribute
+ satisfies some other constraint.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeConstraint.#ctor(System.Type,NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Constructs an AttributeConstraint for a specified attriute
+ Type and base constraint.
+ </summary>
+ <param name="type"></param>
+ <param name="baseConstraint"></param>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeConstraint.Matches(System.Object)">
+ <summary>
+ Determines whether the Type or other provider has the
+ expected attribute and if its value matches the
+ additional constraint specified.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Writes a description of the attribute to the specified writer.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Writes the actual value supplied to the specified writer.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.AttributeConstraint.ToString">
+ <summary>
+ Returns a string representation of the constraint.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.FloatingPointNumerics">
+ <summary>Helper routines for working with floating point numbers</summary>
+ <remarks>
+ <para>
+ The floating point comparison code is based on this excellent article:
+ http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm
+ </para>
+ <para>
+ "ULP" means Unit in the Last Place and in the context of this library refers to
+ the distance between two adjacent floating point numbers. IEEE floating point
+ numbers can only represent a finite subset of natural numbers, with greater
+ accuracy for smaller numbers and lower accuracy for very large numbers.
+ </para>
+ <para>
+ If a comparison is allowed "2 ulps" of deviation, that means the values are
+ allowed to deviate by up to 2 adjacent floating point values, which might be
+ as low as 0.0000001 for small numbers or as high as 10.0 for large numbers.
+ </para>
+ </remarks>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.AreAlmostEqualUlps(System.Single,System.Single,System.Int32)">
+ <summary>Compares two floating point values for equality</summary>
+ <param name="left">First floating point value to be compared</param>
+ <param name="right">Second floating point value t be compared</param>
+ <param name="maxUlps">
+ Maximum number of representable floating point values that are allowed to
+ be between the left and the right floating point values
+ </param>
+ <returns>True if both numbers are equal or close to being equal</returns>
+ <remarks>
+ <para>
+ Floating point values can only represent a finite subset of natural numbers.
+ For example, the values 2.00000000 and 2.00000024 can be stored in a float,
+ but nothing inbetween them.
+ </para>
+ <para>
+ This comparison will count how many possible floating point values are between
+ the left and the right number. If the number of possible values between both
+ numbers is less than or equal to maxUlps, then the numbers are considered as
+ being equal.
+ </para>
+ <para>
+ Implementation partially follows the code outlined here:
+ http://www.anttirt.net/2007/08/19/proper-floating-point-comparisons/
+ </para>
+ </remarks>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.AreAlmostEqualUlps(System.Double,System.Double,System.Int64)">
+ <summary>Compares two double precision floating point values for equality</summary>
+ <param name="left">First double precision floating point value to be compared</param>
+ <param name="right">Second double precision floating point value t be compared</param>
+ <param name="maxUlps">
+ Maximum number of representable double precision floating point values that are
+ allowed to be between the left and the right double precision floating point values
+ </param>
+ <returns>True if both numbers are equal or close to being equal</returns>
+ <remarks>
+ <para>
+ Double precision floating point values can only represent a limited series of
+ natural numbers. For example, the values 2.0000000000000000 and 2.0000000000000004
+ can be stored in a double, but nothing inbetween them.
+ </para>
+ <para>
+ This comparison will count how many possible double precision floating point
+ values are between the left and the right number. If the number of possible
+ values between both numbers is less than or equal to maxUlps, then the numbers
+ are considered as being equal.
+ </para>
+ <para>
+ Implementation partially follows the code outlined here:
+ http://www.anttirt.net/2007/08/19/proper-floating-point-comparisons/
+ </para>
+ </remarks>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsInt(System.Single)">
+ <summary>
+ Reinterprets the memory contents of a floating point value as an integer value
+ </summary>
+ <param name="value">
+ Floating point value whose memory contents to reinterpret
+ </param>
+ <returns>
+ The memory contents of the floating point value interpreted as an integer
+ </returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsLong(System.Double)">
+ <summary>
+ Reinterprets the memory contents of a double precision floating point
+ value as an integer value
+ </summary>
+ <param name="value">
+ Double precision floating point value whose memory contents to reinterpret
+ </param>
+ <returns>
+ The memory contents of the double precision floating point value
+ interpreted as an integer
+ </returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsFloat(System.Int32)">
+ <summary>
+ Reinterprets the memory contents of an integer as a floating point value
+ </summary>
+ <param name="value">Integer value whose memory contents to reinterpret</param>
+ <returns>
+ The memory contents of the integer value interpreted as a floating point value
+ </returns>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.FloatingPointNumerics.ReinterpretAsDouble(System.Int64)">
+ <summary>
+ Reinterprets the memory contents of an integer value as a double precision
+ floating point value
+ </summary>
+ <param name="value">Integer whose memory contents to reinterpret</param>
+ <returns>
+ The memory contents of the integer interpreted as a double precision
+ floating point value
+ </returns>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion">
+ <summary>Union of a floating point variable and an integer</summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion.Float">
+ <summary>The union's value as a floating point variable</summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion.Int">
+ <summary>The union's value as an integer</summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.FloatIntUnion.UInt">
+ <summary>The union's value as an unsigned integer</summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion">
+ <summary>Union of a double precision floating point variable and a long</summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion.Double">
+ <summary>The union's value as a double precision floating point variable</summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion.Long">
+ <summary>The union's value as a long</summary>
+ </member>
+ <member name="F:NUnit.Framework.Constraints.FloatingPointNumerics.DoubleLongUnion.ULong">
+ <summary>The union's value as an unsigned long</summary>
+ </member>
+ <member name="T:NUnit.Framework.Constraints.PredicateConstraint`1">
+ <summary>
+ Predicate constraint wraps a Predicate in a constraint,
+ returning success if the predicate is true.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PredicateConstraint`1.#ctor(System.Predicate{`0})">
+ <summary>
+ Construct a PredicateConstraint from a predicate
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PredicateConstraint`1.Matches(System.Object)">
+ <summary>
+ Determines whether the predicate succeeds when applied
+ to the actual value.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Constraints.PredicateConstraint`1.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
+ <summary>
+ Writes the description to a MessageWriter
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TestCaseData">
+ <summary>
+ The TestCaseData class represents a set of arguments
+ and other parameter info to be used for a parameterized
+ test case. It provides a number of instance modifiers
+ for use in initializing the test case.
+
+ Note: Instance modifiers are getters that return
+ the same instance after modifying it's state.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.ITestCaseData">
+ <summary>
+ The ITestCaseData interface is implemented by a class
+ that is able to return complete testcases for use by
+ a parameterized test method.
+
+ NOTE: This interface is used in both the framework
+ and the core, even though that results in two different
+ types. However, sharing the source code guarantees that
+ the various implementations will be compatible and that
+ the core is able to reflect successfully over the
+ framework implementations of ITestCaseData.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ITestCaseData.Arguments">
+ <summary>
+ Gets the argument list to be provided to the test
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ITestCaseData.Result">
+ <summary>
+ Gets the expected result
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ITestCaseData.ExpectedException">
+ <summary>
+ Gets the expected exception Type
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ITestCaseData.ExpectedExceptionName">
+ <summary>
+ Gets the FullName of the expected exception
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ITestCaseData.TestName">
+ <summary>
+ Gets the name to be used for the test
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ITestCaseData.Description">
+ <summary>
+ Gets the description of the test
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ITestCaseData.Ignored">
+ <summary>
+ Gets a value indicating whether this <see cref="T:NUnit.Framework.ITestCaseData"/> is ignored.
+ </summary>
+ <value><c>true</c> if ignored; otherwise, <c>false</c>.</value>
+ </member>
+ <member name="P:NUnit.Framework.ITestCaseData.IgnoreReason">
+ <summary>
+ Gets the ignore reason.
+ </summary>
+ <value>The ignore reason.</value>
+ </member>
+ <member name="F:NUnit.Framework.TestCaseData.arguments">
+ <summary>
+ The argument list to be provided to the test
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TestCaseData.result">
+ <summary>
+ The expected result to be returned
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TestCaseData.expectedExceptionType">
+ <summary>
+ The expected exception Type
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TestCaseData.expectedExceptionName">
+ <summary>
+ The FullName of the expected exception
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TestCaseData.testName">
+ <summary>
+ The name to be used for the test
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TestCaseData.description">
+ <summary>
+ The description of the test
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TestCaseData.properties">
+ <summary>
+ A dictionary of properties, used to add information
+ to tests without requiring the class to change.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TestCaseData.isIgnored">
+ <summary>
+ If true, indicates that the test case is to be ignored
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TestCaseData.ignoreReason">
+ <summary>
+ The reason for ignoring a test case
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.#ctor(System.Object[])">
+ <summary>
+ Initializes a new instance of the <see cref="T:TestCaseData"/> class.
+ </summary>
+ <param name="args">The arguments.</param>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.#ctor(System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:TestCaseData"/> class.
+ </summary>
+ <param name="arg">The argument.</param>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.#ctor(System.Object,System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:TestCaseData"/> class.
+ </summary>
+ <param name="arg1">The first argument.</param>
+ <param name="arg2">The second argument.</param>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.#ctor(System.Object,System.Object,System.Object)">
+ <summary>
+ Initializes a new instance of the <see cref="T:TestCaseData"/> class.
+ </summary>
+ <param name="arg1">The first argument.</param>
+ <param name="arg2">The second argument.</param>
+ <param name="arg3">The third argument.</param>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.Returns(System.Object)">
+ <summary>
+ Sets the expected result for the test
+ </summary>
+ <param name="result">The expected result</param>
+ <returns>A modified TestCaseData</returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.Throws(System.Type)">
+ <summary>
+ Sets the expected exception type for the test
+ </summary>
+ <param name="exceptionType">Type of the expected exception.</param>
+ <returns>The modified TestCaseData instance</returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.Throws(System.String)">
+ <summary>
+ Sets the expected exception type for the test
+ </summary>
+ <param name="exceptionName">FullName of the expected exception.</param>
+ <returns>The modified TestCaseData instance</returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.SetName(System.String)">
+ <summary>
+ Sets the name of the test case
+ </summary>
+ <returns>The modified TestCaseData instance</returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.SetDescription(System.String)">
+ <summary>
+ Sets the description for the test case
+ being constructed.
+ </summary>
+ <param name="description">The description.</param>
+ <returns>The modified TestCaseData instance.</returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.SetCategory(System.String)">
+ <summary>
+ Applies a category to the test
+ </summary>
+ <param name="category"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.SetProperty(System.String,System.String)">
+ <summary>
+ Applies a named property to the test
+ </summary>
+ <param name="propName"></param>
+ <param name="propValue"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.SetProperty(System.String,System.Int32)">
+ <summary>
+ Applies a named property to the test
+ </summary>
+ <param name="propName"></param>
+ <param name="propValue"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.SetProperty(System.String,System.Double)">
+ <summary>
+ Applies a named property to the test
+ </summary>
+ <param name="propName"></param>
+ <param name="propValue"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.Ignore">
+ <summary>
+ Ignores this TestCase.
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseData.Ignore(System.String)">
+ <summary>
+ Ignores this TestCase, specifying the reason.
+ </summary>
+ <param name="reason">The reason.</param>
+ <returns></returns>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.Arguments">
+ <summary>
+ Gets the argument list to be provided to the test
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.Result">
+ <summary>
+ Gets the expected result
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.ExpectedException">
+ <summary>
+ Gets the expected exception Type
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.ExpectedExceptionName">
+ <summary>
+ Gets the FullName of the expected exception
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.TestName">
+ <summary>
+ Gets the name to be used for the test
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.Description">
+ <summary>
+ Gets the description of the test
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.Ignored">
+ <summary>
+ Gets a value indicating whether this <see cref="T:NUnit.Framework.ITestCaseData"/> is ignored.
+ </summary>
+ <value><c>true</c> if ignored; otherwise, <c>false</c>.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.IgnoreReason">
+ <summary>
+ Gets the ignore reason.
+ </summary>
+ <value>The ignore reason.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.Categories">
+ <summary>
+ Gets a list of categories associated with this test.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseData.Properties">
+ <summary>
+ Gets the property dictionary for this test
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TestCaseSourceAttribute">
+ <summary>
+ FactoryAttribute indicates the source to be used to
+ provide test cases for a test method.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseSourceAttribute.#ctor(System.String)">
+ <summary>
+ Construct with the name of the factory - for use with languages
+ that don't support params arrays.
+ </summary>
+ <param name="sourceName">An array of the names of the factories that will provide data</param>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseSourceAttribute.#ctor(System.Type,System.String)">
+ <summary>
+ Construct with a Type and name - for use with languages
+ that don't support params arrays.
+ </summary>
+ <param name="sourceType">The Type that will provide data</param>
+ <param name="sourceName">The name of the method, property or field that will provide data</param>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseSourceAttribute.SourceName">
+ <summary>
+ The name of a the method, property or fiend to be used as a source
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseSourceAttribute.SourceType">
+ <summary>
+ A Type to be used as a source
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Has">
+ <summary>
+ Helper class with properties and methods that supply
+ a number of constraints used in Asserts.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Has.Property(System.String)">
+ <summary>
+ Returns a new PropertyConstraintExpression, which will either
+ test for the existence of the named property on the object
+ being tested or apply any following constraint to that property.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Has.Attribute(System.Type)">
+ <summary>
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Has.Attribute``1">
+ <summary>
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Has.Member(System.Object)">
+ <summary>
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Has.No">
+ <summary>
+ Returns a ConstraintExpression that negates any
+ following constraint.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Has.All">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Has.Some">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if at least one of them succeeds.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Has.None">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them fail.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Has.Length">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Length property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Has.Count">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Count property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Has.Message">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Message property of the object being tested.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Has.InnerException">
+ <summary>
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the InnerException property of the object being tested.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.List">
+ <summary>
+ The List class is a helper class with properties and methods
+ that supply a number of constraints used with lists and collections.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.List.Map(System.Collections.ICollection)">
+ <summary>
+ List.Map returns a ListMapper, which can be used to map
+ the original collection to another collection.
+ </summary>
+ <param name="actual"></param>
+ <returns></returns>
+ </member>
+ <member name="T:NUnit.Framework.MessageMatch">
+ <summary>
+ Enumeration indicating how the expected message parameter is to be used
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.MessageMatch.Exact">
+ Expect an exact match
+ </member>
+ <member name="F:NUnit.Framework.MessageMatch.Contains">
+ Expect a message containing the parameter string
+ </member>
+ <member name="F:NUnit.Framework.MessageMatch.Regex">
+ Match the regular expression provided as a parameter
+ </member>
+ <member name="F:NUnit.Framework.MessageMatch.StartsWith">
+ Expect a message that starts with the parameter string
+ </member>
+ <member name="T:NUnit.Framework.ExpectedExceptionAttribute">
+ <summary>
+ ExpectedExceptionAttribute
+ </summary>
+
+ </member>
+ <member name="M:NUnit.Framework.ExpectedExceptionAttribute.#ctor">
+ <summary>
+ Constructor for a non-specific exception
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.ExpectedExceptionAttribute.#ctor(System.Type)">
+ <summary>
+ Constructor for a given type of exception
+ </summary>
+ <param name="exceptionType">The type of the expected exception</param>
+ </member>
+ <member name="M:NUnit.Framework.ExpectedExceptionAttribute.#ctor(System.String)">
+ <summary>
+ Constructor for a given exception name
+ </summary>
+ <param name="exceptionName">The full name of the expected exception</param>
+ </member>
+ <member name="P:NUnit.Framework.ExpectedExceptionAttribute.ExpectedException">
+ <summary>
+ Gets or sets the expected exception type
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ExpectedExceptionAttribute.ExpectedExceptionName">
+ <summary>
+ Gets or sets the full Type name of the expected exception
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ExpectedExceptionAttribute.ExpectedMessage">
+ <summary>
+ Gets or sets the expected message text
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ExpectedExceptionAttribute.UserMessage">
+ <summary>
+ Gets or sets the user message displayed in case of failure
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ExpectedExceptionAttribute.MatchType">
+ <summary>
+ Gets or sets the type of match to be performed on the expected message
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ExpectedExceptionAttribute.Handler">
+ <summary>
+ Gets the name of a method to be used as an exception handler
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TestCaseAttribute">
+ <summary>
+ TestCaseAttribute is used to mark parameterized test cases
+ and provide them with their arguments.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object[])">
+ <summary>
+ Construct a TestCaseAttribute with a list of arguments.
+ This constructor is not CLS-Compliant
+ </summary>
+ <param name="arguments"></param>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object)">
+ <summary>
+ Construct a TestCaseAttribute with a single argument
+ </summary>
+ <param name="arg"></param>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object,System.Object)">
+ <summary>
+ Construct a TestCaseAttribute with a two arguments
+ </summary>
+ <param name="arg1"></param>
+ <param name="arg2"></param>
+ </member>
+ <member name="M:NUnit.Framework.TestCaseAttribute.#ctor(System.Object,System.Object,System.Object)">
+ <summary>
+ Construct a TestCaseAttribute with a three arguments
+ </summary>
+ <param name="arg1"></param>
+ <param name="arg2"></param>
+ <param name="arg3"></param>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.Arguments">
+ <summary>
+ Gets the list of arguments to a test case
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.Result">
+ <summary>
+ Gets or sets the expected result.
+ </summary>
+ <value>The result.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.ExpectedException">
+ <summary>
+ Gets or sets the expected exception.
+ </summary>
+ <value>The expected exception.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.ExpectedExceptionName">
+ <summary>
+ Gets or sets the name the expected exception.
+ </summary>
+ <value>The expected name of the exception.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.ExpectedMessage">
+ <summary>
+ Gets or sets the expected message of the expected exception
+ </summary>
+ <value>The expected message of the exception.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.MatchType">
+ <summary>
+ Gets or sets the type of match to be performed on the expected message
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.Description">
+ <summary>
+ Gets or sets the description.
+ </summary>
+ <value>The description.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.TestName">
+ <summary>
+ Gets or sets the name of the test.
+ </summary>
+ <value>The name of the test.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.Ignore">
+ <summary>
+ Gets or sets the ignored status of the test
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.Ignored">
+ <summary>
+ Gets or sets the ignored status of the test
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestCaseAttribute.IgnoreReason">
+ <summary>
+ Gets the ignore reason.
+ </summary>
+ <value>The ignore reason.</value>
+ </member>
+ <member name="T:NUnit.Framework.SuccessException">
+ <summary>
+ Thrown when an assertion failed.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.SuccessException.#ctor(System.String)">
+ <param name="message"></param>
+ </member>
+ <member name="M:NUnit.Framework.SuccessException.#ctor(System.String,System.Exception)">
+ <param name="message">The error message that explains
+ the reason for the exception</param>
+ <param name="inner">The exception that caused the
+ current exception</param>
+ </member>
+ <member name="M:NUnit.Framework.SuccessException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+ <summary>
+ Serialization Constructor
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.InconclusiveException">
+ <summary>
+ Thrown when a test executes inconclusively.
+ </summary>
+
+ </member>
+ <member name="M:NUnit.Framework.InconclusiveException.#ctor(System.String)">
+ <param name="message">The error message that explains
+ the reason for the exception</param>
+ </member>
+ <member name="M:NUnit.Framework.InconclusiveException.#ctor(System.String,System.Exception)">
+ <param name="message">The error message that explains
+ the reason for the exception</param>
+ <param name="inner">The exception that caused the
+ current exception</param>
+ </member>
+ <member name="M:NUnit.Framework.InconclusiveException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+ <summary>
+ Serialization Constructor
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TestDelegate">
+ <summary>
+ Delegate used by tests that execute code and
+ capture any thrown exception.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Assert">
+ <summary>
+ The Assert class contains a collection of static methods that
+ implement the most common assertions used in NUnit.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Assert.#ctor">
+ <summary>
+ We don't actually want any instances of this object, but some people
+ like to inherit from it to add other static methods. Hence, the
+ protected constructor disallows any instances of this object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Equals(System.Object,System.Object)">
+ <summary>
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.ReferenceEquals(System.Object,System.Object)">
+ <summary>
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AssertDoublesAreEqual(System.Double,System.Double,System.Double,System.String,System.Object[])">
+ <summary>
+ Helper for Assert.AreEqual(double expected, double actual, ...)
+ allowing code generation to work consistently.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="delta">The maximum acceptable difference between the
+ the expected and the actual</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Pass(System.String,System.Object[])">
+ <summary>
+ Throws a <see cref="T:NUnit.Framework.SuccessException"/> with the message and arguments
+ that are passed in. This allows a test to be cut short, with a result
+ of success returned to NUnit.
+ </summary>
+ <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Pass(System.String)">
+ <summary>
+ Throws a <see cref="T:NUnit.Framework.SuccessException"/> with the message and arguments
+ that are passed in. This allows a test to be cut short, with a result
+ of success returned to NUnit.
+ </summary>
+ <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Pass">
+ <summary>
+ Throws a <see cref="T:NUnit.Framework.SuccessException"/> with the message and arguments
+ that are passed in. This allows a test to be cut short, with a result
+ of success returned to NUnit.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Fail(System.String,System.Object[])">
+ <summary>
+ Throws an <see cref="T:NUnit.Framework.AssertionException"/> with the message and arguments
+ that are passed in. This is used by the other Assert functions.
+ </summary>
+ <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Fail(System.String)">
+ <summary>
+ Throws an <see cref="T:NUnit.Framework.AssertionException"/> with the message that is
+ passed in. This is used by the other Assert functions.
+ </summary>
+ <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Fail">
+ <summary>
+ Throws an <see cref="T:NUnit.Framework.AssertionException"/>.
+ This is used by the other Assert functions.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Ignore(System.String,System.Object[])">
+ <summary>
+ Throws an <see cref="T:NUnit.Framework.IgnoreException"/> with the message and arguments
+ that are passed in. This causes the test to be reported as ignored.
+ </summary>
+ <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Ignore(System.String)">
+ <summary>
+ Throws an <see cref="T:NUnit.Framework.IgnoreException"/> with the message that is
+ passed in. This causes the test to be reported as ignored.
+ </summary>
+ <param name="message">The message to initialize the <see cref="T:NUnit.Framework.AssertionException"/> with.</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Ignore">
+ <summary>
+ Throws an <see cref="T:NUnit.Framework.IgnoreException"/>.
+ This causes the test to be reported as ignored.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Inconclusive(System.String,System.Object[])">
+ <summary>
+ Throws an <see cref="T:NUnit.Framework.InconclusiveException"/> with the message and arguments
+ that are passed in. This causes the test to be reported as inconclusive.
+ </summary>
+ <param name="message">The message to initialize the <see cref="T:NUnit.Framework.InconclusiveException"/> with.</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Inconclusive(System.String)">
+ <summary>
+ Throws an <see cref="T:NUnit.Framework.InconclusiveException"/> with the message that is
+ passed in. This causes the test to be reported as inconclusive.
+ </summary>
+ <param name="message">The message to initialize the <see cref="T:NUnit.Framework.InconclusiveException"/> with.</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Inconclusive">
+ <summary>
+ Throws an <see cref="T:NUnit.Framework.InconclusiveException"/>.
+ This causes the test to be reported as Inconclusive.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expression">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expression">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expression">A Constraint expression to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expr">A Constraint expression to be applied</param>
+ <param name="del">An ActualValueDelegate returning the value to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expr">A Constraint expression to be applied</param>
+ <param name="del">An ActualValueDelegate returning the value to be tested</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="del">An ActualValueDelegate returning the value to be tested</param>
+ <param name="expr">A Constraint expression to be applied</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expression">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+ <summary>
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expression">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+ <summary>
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expression">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(System.Boolean,System.String,System.Object[])">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display if the condition is false</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(System.Boolean,System.String)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display if the condition is false</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(System.Boolean)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.That(NUnit.Framework.TestDelegate,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Asserts that the code represented by a delegate throws an exception
+ that satisfies the constraint provided.
+ </summary>
+ <param name="code">A TestDelegate to be executed</param>
+ <param name="constraint">A ThrowsConstraint used in the test</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Throws(NUnit.Framework.Constraints.IResolveConstraint,NUnit.Framework.TestDelegate,System.String,System.Object[])">
+ <summary>
+ Verifies that a delegate throws a particular exception when called.
+ </summary>
+ <param name="expression">A constraint to be satisfied by the exception</param>
+ <param name="code">A TestSnippet delegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Throws(NUnit.Framework.Constraints.IResolveConstraint,NUnit.Framework.TestDelegate,System.String)">
+ <summary>
+ Verifies that a delegate throws a particular exception when called.
+ </summary>
+ <param name="expression">A constraint to be satisfied by the exception</param>
+ <param name="code">A TestSnippet delegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Throws(NUnit.Framework.Constraints.IResolveConstraint,NUnit.Framework.TestDelegate)">
+ <summary>
+ Verifies that a delegate throws a particular exception when called.
+ </summary>
+ <param name="expression">A constraint to be satisfied by the exception</param>
+ <param name="code">A TestSnippet delegate</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Throws(System.Type,NUnit.Framework.TestDelegate,System.String,System.Object[])">
+ <summary>
+ Verifies that a delegate throws a particular exception when called.
+ </summary>
+ <param name="expectedExceptionType">The exception Type expected</param>
+ <param name="code">A TestSnippet delegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Throws(System.Type,NUnit.Framework.TestDelegate,System.String)">
+ <summary>
+ Verifies that a delegate throws a particular exception when called.
+ </summary>
+ <param name="expectedExceptionType">The exception Type expected</param>
+ <param name="code">A TestSnippet delegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Throws(System.Type,NUnit.Framework.TestDelegate)">
+ <summary>
+ Verifies that a delegate throws a particular exception when called.
+ </summary>
+ <param name="expectedExceptionType">The exception Type expected</param>
+ <param name="code">A TestSnippet delegate</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Throws``1(NUnit.Framework.TestDelegate,System.String,System.Object[])">
+ <summary>
+ Verifies that a delegate throws a particular exception when called.
+ </summary>
+ <typeparam name="T">Type of the expected exception</typeparam>
+ <param name="code">A TestSnippet delegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Throws``1(NUnit.Framework.TestDelegate,System.String)">
+ <summary>
+ Verifies that a delegate throws a particular exception when called.
+ </summary>
+ <typeparam name="T">Type of the expected exception</typeparam>
+ <param name="code">A TestSnippet delegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Throws``1(NUnit.Framework.TestDelegate)">
+ <summary>
+ Verifies that a delegate throws a particular exception when called.
+ </summary>
+ <typeparam name="T">Type of the expected exception</typeparam>
+ <param name="code">A TestSnippet delegate</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Catch(NUnit.Framework.TestDelegate,System.String,System.Object[])">
+ <summary>
+ Verifies that a delegate throws an exception when called
+ and returns it.
+ </summary>
+ <param name="code">A TestDelegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Catch(NUnit.Framework.TestDelegate,System.String)">
+ <summary>
+ Verifies that a delegate throws an exception when called
+ and returns it.
+ </summary>
+ <param name="code">A TestDelegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Catch(NUnit.Framework.TestDelegate)">
+ <summary>
+ Verifies that a delegate throws an exception when called
+ and returns it.
+ </summary>
+ <param name="code">A TestDelegate</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Catch(System.Type,NUnit.Framework.TestDelegate,System.String,System.Object[])">
+ <summary>
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+ </summary>
+ <param name="expectedExceptionType">The expected Exception Type</param>
+ <param name="code">A TestDelegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Catch(System.Type,NUnit.Framework.TestDelegate,System.String)">
+ <summary>
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+ </summary>
+ <param name="expectedExceptionType">The expected Exception Type</param>
+ <param name="code">A TestDelegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Catch(System.Type,NUnit.Framework.TestDelegate)">
+ <summary>
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+ </summary>
+ <param name="expectedExceptionType">The expected Exception Type</param>
+ <param name="code">A TestDelegate</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Catch``1(NUnit.Framework.TestDelegate,System.String,System.Object[])">
+ <summary>
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+ </summary>
+ <typeparam name="T">The expected Exception Type</typeparam>
+ <param name="code">A TestDelegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Catch``1(NUnit.Framework.TestDelegate,System.String)">
+ <summary>
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+ </summary>
+ <typeparam name="T">The expected Exception Type</typeparam>
+ <param name="code">A TestDelegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Catch``1(NUnit.Framework.TestDelegate)">
+ <summary>
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+ </summary>
+ <typeparam name="T">The expected Exception Type</typeparam>
+ <param name="code">A TestDelegate</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.DoesNotThrow(NUnit.Framework.TestDelegate,System.String,System.Object[])">
+ <summary>
+ Verifies that a delegate does not throw an exception
+ </summary>
+ <param name="code">A TestSnippet delegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.DoesNotThrow(NUnit.Framework.TestDelegate,System.String)">
+ <summary>
+ Verifies that a delegate does not throw an exception.
+ </summary>
+ <param name="code">A TestSnippet delegate</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.DoesNotThrow(NUnit.Framework.TestDelegate)">
+ <summary>
+ Verifies that a delegate does not throw an exception.
+ </summary>
+ <param name="code">A TestSnippet delegate</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.True(System.Boolean,System.String,System.Object[])">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.True(System.Boolean,System.String)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.True(System.Boolean)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsTrue(System.Boolean,System.String,System.Object[])">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsTrue(System.Boolean,System.String)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsTrue(System.Boolean)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.False(System.Boolean,System.String,System.Object[])">
+ <summary>
+ Asserts that a condition is false. If the condition is true the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.False(System.Boolean,System.String)">
+ <summary>
+ Asserts that a condition is false. If the condition is true the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.False(System.Boolean)">
+ <summary>
+ Asserts that a condition is false. If the condition is true the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsFalse(System.Boolean,System.String,System.Object[])">
+ <summary>
+ Asserts that a condition is false. If the condition is true the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsFalse(System.Boolean,System.String)">
+ <summary>
+ Asserts that a condition is false. If the condition is true the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsFalse(System.Boolean)">
+ <summary>
+ Asserts that a condition is false. If the condition is true the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.NotNull(System.Object,System.String,System.Object[])">
+ <summary>
+ Verifies that the object that is passed in is not equal to <code>null</code>
+ If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.NotNull(System.Object,System.String)">
+ <summary>
+ Verifies that the object that is passed in is not equal to <code>null</code>
+ If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.NotNull(System.Object)">
+ <summary>
+ Verifies that the object that is passed in is not equal to <code>null</code>
+ If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotNull(System.Object,System.String,System.Object[])">
+ <summary>
+ Verifies that the object that is passed in is not equal to <code>null</code>
+ If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotNull(System.Object,System.String)">
+ <summary>
+ Verifies that the object that is passed in is not equal to <code>null</code>
+ If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotNull(System.Object)">
+ <summary>
+ Verifies that the object that is passed in is not equal to <code>null</code>
+ If the object is <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Null(System.Object,System.String,System.Object[])">
+ <summary>
+ Verifies that the object that is passed in is equal to <code>null</code>
+ If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Null(System.Object,System.String)">
+ <summary>
+ Verifies that the object that is passed in is equal to <code>null</code>
+ If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Null(System.Object)">
+ <summary>
+ Verifies that the object that is passed in is equal to <code>null</code>
+ If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNull(System.Object,System.String,System.Object[])">
+ <summary>
+ Verifies that the object that is passed in is equal to <code>null</code>
+ If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNull(System.Object,System.String)">
+ <summary>
+ Verifies that the object that is passed in is equal to <code>null</code>
+ If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNull(System.Object)">
+ <summary>
+ Verifies that the object that is passed in is equal to <code>null</code>
+ If the object is not <code>null</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="anObject">The object that is to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNaN(System.Double,System.String,System.Object[])">
+ <summary>
+ Verifies that the double that is passed in is an <code>NaN</code> value.
+ If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="aDouble">The value that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNaN(System.Double,System.String)">
+ <summary>
+ Verifies that the double that is passed in is an <code>NaN</code> value.
+ If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="aDouble">The value that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNaN(System.Double)">
+ <summary>
+ Verifies that the double that is passed in is an <code>NaN</code> value.
+ If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="aDouble">The value that is to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNaN(System.Nullable{System.Double},System.String,System.Object[])">
+ <summary>
+ Verifies that the double that is passed in is an <code>NaN</code> value.
+ If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="aDouble">The value that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNaN(System.Nullable{System.Double},System.String)">
+ <summary>
+ Verifies that the double that is passed in is an <code>NaN</code> value.
+ If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="aDouble">The value that is to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNaN(System.Nullable{System.Double})">
+ <summary>
+ Verifies that the double that is passed in is an <code>NaN</code> value.
+ If the object is not <code>NaN</code> then an <see cref="T:NUnit.Framework.AssertionException"/>
+ is thrown.
+ </summary>
+ <param name="aDouble">The value that is to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsEmpty(System.String,System.String,System.Object[])">
+ <summary>
+ Assert that a string is empty - that is equal to string.Empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsEmpty(System.String,System.String)">
+ <summary>
+ Assert that a string is empty - that is equal to string.Empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsEmpty(System.String)">
+ <summary>
+ Assert that a string is empty - that is equal to string.Empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsEmpty(System.Collections.ICollection,System.String,System.Object[])">
+ <summary>
+ Assert that an array, list or other collection is empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing ICollection</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsEmpty(System.Collections.ICollection,System.String)">
+ <summary>
+ Assert that an array, list or other collection is empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing ICollection</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsEmpty(System.Collections.ICollection)">
+ <summary>
+ Assert that an array, list or other collection is empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing ICollection</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.String,System.String,System.Object[])">
+ <summary>
+ Assert that a string is not empty - that is not equal to string.Empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.String,System.String)">
+ <summary>
+ Assert that a string is not empty - that is not equal to string.Empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.String)">
+ <summary>
+ Assert that a string is not empty - that is not equal to string.Empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.Collections.ICollection,System.String,System.Object[])">
+ <summary>
+ Assert that an array, list or other collection is not empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing ICollection</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.Collections.ICollection,System.String)">
+ <summary>
+ Assert that an array, list or other collection is not empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing ICollection</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotEmpty(System.Collections.ICollection)">
+ <summary>
+ Assert that an array, list or other collection is not empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing ICollection</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNullOrEmpty(System.String,System.String,System.Object[])">
+ <summary>
+ Assert that a string is either null or equal to string.Empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNullOrEmpty(System.String,System.String)">
+ <summary>
+ Assert that a string is either null or equal to string.Empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNullOrEmpty(System.String)">
+ <summary>
+ Assert that a string is either null or equal to string.Empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotNullOrEmpty(System.String,System.String,System.Object[])">
+ <summary>
+ Assert that a string is not null or empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotNullOrEmpty(System.String,System.String)">
+ <summary>
+ Assert that a string is not null or empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotNullOrEmpty(System.String)">
+ <summary>
+ Assert that a string is not null or empty
+ </summary>
+ <param name="aString">The string to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsAssignableFrom(System.Type,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object may be assigned a value of a given Type.
+ </summary>
+ <param name="expected">The expected Type.</param>
+ <param name="actual">The object under examination</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsAssignableFrom(System.Type,System.Object,System.String)">
+ <summary>
+ Asserts that an object may be assigned a value of a given Type.
+ </summary>
+ <param name="expected">The expected Type.</param>
+ <param name="actual">The object under examination</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsAssignableFrom(System.Type,System.Object)">
+ <summary>
+ Asserts that an object may be assigned a value of a given Type.
+ </summary>
+ <param name="expected">The expected Type.</param>
+ <param name="actual">The object under examination</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsAssignableFrom``1(System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object may be assigned a value of a given Type.
+ </summary>
+ <typeparam name="T">The expected Type.</typeparam>
+ <param name="actual">The object under examination</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsAssignableFrom``1(System.Object,System.String)">
+ <summary>
+ Asserts that an object may be assigned a value of a given Type.
+ </summary>
+ <typeparam name="T">The expected Type.</typeparam>
+ <param name="actual">The object under examination</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsAssignableFrom``1(System.Object)">
+ <summary>
+ Asserts that an object may be assigned a value of a given Type.
+ </summary>
+ <typeparam name="T">The expected Type.</typeparam>
+ <param name="actual">The object under examination</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom(System.Type,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object may not be assigned a value of a given Type.
+ </summary>
+ <param name="expected">The expected Type.</param>
+ <param name="actual">The object under examination</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom(System.Type,System.Object,System.String)">
+ <summary>
+ Asserts that an object may not be assigned a value of a given Type.
+ </summary>
+ <param name="expected">The expected Type.</param>
+ <param name="actual">The object under examination</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom(System.Type,System.Object)">
+ <summary>
+ Asserts that an object may not be assigned a value of a given Type.
+ </summary>
+ <param name="expected">The expected Type.</param>
+ <param name="actual">The object under examination</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom``1(System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object may not be assigned a value of a given Type.
+ </summary>
+ <typeparam name="T">The expected Type.</typeparam>
+ <param name="actual">The object under examination</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom``1(System.Object,System.String)">
+ <summary>
+ Asserts that an object may not be assigned a value of a given Type.
+ </summary>
+ <typeparam name="T">The expected Type.</typeparam>
+ <param name="actual">The object under examination</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotAssignableFrom``1(System.Object)">
+ <summary>
+ Asserts that an object may not be assigned a value of a given Type.
+ </summary>
+ <typeparam name="T">The expected Type.</typeparam>
+ <param name="actual">The object under examination</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsInstanceOf(System.Type,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object is an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsInstanceOf(System.Type,System.Object,System.String)">
+ <summary>
+ Asserts that an object is an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsInstanceOf(System.Type,System.Object)">
+ <summary>
+ Asserts that an object is an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsInstanceOfType(System.Type,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object is an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsInstanceOfType(System.Type,System.Object,System.String)">
+ <summary>
+ Asserts that an object is an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsInstanceOfType(System.Type,System.Object)">
+ <summary>
+ Asserts that an object is an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsInstanceOf``1(System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object is an instance of a given type.
+ </summary>
+ <typeparam name="T">The expected Type</typeparam>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsInstanceOf``1(System.Object,System.String)">
+ <summary>
+ Asserts that an object is an instance of a given type.
+ </summary>
+ <typeparam name="T">The expected Type</typeparam>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsInstanceOf``1(System.Object)">
+ <summary>
+ Asserts that an object is an instance of a given type.
+ </summary>
+ <typeparam name="T">The expected Type</typeparam>
+ <param name="actual">The object being examined</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotInstanceOf(System.Type,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object is not an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotInstanceOf(System.Type,System.Object,System.String)">
+ <summary>
+ Asserts that an object is not an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotInstanceOf(System.Type,System.Object)">
+ <summary>
+ Asserts that an object is not an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotInstanceOfType(System.Type,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object is not an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotInstanceOfType(System.Type,System.Object,System.String)">
+ <summary>
+ Asserts that an object is not an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotInstanceOfType(System.Type,System.Object)">
+ <summary>
+ Asserts that an object is not an instance of a given type.
+ </summary>
+ <param name="expected">The expected Type</param>
+ <param name="actual">The object being examined</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotInstanceOf``1(System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that an object is not an instance of a given type.
+ </summary>
+ <typeparam name="T">The expected Type</typeparam>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotInstanceOf``1(System.Object,System.String)">
+ <summary>
+ Asserts that an object is not an instance of a given type.
+ </summary>
+ <typeparam name="T">The expected Type</typeparam>
+ <param name="actual">The object being examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.IsNotInstanceOf``1(System.Object)">
+ <summary>
+ Asserts that an object is not an instance of a given type.
+ </summary>
+ <typeparam name="T">The expected Type</typeparam>
+ <param name="actual">The object being examined</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Int32,System.Int32,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Int32,System.Int32,System.String)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Int32,System.Int32)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Int64,System.Int64,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Int64,System.Int64,System.String)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Int64,System.Int64)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt32,System.UInt32,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt32,System.UInt32,System.String)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt32,System.UInt32)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt64,System.UInt64,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt64,System.UInt64,System.String)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.UInt64,System.UInt64)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Decimal,System.Decimal,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Decimal,System.Decimal,System.String)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Decimal,System.Decimal)">
+ <summary>
+ Verifies that two values are equal. If they are not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Double,System.Double,System.String,System.Object[])">
+ <summary>
+ Verifies that two doubles are equal considering a delta. If the
+ expected value is infinity then the delta value is ignored. If
+ they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is
+ thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="delta">The maximum acceptable difference between the
+ the expected and the actual</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Double,System.Double,System.String)">
+ <summary>
+ Verifies that two doubles are equal considering a delta. If the
+ expected value is infinity then the delta value is ignored. If
+ they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is
+ thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="delta">The maximum acceptable difference between the
+ the expected and the actual</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Double,System.Double)">
+ <summary>
+ Verifies that two doubles are equal considering a delta. If the
+ expected value is infinity then the delta value is ignored. If
+ they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is
+ thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="delta">The maximum acceptable difference between the
+ the expected and the actual</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Nullable{System.Double},System.Double,System.String,System.Object[])">
+ <summary>
+ Verifies that two doubles are equal considering a delta. If the
+ expected value is infinity then the delta value is ignored. If
+ they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is
+ thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="delta">The maximum acceptable difference between the
+ the expected and the actual</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Nullable{System.Double},System.Double,System.String)">
+ <summary>
+ Verifies that two doubles are equal considering a delta. If the
+ expected value is infinity then the delta value is ignored. If
+ they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is
+ thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="delta">The maximum acceptable difference between the
+ the expected and the actual</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Double,System.Nullable{System.Double},System.Double)">
+ <summary>
+ Verifies that two doubles are equal considering a delta. If the
+ expected value is infinity then the delta value is ignored. If
+ they are not equal then an <see cref="T:NUnit.Framework.AssertionException"/> is
+ thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="delta">The maximum acceptable difference between the
+ the expected and the actual</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Object,System.Object,System.String,System.Object[])">
+ <summary>
+ Verifies that two objects are equal. Two objects are considered
+ equal if both are null, or if both have the same value. NUnit
+ has special semantics for some object types.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The value that is expected</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Object,System.Object,System.String)">
+ <summary>
+ Verifies that two objects are equal. Two objects are considered
+ equal if both are null, or if both have the same value. NUnit
+ has special semantics for some object types.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The value that is expected</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreEqual(System.Object,System.Object)">
+ <summary>
+ Verifies that two objects are equal. Two objects are considered
+ equal if both are null, or if both have the same value. NUnit
+ has special semantics for some object types.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The value that is expected</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int32,System.Int32,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int32,System.Int32,System.String)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int32,System.Int32)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int64,System.Int64,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int64,System.Int64,System.String)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Int64,System.Int64)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt32,System.UInt32,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt32,System.UInt32,System.String)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt32,System.UInt32)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt64,System.UInt64,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt64,System.UInt64,System.String)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.UInt64,System.UInt64)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Decimal,System.Decimal,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Decimal,System.Decimal,System.String)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Decimal,System.Decimal)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Single,System.Single,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Single,System.Single,System.String)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Single,System.Single)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Double,System.Double,System.String,System.Object[])">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Double,System.Double,System.String)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Double,System.Double)">
+ <summary>
+ Verifies that two values are not equal. If they are equal, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Object,System.Object,System.String,System.Object[])">
+ <summary>
+ Verifies that two objects are not equal. Two objects are considered
+ equal if both are null, or if both have the same value. NUnit
+ has special semantics for some object types.
+ If they are equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The value that is expected</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Object,System.Object,System.String)">
+ <summary>
+ Verifies that two objects are not equal. Two objects are considered
+ equal if both are null, or if both have the same value. NUnit
+ has special semantics for some object types.
+ If they are equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The value that is expected</param>
+ <param name="actual">The actual value</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotEqual(System.Object,System.Object)">
+ <summary>
+ Verifies that two objects are not equal. Two objects are considered
+ equal if both are null, or if both have the same value. NUnit
+ has special semantics for some object types.
+ If they are equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The value that is expected</param>
+ <param name="actual">The actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreSame(System.Object,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that two objects refer to the same object. If they
+ are not the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected object</param>
+ <param name="actual">The actual object</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreSame(System.Object,System.Object,System.String)">
+ <summary>
+ Asserts that two objects refer to the same object. If they
+ are not the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected object</param>
+ <param name="actual">The actual object</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreSame(System.Object,System.Object)">
+ <summary>
+ Asserts that two objects refer to the same object. If they
+ are not the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected object</param>
+ <param name="actual">The actual object</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotSame(System.Object,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that two objects do not refer to the same object. If they
+ are the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected object</param>
+ <param name="actual">The actual object</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotSame(System.Object,System.Object,System.String)">
+ <summary>
+ Asserts that two objects do not refer to the same object. If they
+ are the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected object</param>
+ <param name="actual">The actual object</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.AreNotSame(System.Object,System.Object)">
+ <summary>
+ Asserts that two objects do not refer to the same object. If they
+ are the same an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected object</param>
+ <param name="actual">The actual object</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Int32,System.Int32,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Int32,System.Int32,System.String)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Int32,System.Int32)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.UInt32,System.UInt32,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.UInt32,System.UInt32,System.String)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.UInt32,System.UInt32)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Int64,System.Int64,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Int64,System.Int64,System.String)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Int64,System.Int64)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.UInt64,System.UInt64,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.UInt64,System.UInt64,System.String)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.UInt64,System.UInt64)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Decimal,System.Decimal,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Decimal,System.Decimal,System.String)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Decimal,System.Decimal)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Double,System.Double,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Double,System.Double,System.String)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Double,System.Double)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Single,System.Single,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Single,System.Single,System.String)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.Single,System.Single)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.IComparable,System.IComparable,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.IComparable,System.IComparable,System.String)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Greater(System.IComparable,System.IComparable)">
+ <summary>
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Int32,System.Int32,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Int32,System.Int32,System.String)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Int32,System.Int32)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.UInt32,System.UInt32,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.UInt32,System.UInt32,System.String)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.UInt32,System.UInt32)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Int64,System.Int64,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Int64,System.Int64,System.String)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Int64,System.Int64)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.UInt64,System.UInt64,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.UInt64,System.UInt64,System.String)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.UInt64,System.UInt64)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Decimal,System.Decimal,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Decimal,System.Decimal,System.String)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Decimal,System.Decimal)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Double,System.Double,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Double,System.Double,System.String)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Double,System.Double)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Single,System.Single,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Single,System.Single,System.String)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.Single,System.Single)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.IComparable,System.IComparable,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.IComparable,System.IComparable,System.String)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Less(System.IComparable,System.IComparable)">
+ <summary>
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int32,System.Int32,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int32,System.Int32,System.String)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int32,System.Int32)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt32,System.UInt32,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt32,System.UInt32,System.String)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt32,System.UInt32)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int64,System.Int64,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int64,System.Int64,System.String)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Int64,System.Int64)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt64,System.UInt64,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt64,System.UInt64,System.String)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.UInt64,System.UInt64)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Decimal,System.Decimal,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Decimal,System.Decimal,System.String)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Decimal,System.Decimal)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Double,System.Double,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Double,System.Double,System.String)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Double,System.Double)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Single,System.Single,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Single,System.Single,System.String)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.Single,System.Single)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.IComparable,System.IComparable,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.IComparable,System.IComparable,System.String)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.GreaterOrEqual(System.IComparable,System.IComparable)">
+ <summary>
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be greater</param>
+ <param name="arg2">The second value, expected to be less</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int32,System.Int32,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int32,System.Int32,System.String)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int32,System.Int32)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt32,System.UInt32,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt32,System.UInt32,System.String)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt32,System.UInt32)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int64,System.Int64,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int64,System.Int64,System.String)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Int64,System.Int64)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt64,System.UInt64,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt64,System.UInt64,System.String)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.UInt64,System.UInt64)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Decimal,System.Decimal,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Decimal,System.Decimal,System.String)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Decimal,System.Decimal)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Double,System.Double,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Double,System.Double,System.String)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Double,System.Double)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Single,System.Single,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Single,System.Single,System.String)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.Single,System.Single)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.IComparable,System.IComparable,System.String,System.Object[])">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.IComparable,System.IComparable,System.String)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.LessOrEqual(System.IComparable,System.IComparable)">
+ <summary>
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="arg1">The first value, expected to be less</param>
+ <param name="arg2">The second value, expected to be greater</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Contains(System.Object,System.Collections.ICollection,System.String,System.Object[])">
+ <summary>
+ Asserts that an object is contained in a list.
+ </summary>
+ <param name="expected">The expected object</param>
+ <param name="actual">The list to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Array of objects to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Contains(System.Object,System.Collections.ICollection,System.String)">
+ <summary>
+ Asserts that an object is contained in a list.
+ </summary>
+ <param name="expected">The expected object</param>
+ <param name="actual">The list to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assert.Contains(System.Object,System.Collections.ICollection)">
+ <summary>
+ Asserts that an object is contained in a list.
+ </summary>
+ <param name="expected">The expected object</param>
+ <param name="actual">The list to be examined</param>
+ </member>
+ <member name="P:NUnit.Framework.Assert.Counter">
+ <summary>
+ Gets the number of assertions executed so far and
+ resets the counter to zero.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.RequiredAddinAttribute">
+ <summary>
+ RequiredAddinAttribute may be used to indicate the names of any addins
+ that must be present in order to run some or all of the tests in an
+ assembly. If the addin is not loaded, the entire assembly is marked
+ as NotRunnable.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.RequiredAddinAttribute.#ctor(System.String)">
+ <summary>
+ Initializes a new instance of the <see cref="T:RequiredAddinAttribute"/> class.
+ </summary>
+ <param name="requiredAddin">The required addin.</param>
+ </member>
+ <member name="P:NUnit.Framework.RequiredAddinAttribute.RequiredAddin">
+ <summary>
+ Gets the name of required addin.
+ </summary>
+ <value>The required addin name.</value>
+ </member>
+ <member name="T:NUnit.Framework.CombinatorialAttribute">
+ <summary>
+ Marks a test to use a combinatorial join of any argument
+ data provided. Since this is the default, the attribute is
+ not needed.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.PropertyAttribute">
+ <summary>
+ PropertyAttribute is used to attach information to a test as a name/value pair..
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.String,System.String)">
+ <summary>
+ Construct a PropertyAttribute with a name and string value
+ </summary>
+ <param name="propertyName">The name of the property</param>
+ <param name="propertyValue">The property value</param>
+ </member>
+ <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.String,System.Int32)">
+ <summary>
+ Construct a PropertyAttribute with a name and int value
+ </summary>
+ <param name="propertyName">The name of the property</param>
+ <param name="propertyValue">The property value</param>
+ </member>
+ <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.String,System.Double)">
+ <summary>
+ Construct a PropertyAttribute with a name and double value
+ </summary>
+ <param name="propertyName">The name of the property</param>
+ <param name="propertyValue">The property value</param>
+ </member>
+ <member name="M:NUnit.Framework.PropertyAttribute.#ctor">
+ <summary>
+ Constructor for derived classes that set the
+ property dictionary directly.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.PropertyAttribute.#ctor(System.Object)">
+ <summary>
+ Constructor for use by derived classes that use the
+ name of the type as the property name. Derived classes
+ must ensure that the Type of the property value is
+ a standard type supported by the BCL. Any custom
+ types will cause a serialization Exception when
+ in the client.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.PropertyAttribute.Properties">
+ <summary>
+ Gets the property dictionary for this attribute
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.CombinatorialAttribute.#ctor">
+ <summary>
+ Default constructor
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.PairwiseAttribute">
+ <summary>
+ Marks a test to use a combinatorial join of any argument
+ data provided. Since this is the default, the attribute is
+ not needed.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.PairwiseAttribute.#ctor">
+ <summary>
+ Default constructor
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.SequentialAttribute">
+ <summary>
+ Marks a test to use a combinatorial join of any argument
+ data provided. Since this is the default, the attribute is
+ not needed.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.SequentialAttribute.#ctor">
+ <summary>
+ Default constructor
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TestAttribute">
+ <summary>
+ Adding this attribute to a method within a <seealso cref="T:NUnit.Framework.TestFixtureAttribute"/>
+ class makes the method callable from the NUnit test runner. There is a property
+ called Description which is optional which you can provide a more detailed test
+ description. This class cannot be inherited.
+ </summary>
+
+ <example>
+ [TestFixture]
+ public class Fixture
+ {
+ [Test]
+ public void MethodToTest()
+ {}
+
+ [Test(Description = "more detailed description")]
+ publc void TestDescriptionMethod()
+ {}
+ }
+ </example>
+
+ </member>
+ <member name="P:NUnit.Framework.TestAttribute.Description">
+ <summary>
+ Descriptive text for this test
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TestFixtureAttribute">
+ <example>
+ [TestFixture]
+ public class ExampleClass
+ {}
+ </example>
+ </member>
+ <member name="M:NUnit.Framework.TestFixtureAttribute.#ctor">
+ <summary>
+ Default constructor
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.TestFixtureAttribute.#ctor(System.Object[])">
+ <summary>
+ Construct with a object[] representing a set of arguments.
+ In .NET 2.0, the arguments may later be separated into
+ type arguments and constructor arguments.
+ </summary>
+ <param name="arguments"></param>
+ </member>
+ <member name="P:NUnit.Framework.TestFixtureAttribute.Description">
+ <summary>
+ Descriptive text for this fixture
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestFixtureAttribute.Arguments">
+ <summary>
+ The arguments originally provided to the attribute
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.TestFixtureAttribute.Ignore">
+ <summary>
+ Gets or sets a value indicating whether this <see cref="T:NUnit.Framework.TestFixtureAttribute"/> should be ignored.
+ </summary>
+ <value><c>true</c> if ignore; otherwise, <c>false</c>.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestFixtureAttribute.IgnoreReason">
+ <summary>
+ Gets or sets the ignore reason. May set Ignored as a side effect.
+ </summary>
+ <value>The ignore reason.</value>
+ </member>
+ <member name="P:NUnit.Framework.TestFixtureAttribute.TypeArgs">
+ <summary>
+ Get or set the type arguments. If not set
+ explicitly, any leading arguments that are
+ Types are taken as type arguments.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.CollectionAssert">
+ <summary>
+ A set of Assert methods operationg on one or more collections
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.Equals(System.Object,System.Object)">
+ <summary>
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.ReferenceEquals(System.Object,System.Object)">
+ <summary>
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreInstancesOfType(System.Collections.IEnumerable,System.Type)">
+ <summary>
+ Asserts that all items contained in collection are of the type specified by expectedType.
+ </summary>
+ <param name="collection">IEnumerable containing objects to be considered</param>
+ <param name="expectedType">System.Type that all objects in collection must be instances of</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreInstancesOfType(System.Collections.IEnumerable,System.Type,System.String)">
+ <summary>
+ Asserts that all items contained in collection are of the type specified by expectedType.
+ </summary>
+ <param name="collection">IEnumerable containing objects to be considered</param>
+ <param name="expectedType">System.Type that all objects in collection must be instances of</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreInstancesOfType(System.Collections.IEnumerable,System.Type,System.String,System.Object[])">
+ <summary>
+ Asserts that all items contained in collection are of the type specified by expectedType.
+ </summary>
+ <param name="collection">IEnumerable containing objects to be considered</param>
+ <param name="expectedType">System.Type that all objects in collection must be instances of</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreNotNull(System.Collections.IEnumerable)">
+ <summary>
+ Asserts that all items contained in collection are not equal to null.
+ </summary>
+ <param name="collection">IEnumerable containing objects to be considered</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreNotNull(System.Collections.IEnumerable,System.String)">
+ <summary>
+ Asserts that all items contained in collection are not equal to null.
+ </summary>
+ <param name="collection">IEnumerable containing objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreNotNull(System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Asserts that all items contained in collection are not equal to null.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreUnique(System.Collections.IEnumerable)">
+ <summary>
+ Ensures that every object contained in collection exists within the collection
+ once and only once.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreUnique(System.Collections.IEnumerable,System.String)">
+ <summary>
+ Ensures that every object contained in collection exists within the collection
+ once and only once.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AllItemsAreUnique(System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Ensures that every object contained in collection exists within the collection
+ once and only once.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable)">
+ <summary>
+ Asserts that expected and actual are exactly equal. The collections must have the same count,
+ and contain the exact same objects in the same order.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer)">
+ <summary>
+ Asserts that expected and actual are exactly equal. The collections must have the same count,
+ and contain the exact same objects in the same order.
+ If comparer is not null then it will be used to compare the objects.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+ <summary>
+ Asserts that expected and actual are exactly equal. The collections must have the same count,
+ and contain the exact same objects in the same order.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer,System.String)">
+ <summary>
+ Asserts that expected and actual are exactly equal. The collections must have the same count,
+ and contain the exact same objects in the same order.
+ If comparer is not null then it will be used to compare the objects.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Asserts that expected and actual are exactly equal. The collections must have the same count,
+ and contain the exact same objects in the same order.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer,System.String,System.Object[])">
+ <summary>
+ Asserts that expected and actual are exactly equal. The collections must have the same count,
+ and contain the exact same objects in the same order.
+ If comparer is not null then it will be used to compare the objects.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable)">
+ <summary>
+ Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+ <summary>
+ Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable)">
+ <summary>
+ Asserts that expected and actual are not exactly equal.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer)">
+ <summary>
+ Asserts that expected and actual are not exactly equal.
+ If comparer is not null then it will be used to compare the objects.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+ <summary>
+ Asserts that expected and actual are not exactly equal.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer,System.String)">
+ <summary>
+ Asserts that expected and actual are not exactly equal.
+ If comparer is not null then it will be used to compare the objects.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Asserts that expected and actual are not exactly equal.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreNotEqual(System.Collections.IEnumerable,System.Collections.IEnumerable,System.Collections.IComparer,System.String,System.Object[])">
+ <summary>
+ Asserts that expected and actual are not exactly equal.
+ If comparer is not null then it will be used to compare the objects.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="comparer">The IComparer to use in comparing objects from each IEnumerable</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreNotEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable)">
+ <summary>
+ Asserts that expected and actual are not equivalent.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreNotEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+ <summary>
+ Asserts that expected and actual are not equivalent.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.AreNotEquivalent(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Asserts that expected and actual are not equivalent.
+ </summary>
+ <param name="expected">The first IEnumerable of objects to be considered</param>
+ <param name="actual">The second IEnumerable of objects to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.Contains(System.Collections.IEnumerable,System.Object)">
+ <summary>
+ Asserts that collection contains actual as an item.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ <param name="actual">Object to be found within collection</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.Contains(System.Collections.IEnumerable,System.Object,System.String)">
+ <summary>
+ Asserts that collection contains actual as an item.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ <param name="actual">Object to be found within collection</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.Contains(System.Collections.IEnumerable,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that collection contains actual as an item.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ <param name="actual">Object to be found within collection</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.DoesNotContain(System.Collections.IEnumerable,System.Object)">
+ <summary>
+ Asserts that collection does not contain actual as an item.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ <param name="actual">Object that cannot exist within collection</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.DoesNotContain(System.Collections.IEnumerable,System.Object,System.String)">
+ <summary>
+ Asserts that collection does not contain actual as an item.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ <param name="actual">Object that cannot exist within collection</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.DoesNotContain(System.Collections.IEnumerable,System.Object,System.String,System.Object[])">
+ <summary>
+ Asserts that collection does not contain actual as an item.
+ </summary>
+ <param name="collection">IEnumerable of objects to be considered</param>
+ <param name="actual">Object that cannot exist within collection</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsNotSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable)">
+ <summary>
+ Asserts that superset is not a subject of subset.
+ </summary>
+ <param name="subset">The IEnumerable superset to be considered</param>
+ <param name="superset">The IEnumerable subset to be considered</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsNotSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+ <summary>
+ Asserts that superset is not a subject of subset.
+ </summary>
+ <param name="subset">The IEnumerable superset to be considered</param>
+ <param name="superset">The IEnumerable subset to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsNotSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Asserts that superset is not a subject of subset.
+ </summary>
+ <param name="subset">The IEnumerable superset to be considered</param>
+ <param name="superset">The IEnumerable subset to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable)">
+ <summary>
+ Asserts that superset is a subset of subset.
+ </summary>
+ <param name="subset">The IEnumerable superset to be considered</param>
+ <param name="superset">The IEnumerable subset to be considered</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String)">
+ <summary>
+ Asserts that superset is a subset of subset.
+ </summary>
+ <param name="subset">The IEnumerable superset to be considered</param>
+ <param name="superset">The IEnumerable subset to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsSubsetOf(System.Collections.IEnumerable,System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Asserts that superset is a subset of subset.
+ </summary>
+ <param name="subset">The IEnumerable superset to be considered</param>
+ <param name="superset">The IEnumerable subset to be considered</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsEmpty(System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Assert that an array, list or other collection is empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ <param name="message">The message to be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsEmpty(System.Collections.IEnumerable,System.String)">
+ <summary>
+ Assert that an array, list or other collection is empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ <param name="message">The message to be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsEmpty(System.Collections.IEnumerable)">
+ <summary>
+ Assert that an array,list or other collection is empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsNotEmpty(System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Assert that an array, list or other collection is empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ <param name="message">The message to be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsNotEmpty(System.Collections.IEnumerable,System.String)">
+ <summary>
+ Assert that an array, list or other collection is empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ <param name="message">The message to be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsNotEmpty(System.Collections.IEnumerable)">
+ <summary>
+ Assert that an array,list or other collection is empty
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.String,System.Object[])">
+ <summary>
+ Assert that an array, list or other collection is ordered
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ <param name="message">The message to be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.String)">
+ <summary>
+ Assert that an array, list or other collection is ordered
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ <param name="message">The message to be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable)">
+ <summary>
+ Assert that an array, list or other collection is ordered
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.Collections.IComparer,System.String,System.Object[])">
+ <summary>
+ Assert that an array, list or other collection is ordered
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ <param name="comparer">A custom comparer to perform the comparisons</param>
+ <param name="message">The message to be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.Collections.IComparer,System.String)">
+ <summary>
+ Assert that an array, list or other collection is ordered
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ <param name="comparer">A custom comparer to perform the comparisons</param>
+ <param name="message">The message to be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.CollectionAssert.IsOrdered(System.Collections.IEnumerable,System.Collections.IComparer)">
+ <summary>
+ Assert that an array, list or other collection is ordered
+ </summary>
+ <param name="collection">An array, list or other collection implementing IEnumerable</param>
+ <param name="comparer">A custom comparer to perform the comparisons</param>
+ </member>
+ <member name="T:NUnit.Framework.ParameterDataAttribute">
+ <summary>
+ Abstract base class for attributes that apply to parameters
+ and supply data for the parameter.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.ParameterDataAttribute.GetData(System.Reflection.ParameterInfo)">
+ <summary>
+ Gets the data to be provided to the specified parameter
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.ValuesAttribute">
+ <summary>
+ ValuesAttribute is used to provide literal arguments for
+ an individual parameter of a test.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.ValuesAttribute.data">
+ <summary>
+ The collection of data to be returned. Must
+ be set by any derived attribute classes.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object)">
+ <summary>
+ Construct with one argument
+ </summary>
+ <param name="arg1"></param>
+ </member>
+ <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object,System.Object)">
+ <summary>
+ Construct with two arguments
+ </summary>
+ <param name="arg1"></param>
+ <param name="arg2"></param>
+ </member>
+ <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object,System.Object,System.Object)">
+ <summary>
+ Construct with three arguments
+ </summary>
+ <param name="arg1"></param>
+ <param name="arg2"></param>
+ <param name="arg3"></param>
+ </member>
+ <member name="M:NUnit.Framework.ValuesAttribute.#ctor(System.Object[])">
+ <summary>
+ Construct with an array of arguments
+ </summary>
+ <param name="args"></param>
+ </member>
+ <member name="M:NUnit.Framework.ValuesAttribute.GetData(System.Reflection.ParameterInfo)">
+ <summary>
+ Get the collection of values to be used as arguments
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.AssertionException">
+ <summary>
+ Thrown when an assertion failed.
+ </summary>
+
+ </member>
+ <member name="M:NUnit.Framework.AssertionException.#ctor(System.String)">
+ <param name="message">The error message that explains
+ the reason for the exception</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionException.#ctor(System.String,System.Exception)">
+ <param name="message">The error message that explains
+ the reason for the exception</param>
+ <param name="inner">The exception that caused the
+ current exception</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+ <summary>
+ Serialization Constructor
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TimeoutAttribute">
+ <summary>
+ WUsed on a method, marks the test with a timeout value in milliseconds.
+ The test will be run in a separate thread and is cancelled if the timeout
+ is exceeded. Used on a method or assembly, sets the default timeout
+ for all contained test methods.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.TimeoutAttribute.#ctor(System.Int32)">
+ <summary>
+ Construct a TimeoutAttribute given a time in milliseconds
+ </summary>
+ <param name="timeout">The timeout value in milliseconds</param>
+ </member>
+ <member name="T:NUnit.Framework.RequiresSTAAttribute">
+ <summary>
+ Marks a test that must run in the STA, causing it
+ to run in a separate thread if necessary.
+
+ On methods, you may also use STAThreadAttribute
+ to serve the same purpose.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.RequiresSTAAttribute.#ctor">
+ <summary>
+ Construct a RequiresSTAAttribute
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.RequiresMTAAttribute">
+ <summary>
+ Marks a test that must run in the MTA, causing it
+ to run in a separate thread if necessary.
+
+ On methods, you may also use MTAThreadAttribute
+ to serve the same purpose.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.RequiresMTAAttribute.#ctor">
+ <summary>
+ Construct a RequiresMTAAttribute
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.RequiresThreadAttribute">
+ <summary>
+ Marks a test that must run on a separate thread.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.RequiresThreadAttribute.#ctor">
+ <summary>
+ Construct a RequiresThreadAttribute
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.RequiresThreadAttribute.#ctor(System.Threading.ApartmentState)">
+ <summary>
+ Construct a RequiresThreadAttribute, specifying the apartment
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.AssertionHelper">
+ <summary>
+ AssertionHelper is an optional base class for user tests,
+ allowing the use of shorter names for constraints and
+ asserts and avoiding conflict with the definition of
+ <see cref="T:NUnit.Framework.Is"/>, from which it inherits much of its
+ behavior, in certain mock object frameworks.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Object,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure. Works
+ identically to <see cref="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint)"/>
+ </summary>
+ <param name="constraint">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure. Works
+ identically to <see cref="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String)"/>
+ </summary>
+ <param name="constraint">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure. Works
+ identically to <see cref="M:NUnit.Framework.Assert.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])"/>
+ </summary>
+ <param name="constraint">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expr">A Constraint expression to be applied</param>
+ <param name="del">An ActualValueDelegate returning the value to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expr">A Constraint expression to be applied</param>
+ <param name="del">An ActualValueDelegate returning the value to be tested</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="del">An ActualValueDelegate returning the value to be tested</param>
+ <param name="expr">A Constraint expression to be applied</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect``1(``0@,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="constraint">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+ <summary>
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="constraint">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+ <summary>
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ </summary>
+ <param name="expression">A Constraint to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Boolean,System.String,System.Object[])">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>. Works Identically to
+ <see cref="M:NUnit.Framework.Assert.That(System.Boolean,System.String,System.Object[])"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display if the condition is false</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Boolean,System.String)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>. Works Identically to
+ <see cref="M:NUnit.Framework.Assert.That(System.Boolean,System.String)"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display if the condition is false</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(System.Boolean)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.AssertionException"/>. Works Identically to <see cref="M:NUnit.Framework.Assert.That(System.Boolean)"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Expect(NUnit.Framework.TestDelegate,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Asserts that the code represented by a delegate throws an exception
+ that satisfies the constraint provided.
+ </summary>
+ <param name="code">A TestDelegate to be executed</param>
+ <param name="constraint">A ThrowsConstraint used in the test</param>
+ </member>
+ <member name="M:NUnit.Framework.AssertionHelper.Map(System.Collections.ICollection)">
+ <summary>
+ Returns a ListMapper based on a collection.
+ </summary>
+ <param name="original">The original collection</param>
+ <returns></returns>
+ </member>
+ <member name="T:NUnit.Framework.CategoryAttribute">
+ <summary>
+ Attribute used to apply a category to a test
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.CategoryAttribute.categoryName">
+ <summary>
+ The name of the category
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.CategoryAttribute.#ctor(System.String)">
+ <summary>
+ Construct attribute for a given category
+ </summary>
+ <param name="name">The name of the category</param>
+ </member>
+ <member name="M:NUnit.Framework.CategoryAttribute.#ctor">
+ <summary>
+ Protected constructor uses the Type name as the name
+ of the category.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.CategoryAttribute.Name">
+ <summary>
+ The name of the category
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.RandomAttribute">
+ <summary>
+ RandomAttribute is used to supply a set of random values
+ to a single parameter of a parameterized test.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.RandomAttribute.#ctor(System.Int32)">
+ <summary>
+ Construct a set of doubles from 0.0 to 1.0,
+ specifying only the count.
+ </summary>
+ <param name="count"></param>
+ </member>
+ <member name="M:NUnit.Framework.RandomAttribute.#ctor(System.Double,System.Double,System.Int32)">
+ <summary>
+ Construct a set of doubles from min to max
+ </summary>
+ <param name="min"></param>
+ <param name="max"></param>
+ <param name="count"></param>
+ </member>
+ <member name="M:NUnit.Framework.RandomAttribute.#ctor(System.Int32,System.Int32,System.Int32)">
+ <summary>
+ Construct a set of ints from min to max
+ </summary>
+ <param name="min"></param>
+ <param name="max"></param>
+ <param name="count"></param>
+ </member>
+ <member name="M:NUnit.Framework.RandomAttribute.GetData(System.Reflection.ParameterInfo)">
+ <summary>
+ Get the collection of values to be used as arguments
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.DescriptionAttribute">
+ <summary>
+ Attribute used to provide descriptive text about a
+ test case or fixture.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.DescriptionAttribute.#ctor(System.String)">
+ <summary>
+ Construct the attribute
+ </summary>
+ <param name="description">Text describing the test</param>
+ </member>
+ <member name="P:NUnit.Framework.DescriptionAttribute.Description">
+ <summary>
+ Gets the test description
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.ExplicitAttribute">
+ <summary>
+ ExplicitAttribute marks a test or test fixture so that it will
+ only be run if explicitly executed from the gui or command line
+ or if it is included by use of a filter. The test will not be
+ run simply because an enclosing suite is run.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.ExplicitAttribute.#ctor">
+ <summary>
+ Default constructor
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.ExplicitAttribute.#ctor(System.String)">
+ <summary>
+ Constructor with a reason
+ </summary>
+ <param name="reason">The reason test is marked explicit</param>
+ </member>
+ <member name="P:NUnit.Framework.ExplicitAttribute.Reason">
+ <summary>
+ The reason test is marked explicit
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Assume">
+ <summary>
+ Provides static methods to express the assumptions
+ that must be met for a test to give a meaningful
+ result. If an assumption is not met, the test
+ should produce an inconclusive result.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Assume.Equals(System.Object,System.Object)">
+ <summary>
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.ReferenceEquals(System.Object,System.Object)">
+ <summary>
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+ </summary>
+ <param name="expression">A Constraint expression to be applied</param>
+ <param name="actual">The actual value to test</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+ </summary>
+ <param name="expression">A Constraint expression to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(System.Object,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+ </summary>
+ <param name="expression">A Constraint expression to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+ </summary>
+ <param name="expr">A Constraint expression to be applied</param>
+ <param name="del">An ActualValueDelegate returning the value to be tested</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+ </summary>
+ <param name="expr">A Constraint expression to be applied</param>
+ <param name="del">An ActualValueDelegate returning the value to be tested</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(NUnit.Framework.Constraints.ActualValueDelegate,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+ <summary>
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+ </summary>
+ <param name="del">An ActualValueDelegate returning the value to be tested</param>
+ <param name="expr">A Constraint expression to be applied</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+ </summary>
+ <param name="expression">A Constraint expression to be applied</param>
+ <param name="actual">The actual value to test</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String)">
+ <summary>
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+ </summary>
+ <param name="expression">A Constraint expression to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That``1(``0@,NUnit.Framework.Constraints.IResolveConstraint,System.String,System.Object[])">
+ <summary>
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+ </summary>
+ <param name="expression">A Constraint expression to be applied</param>
+ <param name="actual">The actual value to test</param>
+ <param name="message">The message that will be displayed on failure</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(System.Boolean,System.String,System.Object[])">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.InconclusiveException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display if the condition is false</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(System.Boolean,System.String)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the method throws
+ an <see cref="T:NUnit.Framework.InconclusiveException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ <param name="message">The message to display if the condition is false</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(System.Boolean)">
+ <summary>
+ Asserts that a condition is true. If the condition is false the
+ method throws an <see cref="T:NUnit.Framework.InconclusiveException"/>.
+ </summary>
+ <param name="condition">The evaluated condition</param>
+ </member>
+ <member name="M:NUnit.Framework.Assume.That(NUnit.Framework.TestDelegate,NUnit.Framework.Constraints.IResolveConstraint)">
+ <summary>
+ Asserts that the code represented by a delegate throws an exception
+ that satisfies the constraint provided.
+ </summary>
+ <param name="code">A TestDelegate to be executed</param>
+ <param name="constraint">A ThrowsConstraint used in the test</param>
+ </member>
+ <member name="T:NUnit.Framework.GlobalSettings">
+ <summary>
+ GlobalSettings is a place for setting default values used
+ by the framework in performing asserts.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.GlobalSettings.DefaultFloatingPointTolerance">
+ <summary>
+ Default tolerance for floating point equality
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Is">
+ <summary>
+ Helper class with properties and methods that supply
+ a number of constraints used in Asserts.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.EqualTo(System.Object)">
+ <summary>
+ Returns a constraint that tests two items for equality
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.SameAs(System.Object)">
+ <summary>
+ Returns a constraint that tests that two references are the same object
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.GreaterThan(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is greater than the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.GreaterThanOrEqualTo(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.AtLeast(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.LessThan(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is less than the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.LessThanOrEqualTo(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.AtMost(System.Object)">
+ <summary>
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.TypeOf(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.TypeOf``1">
+ <summary>
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.InstanceOf(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.InstanceOf``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.InstanceOfType(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.InstanceOfType``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.AssignableFrom(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.AssignableFrom``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.AssignableTo(System.Type)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.AssignableTo``1">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.EquivalentTo(System.Collections.IEnumerable)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is a collection containing the same elements as the
+ collection supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.SubsetOf(System.Collections.IEnumerable)">
+ <summary>
+ Returns a constraint that tests whether the actual value
+ is a subset of the collection supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.StringContaining(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.StringStarting(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.StringEnding(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.StringMatching(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.SamePath(System.String)">
+ <summary>
+ Returns a constraint that tests whether the path provided
+ is the same as an expected path after canonicalization.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.SamePathOrUnder(System.String)">
+ <summary>
+ Returns a constraint that tests whether the path provided
+ is the same path or under an expected path after canonicalization.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Is.InRange(System.IComparable,System.IComparable)">
+ <summary>
+ Returns a constraint that tests whether the actual value falls
+ within a specified range.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.Not">
+ <summary>
+ Returns a ConstraintExpression that negates any
+ following constraint.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.All">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.Null">
+ <summary>
+ Returns a constraint that tests for null
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.True">
+ <summary>
+ Returns a constraint that tests for True
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.False">
+ <summary>
+ Returns a constraint that tests for False
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.NaN">
+ <summary>
+ Returns a constraint that tests for NaN
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.Empty">
+ <summary>
+ Returns a constraint that tests for empty
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.Unique">
+ <summary>
+ Returns a constraint that tests whether a collection
+ contains all unique items.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.BinarySerializable">
+ <summary>
+ Returns a constraint that tests whether an object graph is serializable in binary format.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.XmlSerializable">
+ <summary>
+ Returns a constraint that tests whether an object graph is serializable in xml format.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Is.Ordered">
+ <summary>
+ Returns a constraint that tests whether a collection is ordered
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.IExpectException">
+ <summary>
+ Interface implemented by a user fixture in order to
+ validate any expected exceptions. It is only called
+ for test methods marked with the ExpectedException
+ attribute.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.IExpectException.HandleException(System.Exception)">
+ <summary>
+ Method to handle an expected exception
+ </summary>
+ <param name="ex">The exception to be handled</param>
+ </member>
+ <member name="T:NUnit.Framework.IgnoreAttribute">
+ <summary>
+ Attribute used to mark a test that is to be ignored.
+ Ignored tests result in a warning message when the
+ tests are run.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.IgnoreAttribute.#ctor">
+ <summary>
+ Constructs the attribute without giving a reason
+ for ignoring the test.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.IgnoreAttribute.#ctor(System.String)">
+ <summary>
+ Constructs the attribute giving a reason for ignoring the test
+ </summary>
+ <param name="reason">The reason for ignoring the test</param>
+ </member>
+ <member name="P:NUnit.Framework.IgnoreAttribute.Reason">
+ <summary>
+ The reason for ignoring a test
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.IgnoreException">
+ <summary>
+ Thrown when an assertion failed.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.IgnoreException.#ctor(System.String)">
+ <param name="message"></param>
+ </member>
+ <member name="M:NUnit.Framework.IgnoreException.#ctor(System.String,System.Exception)">
+ <param name="message">The error message that explains
+ the reason for the exception</param>
+ <param name="inner">The exception that caused the
+ current exception</param>
+ </member>
+ <member name="M:NUnit.Framework.IgnoreException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+ <summary>
+ Serialization Constructor
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.IncludeExcludeAttribute">
+ <summary>
+ Abstract base for Attributes that are used to include tests
+ in the test run based on environmental settings.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.IncludeExcludeAttribute.#ctor">
+ <summary>
+ Constructor with no included items specified, for use
+ with named property syntax.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.IncludeExcludeAttribute.#ctor(System.String)">
+ <summary>
+ Constructor taking one or more included items
+ </summary>
+ <param name="include">Comma-delimited list of included items</param>
+ </member>
+ <member name="P:NUnit.Framework.IncludeExcludeAttribute.Include">
+ <summary>
+ Name of the item that is needed in order for
+ a test to run. Multiple itemss may be given,
+ separated by a comma.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.IncludeExcludeAttribute.Exclude">
+ <summary>
+ Name of the item to be excluded. Multiple items
+ may be given, separated by a comma.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.IncludeExcludeAttribute.Reason">
+ <summary>
+ The reason for including or excluding the test
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.PlatformAttribute">
+ <summary>
+ PlatformAttribute is used to mark a test fixture or an
+ individual method as applying to a particular platform only.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.PlatformAttribute.#ctor">
+ <summary>
+ Constructor with no platforms specified, for use
+ with named property syntax.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.PlatformAttribute.#ctor(System.String)">
+ <summary>
+ Constructor taking one or more platforms
+ </summary>
+ <param name="platforms">Comma-deliminted list of platforms</param>
+ </member>
+ <member name="T:NUnit.Framework.CultureAttribute">
+ <summary>
+ CultureAttribute is used to mark a test fixture or an
+ individual method as applying to a particular Culture only.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.CultureAttribute.#ctor">
+ <summary>
+ Constructor with no cultures specified, for use
+ with named property syntax.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.CultureAttribute.#ctor(System.String)">
+ <summary>
+ Constructor taking one or more cultures
+ </summary>
+ <param name="cultures">Comma-deliminted list of cultures</param>
+ </member>
+ <member name="T:NUnit.Framework.RangeAttribute">
+ <summary>
+ RangeAttribute is used to supply a range of values to an
+ individual parameter of a parameterized test.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Int32,System.Int32)">
+ <summary>
+ Construct a range of ints using default step of 1
+ </summary>
+ <param name="from"></param>
+ <param name="to"></param>
+ </member>
+ <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Int32,System.Int32,System.Int32)">
+ <summary>
+ Construct a range of ints specifying the step size
+ </summary>
+ <param name="from"></param>
+ <param name="to"></param>
+ <param name="step"></param>
+ </member>
+ <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Int64,System.Int64,System.Int64)">
+ <summary>
+ Construct a range of longs
+ </summary>
+ <param name="from"></param>
+ <param name="to"></param>
+ <param name="step"></param>
+ </member>
+ <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Double,System.Double,System.Double)">
+ <summary>
+ Construct a range of doubles
+ </summary>
+ <param name="from"></param>
+ <param name="to"></param>
+ <param name="step"></param>
+ </member>
+ <member name="M:NUnit.Framework.RangeAttribute.#ctor(System.Single,System.Single,System.Single)">
+ <summary>
+ Construct a range of floats
+ </summary>
+ <param name="from"></param>
+ <param name="to"></param>
+ <param name="step"></param>
+ </member>
+ <member name="T:NUnit.Framework.SetCultureAttribute">
+ <summary>
+ Summary description for SetCultureAttribute.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.SetCultureAttribute.#ctor(System.String)">
+ <summary>
+ Construct given the name of a culture
+ </summary>
+ <param name="culture"></param>
+ </member>
+ <member name="T:NUnit.Framework.ValueSourceAttribute">
+ <summary>
+ ValueSourceAttribute indicates the source to be used to
+ provide data for one parameter of a test method.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.ValueSourceAttribute.#ctor(System.String)">
+ <summary>
+ Construct with the name of the factory - for use with languages
+ that don't support params arrays.
+ </summary>
+ <param name="sourceName">The name of the data source to be used</param>
+ </member>
+ <member name="M:NUnit.Framework.ValueSourceAttribute.#ctor(System.Type,System.String)">
+ <summary>
+ Construct with a Type and name - for use with languages
+ that don't support params arrays.
+ </summary>
+ <param name="sourceType">The Type that will provide data</param>
+ <param name="sourceName">The name of the method, property or field that will provide data</param>
+ </member>
+ <member name="P:NUnit.Framework.ValueSourceAttribute.SourceName">
+ <summary>
+ The name of a the method, property or fiend to be used as a source
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.ValueSourceAttribute.SourceType">
+ <summary>
+ A Type to be used as a source
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TextMessageWriter">
+ <summary>
+ TextMessageWriter writes constraint descriptions and messages
+ in displayable form as a text stream. It tailors the display
+ of individual message components to form the standard message
+ format of NUnit assertion failure messages.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TextMessageWriter.Pfx_Expected">
+ <summary>
+ Prefix used for the expected value line of a message
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TextMessageWriter.Pfx_Actual">
+ <summary>
+ Prefix used for the actual value line of a message
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.TextMessageWriter.PrefixLength">
+ <summary>
+ Length of a message prefix
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.#ctor">
+ <summary>
+ Construct a TextMessageWriter
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.#ctor(System.String,System.Object[])">
+ <summary>
+ Construct a TextMessageWriter, specifying a user message
+ and optional formatting arguments.
+ </summary>
+ <param name="userMessage"></param>
+ <param name="args"></param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteMessageLine(System.Int32,System.String,System.Object[])">
+ <summary>
+ Method to write single line message with optional args, usually
+ written to precede the general failure message, at a givel
+ indentation level.
+ </summary>
+ <param name="level">The indentation level of the message</param>
+ <param name="message">The message to be written</param>
+ <param name="args">Any arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.DisplayDifferences(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Display Expected and Actual lines for a constraint. This
+ is called by MessageWriter's default implementation of
+ WriteMessageTo and provides the generic two-line display.
+ </summary>
+ <param name="constraint">The constraint that failed</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.DisplayDifferences(System.Object,System.Object)">
+ <summary>
+ Display Expected and Actual lines for given values. This
+ method may be called by constraints that need more control over
+ the display of actual and expected values than is provided
+ by the default implementation.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value causing the failure</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.DisplayDifferences(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance)">
+ <summary>
+ Display Expected and Actual lines for given values, including
+ a tolerance value on the expected line.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="actual">The actual value causing the failure</param>
+ <param name="tolerance">The tolerance within which the test was made</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.DisplayStringDifferences(System.String,System.String,System.Int32,System.Boolean,System.Boolean)">
+ <summary>
+ Display the expected and actual string values on separate lines.
+ If the mismatch parameter is >=0, an additional line is displayed
+ line containing a caret that points to the mismatch point.
+ </summary>
+ <param name="expected">The expected string value</param>
+ <param name="actual">The actual string value</param>
+ <param name="mismatch">The point at which the strings don't match or -1</param>
+ <param name="ignoreCase">If true, case is ignored in string comparisons</param>
+ <param name="clipping">If true, clip the strings to fit the max line length</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteConnector(System.String)">
+ <summary>
+ Writes the text for a connector.
+ </summary>
+ <param name="connector">The connector.</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WritePredicate(System.String)">
+ <summary>
+ Writes the text for a predicate.
+ </summary>
+ <param name="predicate">The predicate.</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteModifier(System.String)">
+ <summary>
+ Write the text for a modifier.
+ </summary>
+ <param name="modifier">The modifier.</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteExpectedValue(System.Object)">
+ <summary>
+ Writes the text for an expected value.
+ </summary>
+ <param name="expected">The expected value.</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteActualValue(System.Object)">
+ <summary>
+ Writes the text for an actual value.
+ </summary>
+ <param name="actual">The actual value.</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteValue(System.Object)">
+ <summary>
+ Writes the text for a generalized value.
+ </summary>
+ <param name="val">The value.</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteCollectionElements(System.Collections.ICollection,System.Int32,System.Int32)">
+ <summary>
+ Writes the text for a collection value,
+ starting at a particular point, to a max length
+ </summary>
+ <param name="collection">The collection containing elements to write.</param>
+ <param name="start">The starting point of the elements to write</param>
+ <param name="max">The maximum number of elements to write</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteExpectedLine(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Write the generic 'Expected' line for a constraint
+ </summary>
+ <param name="constraint">The constraint that failed</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteExpectedLine(System.Object)">
+ <summary>
+ Write the generic 'Expected' line for a given value
+ </summary>
+ <param name="expected">The expected value</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteExpectedLine(System.Object,NUnit.Framework.Constraints.Tolerance)">
+ <summary>
+ Write the generic 'Expected' line for a given value
+ and tolerance.
+ </summary>
+ <param name="expected">The expected value</param>
+ <param name="tolerance">The tolerance within which the test was made</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteActualLine(NUnit.Framework.Constraints.Constraint)">
+ <summary>
+ Write the generic 'Actual' line for a constraint
+ </summary>
+ <param name="constraint">The constraint for which the actual value is to be written</param>
+ </member>
+ <member name="M:NUnit.Framework.TextMessageWriter.WriteActualLine(System.Object)">
+ <summary>
+ Write the generic 'Actual' line for a given value
+ </summary>
+ <param name="actual">The actual value causing a failure</param>
+ </member>
+ <member name="P:NUnit.Framework.TextMessageWriter.MaxLineLength">
+ <summary>
+ Gets or sets the maximum line length for this writer
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.StringAssert">
+ <summary>
+ Basic Asserts on strings.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.Equals(System.Object,System.Object)">
+ <summary>
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.ReferenceEquals(System.Object,System.Object)">
+ <summary>
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.Contains(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that a string is found within another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.Contains(System.String,System.String,System.String)">
+ <summary>
+ Asserts that a string is found within another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.Contains(System.String,System.String)">
+ <summary>
+ Asserts that a string is found within another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotContain(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that a string is not found within another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotContain(System.String,System.String,System.String)">
+ <summary>
+ Asserts that a string is found within another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotContain(System.String,System.String)">
+ <summary>
+ Asserts that a string is found within another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.StartsWith(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that a string starts with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.StartsWith(System.String,System.String,System.String)">
+ <summary>
+ Asserts that a string starts with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.StartsWith(System.String,System.String)">
+ <summary>
+ Asserts that a string starts with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotStartWith(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that a string does not start with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotStartWith(System.String,System.String,System.String)">
+ <summary>
+ Asserts that a string does not start with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotStartWith(System.String,System.String)">
+ <summary>
+ Asserts that a string does not start with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.EndsWith(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that a string ends with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.EndsWith(System.String,System.String,System.String)">
+ <summary>
+ Asserts that a string ends with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.EndsWith(System.String,System.String)">
+ <summary>
+ Asserts that a string ends with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotEndWith(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that a string does not end with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotEndWith(System.String,System.String,System.String)">
+ <summary>
+ Asserts that a string does not end with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotEndWith(System.String,System.String)">
+ <summary>
+ Asserts that a string does not end with another string.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The string to be examined</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.AreEqualIgnoringCase(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that two strings are equal, without regard to case.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The actual string</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.AreEqualIgnoringCase(System.String,System.String,System.String)">
+ <summary>
+ Asserts that two strings are equal, without regard to case.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The actual string</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.AreEqualIgnoringCase(System.String,System.String)">
+ <summary>
+ Asserts that two strings are equal, without regard to case.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The actual string</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.AreNotEqualIgnoringCase(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that two strings are not equal, without regard to case.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The actual string</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.AreNotEqualIgnoringCase(System.String,System.String,System.String)">
+ <summary>
+ Asserts that two strings are Notequal, without regard to case.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The actual string</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.AreNotEqualIgnoringCase(System.String,System.String)">
+ <summary>
+ Asserts that two strings are not equal, without regard to case.
+ </summary>
+ <param name="expected">The expected string</param>
+ <param name="actual">The actual string</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.IsMatch(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that a string matches an expected regular expression pattern.
+ </summary>
+ <param name="pattern">The regex pattern to be matched</param>
+ <param name="actual">The actual string</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.IsMatch(System.String,System.String,System.String)">
+ <summary>
+ Asserts that a string matches an expected regular expression pattern.
+ </summary>
+ <param name="pattern">The regex pattern to be matched</param>
+ <param name="actual">The actual string</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.IsMatch(System.String,System.String)">
+ <summary>
+ Asserts that a string matches an expected regular expression pattern.
+ </summary>
+ <param name="pattern">The regex pattern to be matched</param>
+ <param name="actual">The actual string</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotMatch(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that a string does not match an expected regular expression pattern.
+ </summary>
+ <param name="pattern">The regex pattern to be used</param>
+ <param name="actual">The actual string</param>
+ <param name="message">The message to display in case of failure</param>
+ <param name="args">Arguments used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotMatch(System.String,System.String,System.String)">
+ <summary>
+ Asserts that a string does not match an expected regular expression pattern.
+ </summary>
+ <param name="pattern">The regex pattern to be used</param>
+ <param name="actual">The actual string</param>
+ <param name="message">The message to display in case of failure</param>
+ </member>
+ <member name="M:NUnit.Framework.StringAssert.DoesNotMatch(System.String,System.String)">
+ <summary>
+ Asserts that a string does not match an expected regular expression pattern.
+ </summary>
+ <param name="pattern">The regex pattern to be used</param>
+ <param name="actual">The actual string</param>
+ </member>
+ <member name="T:NUnit.Framework.SetUpAttribute">
+ <summary>
+ Attribute used to mark a class that contains one-time SetUp
+ and/or TearDown methods that apply to all the tests in a
+ namespace or an assembly.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.SetUpFixtureAttribute">
+ <summary>
+ SetUpFixtureAttribute is used to identify a SetUpFixture
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.RepeatAttribute">
+ <summary>
+ RepeatAttribute may be applied to test case in order
+ to run it multiple times.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.RepeatAttribute.#ctor(System.Int32)">
+ <summary>
+ Construct a RepeatAttribute
+ </summary>
+ <param name="count">The number of times to run the test</param>
+ </member>
+ <member name="T:NUnit.Framework.SuiteAttribute">
+ <summary>
+ Attribute used to mark a static (shared in VB) property
+ that returns a list of tests.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TearDownAttribute">
+ <summary>
+ Attribute used to identify a method that is called
+ immediately after each test is run. The method is
+ guaranteed to be called, even if an exception is thrown.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Iz">
+ <summary>
+ The Iz class is a synonym for Is intended for use in VB,
+ which regards Is as a keyword.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Throws">
+ <summary>
+ Helper class with properties and methods that supply
+ constraints that operate on exceptions.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Throws.TypeOf(System.Type)">
+ <summary>
+ Creates a constraint specifying the exact type of exception expected
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Throws.TypeOf``1">
+ <summary>
+ Creates a constraint specifying the exact type of exception expected
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Throws.InstanceOf(System.Type)">
+ <summary>
+ Creates a constraint specifying the type of exception expected
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Throws.InstanceOf``1">
+ <summary>
+ Creates a constraint specifying the type of exception expected
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Throws.Exception">
+ <summary>
+ Creates a constraint specifying an expected exception
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Throws.InnerException">
+ <summary>
+ Creates a constraint specifying an exception with a given InnerException
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Throws.TargetInvocationException">
+ <summary>
+ Creates a constraint specifying an expected TargetInvocationException
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Throws.ArgumentException">
+ <summary>
+ Creates a constraint specifying an expected TargetInvocationException
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Throws.InvalidOperationException">
+ <summary>
+ Creates a constraint specifying an expected TargetInvocationException
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Throws.Nothing">
+ <summary>
+ Creates a constraint specifying that no exception is thrown
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.ListMapper">
+ <summary>
+ ListMapper is used to transform a collection used as an actual argument
+ producing another collection to be used in the assertion.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.ListMapper.#ctor(System.Collections.ICollection)">
+ <summary>
+ Construct a ListMapper based on a collection
+ </summary>
+ <param name="original">The collection to be transformed</param>
+ </member>
+ <member name="M:NUnit.Framework.ListMapper.Property(System.String)">
+ <summary>
+ Produces a collection containing all the values of a property
+ </summary>
+ <param name="name">The collection of property values</param>
+ <returns></returns>
+ </member>
+ <member name="T:NUnit.Framework.TestFixtureSetUpAttribute">
+ <summary>
+ Attribute used to identify a method that is
+ called before any tests in a fixture are run.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.TestFixtureTearDownAttribute">
+ <summary>
+ Attribute used to identify a method that is called after
+ all the tests in a fixture have run. The method is
+ guaranteed to be called, even if an exception is thrown.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.Text">
+ <summary>
+ Helper class with static methods used to supply constraints
+ that operate on strings.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Text.Contains(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Text.DoesNotContain(System.String)">
+ <summary>
+ Returns a constraint that fails if the actual
+ value contains the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Text.StartsWith(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Text.DoesNotStartWith(System.String)">
+ <summary>
+ Returns a constraint that fails if the actual
+ value starts with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Text.EndsWith(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Text.DoesNotEndWith(System.String)">
+ <summary>
+ Returns a constraint that fails if the actual
+ value ends with the substring supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Text.Matches(System.String)">
+ <summary>
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Text.DoesNotMatch(System.String)">
+ <summary>
+ Returns a constraint that fails if the actual
+ value matches the pattern supplied as an argument.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Text.All">
+ <summary>
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.MaxTimeAttribute">
+ <summary>
+ Summary description for MaxTimeAttribute.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.MaxTimeAttribute.#ctor(System.Int32)">
+ <summary>
+ Construct a MaxTimeAttribute, given a time in milliseconds.
+ </summary>
+ <param name="milliseconds">The maximum elapsed time in milliseconds</param>
+ </member>
+ <member name="T:NUnit.Framework.SetUICultureAttribute">
+ <summary>
+ Summary description for SetUICultureAttribute.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.SetUICultureAttribute.#ctor(System.String)">
+ <summary>
+ Construct given the name of a culture
+ </summary>
+ <param name="culture"></param>
+ </member>
+ <member name="T:NUnit.Framework.DirectoryAssert">
+ <summary>
+ Summary description for DirectoryAssert
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.Equals(System.Object,System.Object)">
+ <summary>
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.ReferenceEquals(System.Object,System.Object)">
+ <summary>
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.#ctor">
+ <summary>
+ We don't actually want any instances of this object, but some people
+ like to inherit from it to add other static methods. Hence, the
+ protected constructor disallows any instances of this object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String,System.Object[])">
+ <summary>
+ Verifies that two directories are equal. Two directories are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory containing the value that is expected</param>
+ <param name="actual">A directory containing the actual value</param>
+ <param name="message">The message to display if directories are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String)">
+ <summary>
+ Verifies that two directories are equal. Two directories are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory containing the value that is expected</param>
+ <param name="actual">A directory containing the actual value</param>
+ <param name="message">The message to display if directories are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
+ <summary>
+ Verifies that two directories are equal. Two directories are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory containing the value that is expected</param>
+ <param name="actual">A directory containing the actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Verifies that two directories are equal. Two directories are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory path string containing the value that is expected</param>
+ <param name="actual">A directory path string containing the actual value</param>
+ <param name="message">The message to display if directories are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.String,System.String,System.String)">
+ <summary>
+ Verifies that two directories are equal. Two directories are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory path string containing the value that is expected</param>
+ <param name="actual">A directory path string containing the actual value</param>
+ <param name="message">The message to display if directories are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreEqual(System.String,System.String)">
+ <summary>
+ Verifies that two directories are equal. Two directories are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory path string containing the value that is expected</param>
+ <param name="actual">A directory path string containing the actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String,System.Object[])">
+ <summary>
+ Asserts that two directories are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory containing the value that is expected</param>
+ <param name="actual">A directory containing the actual value</param>
+ <param name="message">The message to display if directories are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String)">
+ <summary>
+ Asserts that two directories are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory containing the value that is expected</param>
+ <param name="actual">A directory containing the actual value</param>
+ <param name="message">The message to display if directories are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
+ <summary>
+ Asserts that two directories are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory containing the value that is expected</param>
+ <param name="actual">A directory containing the actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that two directories are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory path string containing the value that is expected</param>
+ <param name="actual">A directory path string containing the actual value</param>
+ <param name="message">The message to display if directories are equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.String,System.String,System.String)">
+ <summary>
+ Asserts that two directories are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory path string containing the value that is expected</param>
+ <param name="actual">A directory path string containing the actual value</param>
+ <param name="message">The message to display if directories are equal</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.AreNotEqual(System.String,System.String)">
+ <summary>
+ Asserts that two directories are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A directory path string containing the value that is expected</param>
+ <param name="actual">A directory path string containing the actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.IO.DirectoryInfo,System.String,System.Object[])">
+ <summary>
+ Asserts that the directory is empty. If it is not empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="message">The message to display if directories are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.IO.DirectoryInfo,System.String)">
+ <summary>
+ Asserts that the directory is empty. If it is not empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="message">The message to display if directories are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.IO.DirectoryInfo)">
+ <summary>
+ Asserts that the directory is empty. If it is not empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that the directory is empty. If it is not empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="message">The message to display if directories are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.String,System.String)">
+ <summary>
+ Asserts that the directory is empty. If it is not empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="message">The message to display if directories are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsEmpty(System.String)">
+ <summary>
+ Asserts that the directory is empty. If it is not empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.IO.DirectoryInfo,System.String,System.Object[])">
+ <summary>
+ Asserts that the directory is not empty. If it is empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="message">The message to display if directories are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.IO.DirectoryInfo,System.String)">
+ <summary>
+ Asserts that the directory is not empty. If it is empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="message">The message to display if directories are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.IO.DirectoryInfo)">
+ <summary>
+ Asserts that the directory is not empty. If it is empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that the directory is not empty. If it is empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="message">The message to display if directories are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.String,System.String)">
+ <summary>
+ Asserts that the directory is not empty. If it is empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="message">The message to display if directories are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotEmpty(System.String)">
+ <summary>
+ Asserts that the directory is not empty. If it is empty
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String,System.Object[])">
+ <summary>
+ Asserts that path contains actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ <param name="message">The message to display if directory is not within the path</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String)">
+ <summary>
+ Asserts that path contains actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ <param name="message">The message to display if directory is not within the path</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
+ <summary>
+ Asserts that path contains actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that path contains actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ <param name="message">The message to display if directory is not within the path</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.String,System.String,System.String)">
+ <summary>
+ Asserts that path contains actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ <param name="message">The message to display if directory is not within the path</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsWithin(System.String,System.String)">
+ <summary>
+ Asserts that path contains actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String,System.Object[])">
+ <summary>
+ Asserts that path does not contain actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ <param name="message">The message to display if directory is not within the path</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo,System.String)">
+ <summary>
+ Asserts that path does not contain actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ <param name="message">The message to display if directory is not within the path</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
+ <summary>
+ Asserts that path does not contain actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that path does not contain actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ <param name="message">The message to display if directory is not within the path</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.String,System.String,System.String)">
+ <summary>
+ Asserts that path does not contain actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ <param name="message">The message to display if directory is not within the path</param>
+ </member>
+ <member name="M:NUnit.Framework.DirectoryAssert.IsNotWithin(System.String,System.String)">
+ <summary>
+ Asserts that path does not contain actual as a subdirectory or
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="directory">A directory to search</param>
+ <param name="actual">sub-directory asserted to exist under directory</param>
+ </member>
+ <member name="T:NUnit.Framework.SpecialValue">
+ <summary>
+ The SpecialValue enum is used to represent TestCase arguments
+ that cannot be used as arguments to an Attribute.
+ </summary>
+ </member>
+ <member name="F:NUnit.Framework.SpecialValue.Null">
+ <summary>
+ Null represents a null value, which cannot be used as an
+ argument to an attriute under .NET 1.x
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.FileAssert">
+ <summary>
+ Summary description for FileAssert.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.Equals(System.Object,System.Object)">
+ <summary>
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.ReferenceEquals(System.Object,System.Object)">
+ <summary>
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+ </summary>
+ <param name="a"></param>
+ <param name="b"></param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.#ctor">
+ <summary>
+ We don't actually want any instances of this object, but some people
+ like to inherit from it to add other static methods. Hence, the
+ protected constructor disallows any instances of this object.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.Stream,System.IO.Stream,System.String,System.Object[])">
+ <summary>
+ Verifies that two Streams are equal. Two Streams are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected Stream</param>
+ <param name="actual">The actual Stream</param>
+ <param name="message">The message to display if Streams are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.Stream,System.IO.Stream,System.String)">
+ <summary>
+ Verifies that two Streams are equal. Two Streams are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected Stream</param>
+ <param name="actual">The actual Stream</param>
+ <param name="message">The message to display if objects are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.Stream,System.IO.Stream)">
+ <summary>
+ Verifies that two Streams are equal. Two Streams are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected Stream</param>
+ <param name="actual">The actual Stream</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.FileInfo,System.IO.FileInfo,System.String,System.Object[])">
+ <summary>
+ Verifies that two files are equal. Two files are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A file containing the value that is expected</param>
+ <param name="actual">A file containing the actual value</param>
+ <param name="message">The message to display if Streams are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.FileInfo,System.IO.FileInfo,System.String)">
+ <summary>
+ Verifies that two files are equal. Two files are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A file containing the value that is expected</param>
+ <param name="actual">A file containing the actual value</param>
+ <param name="message">The message to display if objects are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreEqual(System.IO.FileInfo,System.IO.FileInfo)">
+ <summary>
+ Verifies that two files are equal. Two files are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A file containing the value that is expected</param>
+ <param name="actual">A file containing the actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreEqual(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Verifies that two files are equal. Two files are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The path to a file containing the value that is expected</param>
+ <param name="actual">The path to a file containing the actual value</param>
+ <param name="message">The message to display if Streams are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreEqual(System.String,System.String,System.String)">
+ <summary>
+ Verifies that two files are equal. Two files are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The path to a file containing the value that is expected</param>
+ <param name="actual">The path to a file containing the actual value</param>
+ <param name="message">The message to display if objects are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreEqual(System.String,System.String)">
+ <summary>
+ Verifies that two files are equal. Two files are considered
+ equal if both are null, or if both have the same value byte for byte.
+ If they are not equal an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The path to a file containing the value that is expected</param>
+ <param name="actual">The path to a file containing the actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.Stream,System.IO.Stream,System.String,System.Object[])">
+ <summary>
+ Asserts that two Streams are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected Stream</param>
+ <param name="actual">The actual Stream</param>
+ <param name="message">The message to be displayed when the two Stream are the same.</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.Stream,System.IO.Stream,System.String)">
+ <summary>
+ Asserts that two Streams are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected Stream</param>
+ <param name="actual">The actual Stream</param>
+ <param name="message">The message to be displayed when the Streams are the same.</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.Stream,System.IO.Stream)">
+ <summary>
+ Asserts that two Streams are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The expected Stream</param>
+ <param name="actual">The actual Stream</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.FileInfo,System.IO.FileInfo,System.String,System.Object[])">
+ <summary>
+ Asserts that two files are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A file containing the value that is expected</param>
+ <param name="actual">A file containing the actual value</param>
+ <param name="message">The message to display if Streams are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.FileInfo,System.IO.FileInfo,System.String)">
+ <summary>
+ Asserts that two files are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A file containing the value that is expected</param>
+ <param name="actual">A file containing the actual value</param>
+ <param name="message">The message to display if objects are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.IO.FileInfo,System.IO.FileInfo)">
+ <summary>
+ Asserts that two files are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">A file containing the value that is expected</param>
+ <param name="actual">A file containing the actual value</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.String,System.String,System.String,System.Object[])">
+ <summary>
+ Asserts that two files are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The path to a file containing the value that is expected</param>
+ <param name="actual">The path to a file containing the actual value</param>
+ <param name="message">The message to display if Streams are not equal</param>
+ <param name="args">Arguments to be used in formatting the message</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.String,System.String,System.String)">
+ <summary>
+ Asserts that two files are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The path to a file containing the value that is expected</param>
+ <param name="actual">The path to a file containing the actual value</param>
+ <param name="message">The message to display if objects are not equal</param>
+ </member>
+ <member name="M:NUnit.Framework.FileAssert.AreNotEqual(System.String,System.String)">
+ <summary>
+ Asserts that two files are not equal. If they are equal
+ an <see cref="T:NUnit.Framework.AssertionException"/> is thrown.
+ </summary>
+ <param name="expected">The path to a file containing the value that is expected</param>
+ <param name="actual">The path to a file containing the actual value</param>
+ </member>
+ <member name="T:NUnit.Framework.TheoryAttribute">
+ <summary>
+ Adding this attribute to a method within a <seealso cref="T:NUnit.Framework.TestFixtureAttribute"/>
+ class makes the method callable from the NUnit test runner. There is a property
+ called Description which is optional which you can provide a more detailed test
+ description. This class cannot be inherited.
+ </summary>
+
+ <example>
+ [TestFixture]
+ public class Fixture
+ {
+ [Test]
+ public void MethodToTest()
+ {}
+
+ [Test(Description = "more detailed description")]
+ publc void TestDescriptionMethod()
+ {}
+ }
+ </example>
+
+ </member>
+ <member name="T:NUnit.Framework.Randomizer">
+ <summary>
+ Randomizer returns a set of random values in a repeatable
+ way, to allow re-running of tests if necessary.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Randomizer.GetRandomizer(System.Reflection.MemberInfo)">
+ <summary>
+ Get a randomizer for a particular member, returning
+ one that has already been created if it exists.
+ This ensures that the same values are generated
+ each time the tests are reloaded.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Randomizer.GetRandomizer(System.Reflection.ParameterInfo)">
+ <summary>
+ Get a randomizer for a particular parameter, returning
+ one that has already been created if it exists.
+ This ensures that the same values are generated
+ each time the tests are reloaded.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Randomizer.#ctor">
+ <summary>
+ Construct a randomizer using a random seed
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Randomizer.#ctor(System.Int32)">
+ <summary>
+ Construct a randomizer using a specified seed
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Randomizer.GetDoubles(System.Int32)">
+ <summary>
+ Return an array of random doubles between 0.0 and 1.0.
+ </summary>
+ <param name="count"></param>
+ <returns></returns>
+ </member>
+ <member name="M:NUnit.Framework.Randomizer.GetDoubles(System.Double,System.Double,System.Int32)">
+ <summary>
+ Return an array of random doubles with values in a specified range.
+ </summary>
+ </member>
+ <member name="M:NUnit.Framework.Randomizer.GetInts(System.Int32,System.Int32,System.Int32)">
+ <summary>
+ Return an array of random ints with values in a specified range.
+ </summary>
+ </member>
+ <member name="P:NUnit.Framework.Randomizer.RandomSeed">
+ <summary>
+ Get a random seed for use in creating a randomizer.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.DatapointAttribute">
+ <summary>
+ Used to mark a field for use as a datapoint when executing a theory
+ within the same fixture that requires an argument of the field's Type.
+ </summary>
+ </member>
+ <member name="T:NUnit.Framework.DatapointsAttribute">
+ <summary>
+ Used to mark an array as containing a set of datapoints to be used
+ executing a theory within the same fixture that requires an argument
+ of the Type of the array elements.
+ </summary>
+ </member>
+ </members>
+</doc>
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/obj/Debug/CSCC44.tmp
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/obj/Debug/FreeSWITCH.Managed.Tests.csproj.FileListAbsolute.txt (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/obj/Debug/FreeSWITCH.Managed.Tests.csproj.FileListAbsolute.txt (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/obj/Debug/FreeSWITCH.Managed.Tests.csproj.FileListAbsolute.txt 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,12 @@
+C:\RTI Development\FreeSWITCH.Managed\UnitTests\bin\Debug\FreeSWITCH.Managed.Tests.dll
+C:\RTI Development\FreeSWITCH.Managed\UnitTests\bin\Debug\FreeSWITCH.Managed.Tests.pdb
+C:\RTI Development\FreeSWITCH.Managed\UnitTests\bin\Debug\FreeSWITCH.Managed.dll
+C:\RTI Development\FreeSWITCH.Managed\UnitTests\bin\Debug\Moq.dll
+C:\RTI Development\FreeSWITCH.Managed\UnitTests\bin\Debug\nunit.framework.dll
+C:\RTI Development\FreeSWITCH.Managed\UnitTests\bin\Debug\nunit.framework.xml
+C:\RTI Development\FreeSWITCH.Managed\UnitTests\bin\Debug\FreeSWITCH.Managed.pdb
+C:\RTI Development\FreeSWITCH.Managed\UnitTests\bin\Debug\Moq.pdb
+C:\RTI Development\FreeSWITCH.Managed\UnitTests\bin\Debug\Moq.xml
+C:\RTI Development\FreeSWITCH.Managed\UnitTests\obj\Debug\ResolveAssemblyReference.cache
+C:\RTI Development\FreeSWITCH.Managed\UnitTests\obj\Debug\FreeSWITCH.Managed.Tests.dll
+C:\RTI Development\FreeSWITCH.Managed\UnitTests\obj\Debug\FreeSWITCH.Managed.Tests.pdb
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/obj/Debug/FreeSWITCH.Managed.Tests.dll
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/obj/Debug/FreeSWITCH.Managed.Tests.pdb
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/UnitTests/obj/Debug/ResolveAssemblyReference.cache
(Binary files differ)
Deleted: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/Util.cs
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/Demo.csx (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/Demo.csx (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/Demo.csx 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,110 @@
+/*
+ * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_managed
+ * Copyright (C) 2008, Michael Giagnocavo <mgg@giagnocavo.net>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application - mod_managed
+ *
+ * The Initial Developer of the Original Code is
+ * Michael Giagnocavo <mgg@giagnocavo.net>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Michael Giagnocavo <mgg@giagnocavo.net>
+ *
+ * Demo.cs -- mod_mono demo classes
+ *
+ */
+
+// How to test the demo (in the mod/managed directory):
+// -- Compile to dll for "normal" loading
+// -- Compile to exe for script EXE loading
+// -- Copy to managed directory for dynamic compilation
+
+using System;
+using FreeSWITCH;
+using FreeSWITCH.Native;
+
+public class AppDemo : IAppPlugin {
+
+ ManagedSession Session;
+ public void Run(AppContext context) {
+ Session = context.Session;
+ Session.HangupFunction = hangupHook;
+ Session.Answer();
+ Session.DtmfReceivedFunction = (d, t) => {
+ Log.WriteLine(LogLevel.Notice, "Received {0} for {1}.", d, t);
+ return "";
+ };
+ Log.WriteLine(LogLevel.Notice, "Inside AppDemo.Run (args '{0}'); HookState is {1}. Now will collect digits.", context.Arguments, Session.HookState);
+ Session.CollectDigits(5000); // Hanging up here will cause an abort and the next line won't be written
+ Log.WriteLine(LogLevel.Notice, "AppDemo is finishing its run and will now hang up.");
+ Session.Hangup("USER_BUSY");
+ }
+
+ void hangupHook() {
+ Log.WriteLine(LogLevel.Notice, "AppDemo hanging up, UUID: {0}.", this.Session.Uuid);
+ }
+
+}
+
+public class ApiDemo : IApiPlugin {
+
+ public void Execute(ApiContext context) {
+ context.Stream.Write(string.Format("ApiDemo executed with args '{0}' and event type {1}.",
+ context.Arguments, context.Event == null ? "<none>" : context.Event.GetEventType()));
+ }
+
+ public void ExecuteBackground(ApiBackgroundContext context) {
+ Log.WriteLine(LogLevel.Notice, "ApiDemo on a background thread #({0}), with args '{1}'.",
+ System.Threading.Thread.CurrentThread.ManagedThreadId,
+ context.Arguments);
+ }
+
+}
+
+public class LoadDemo : ILoadNotificationPlugin {
+ public bool Load() {
+ Log.WriteLine(LogLevel.Notice, "LoadDemo running.");
+ return true;
+ }
+}
+
+public class ScriptDemo {
+
+ public static void Main() {
+ switch (FreeSWITCH.Script.ContextType) {
+ case ScriptContextType.Api: {
+ var ctx = FreeSWITCH.Script.GetApiContext();
+ ctx.Stream.Write("Script executing as API with args: " + ctx.Arguments);
+ break;
+ }
+ case ScriptContextType.ApiBackground: {
+ var ctx = FreeSWITCH.Script.GetApiBackgroundContext();
+ Log.WriteLine(LogLevel.Notice, "Executing as APIBackground with args: " + ctx.Arguments);
+ break;
+ }
+ case ScriptContextType.App: {
+ var ctx = FreeSWITCH.Script.GetAppContext();
+ Log.WriteLine(LogLevel.Notice, "Executing as App with args: " + ctx.Arguments);
+ break;
+ }
+ }
+
+ }
+
+}
+
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/FormLoader.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/FormLoader.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/FormLoader.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using FreeSWITCH.Managed;
+using System.Windows.Forms;
+
+namespace WinFormLogger
+{
+ public class FormLoader : IPrimaryAppdomainExtension
+ {
+ public void Load()
+ {
+ Application.EnableVisualStyles();
+ Application.SetCompatibleTextRenderingDefault(false);
+ var container = DefaultServiceLocator.Container.Create<LoggerContainer>();
+ var form = new LogForm();
+ container.Add(new FormLogger(form));
+ Application.Run(form);
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/FormLogger.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/FormLogger.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/FormLogger.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using FreeSWITCH.Managed;
+using System.Windows.Forms;
+
+namespace WinFormLogger
+{
+ public class FormLogger : ILogger
+ {
+ private LogForm form;
+ public FormLogger(LogForm form)
+ {
+ this.form = form;
+
+ }
+ public void Debug(string message)
+ {
+ this.form.AddMessage(message);
+ }
+
+ public void Info(string message)
+ {
+ this.form.AddMessage(message);
+ }
+
+ public void Error(string message)
+ {
+ this.form.AddMessage(message);
+ }
+
+ public void Critical(string message)
+ {
+ this.form.AddMessage(message);
+ }
+
+ public void Alert(string message)
+ {
+ this.form.AddMessage(message);
+ }
+
+ public void Warning(string message)
+ {
+ this.form.AddMessage(message);
+ }
+
+ public void Notice(string message)
+ {
+ this.form.AddMessage(message);
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/LogForm.Designer.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/LogForm.Designer.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/LogForm.Designer.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,60 @@
+namespace WinFormLogger
+{
+ partial class LogForm
+ {
+ /// <summary>
+ /// Required designer variable.
+ /// </summary>
+ private System.ComponentModel.IContainer components = null;
+
+ /// <summary>
+ /// Clean up any resources being used.
+ /// </summary>
+ /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+ protected override void Dispose(bool disposing)
+ {
+ if (disposing && (components != null))
+ {
+ components.Dispose();
+ }
+ base.Dispose(disposing);
+ }
+
+ #region Windows Form Designer generated code
+
+ /// <summary>
+ /// Required method for Designer support - do not modify
+ /// the contents of this method with the code editor.
+ /// </summary>
+ private void InitializeComponent()
+ {
+ this.Messages = new System.Windows.Forms.TextBox();
+ this.SuspendLayout();
+ //
+ // Messages
+ //
+ this.Messages.Dock = System.Windows.Forms.DockStyle.Fill;
+ this.Messages.Location = new System.Drawing.Point(0, 0);
+ this.Messages.Multiline = true;
+ this.Messages.Name = "Messages";
+ this.Messages.Size = new System.Drawing.Size(292, 273);
+ this.Messages.TabIndex = 0;
+ //
+ // LogForm
+ //
+ this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+ this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+ this.ClientSize = new System.Drawing.Size(292, 273);
+ this.Controls.Add(this.Messages);
+ this.Name = "LogForm";
+ this.Text = "LogForm";
+ this.ResumeLayout(false);
+ this.PerformLayout();
+
+ }
+
+ #endregion
+
+ private System.Windows.Forms.TextBox Messages;
+ }
+}
\ No newline at end of file
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/LogForm.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/LogForm.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/LogForm.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Data;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using System.Windows.Forms;
+
+namespace WinFormLogger
+{
+ public partial class LogForm : Form
+ {
+ public LogForm()
+ {
+ InitializeComponent();
+ }
+
+ public void AddMessage(string message)
+ {
+ this.Messages.Text += message;
+ this.Messages.Text += Environment.NewLine;
+ }
+ }
+}
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/LogForm.resx (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/LogForm.resx (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/LogForm.resx 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+ <!--
+ Microsoft ResX Schema
+
+ Version 2.0
+
+ The primary goals of this format is to allow a simple XML format
+ that is mostly human readable. The generation and parsing of the
+ various data types are done through the TypeConverter classes
+ associated with the data types.
+
+ Example:
+
+ ... ado.net/XML headers & schema ...
+ <resheader name="resmimetype">text/microsoft-resx</resheader>
+ <resheader name="version">2.0</resheader>
+ <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+ <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+ <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+ <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+ <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+ <value>[base64 mime encoded serialized .NET Framework object]</value>
+ </data>
+ <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+ <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+ <comment>This is a comment</comment>
+ </data>
+
+ There are any number of "resheader" rows that contain simple
+ name/value pairs.
+
+ Each data row contains a name, and value. The row also contains a
+ type or mimetype. Type corresponds to a .NET class that support
+ text/value conversion through the TypeConverter architecture.
+ Classes that don't support this are serialized and stored with the
+ mimetype set.
+
+ The mimetype is used for serialized objects, and tells the
+ ResXResourceReader how to depersist the object. This is currently not
+ extensible. For a given mimetype the value must be set accordingly:
+
+ Note - application/x-microsoft.net.object.binary.base64 is the format
+ that the ResXResourceWriter will generate, however the reader can
+ read any of the formats listed below.
+
+ mimetype: application/x-microsoft.net.object.binary.base64
+ value : The object must be serialized with
+ : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+ : and then encoded with base64 encoding.
+
+ mimetype: application/x-microsoft.net.object.soap.base64
+ value : The object must be serialized with
+ : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+ : and then encoded with base64 encoding.
+
+ mimetype: application/x-microsoft.net.object.bytearray.base64
+ value : The object must be serialized into a byte array
+ : using a System.ComponentModel.TypeConverter
+ : and then encoded with base64 encoding.
+ -->
+ <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+ <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+ <xsd:element name="root" msdata:IsDataSet="true">
+ <xsd:complexType>
+ <xsd:choice maxOccurs="unbounded">
+ <xsd:element name="metadata">
+ <xsd:complexType>
+ <xsd:sequence>
+ <xsd:element name="value" type="xsd:string" minOccurs="0" />
+ </xsd:sequence>
+ <xsd:attribute name="name" use="required" type="xsd:string" />
+ <xsd:attribute name="type" type="xsd:string" />
+ <xsd:attribute name="mimetype" type="xsd:string" />
+ <xsd:attribute ref="xml:space" />
+ </xsd:complexType>
+ </xsd:element>
+ <xsd:element name="assembly">
+ <xsd:complexType>
+ <xsd:attribute name="alias" type="xsd:string" />
+ <xsd:attribute name="name" type="xsd:string" />
+ </xsd:complexType>
+ </xsd:element>
+ <xsd:element name="data">
+ <xsd:complexType>
+ <xsd:sequence>
+ <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+ <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+ </xsd:sequence>
+ <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+ <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+ <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+ <xsd:attribute ref="xml:space" />
+ </xsd:complexType>
+ </xsd:element>
+ <xsd:element name="resheader">
+ <xsd:complexType>
+ <xsd:sequence>
+ <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+ </xsd:sequence>
+ <xsd:attribute name="name" type="xsd:string" use="required" />
+ </xsd:complexType>
+ </xsd:element>
+ </xsd:choice>
+ </xsd:complexType>
+ </xsd:element>
+ </xsd:schema>
+ <resheader name="resmimetype">
+ <value>text/microsoft-resx</value>
+ </resheader>
+ <resheader name="version">
+ <value>2.0</value>
+ </resheader>
+ <resheader name="reader">
+ <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+ </resheader>
+ <resheader name="writer">
+ <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+ </resheader>
+</root>
\ No newline at end of file
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/Properties/AssemblyInfo.cs (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/Properties/AssemblyInfo.cs (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/Properties/AssemblyInfo.cs 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("WinFormLogger")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("WinFormLogger")]
+[assembly: AssemblyCopyright("Copyright © 2009")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components. If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("02f08365-dbe9-48e0-877b-2c71e623319e")]
+
+// Version information for an assembly consists of the following four values:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/WinFormLogger.csproj (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/WinFormLogger.csproj (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/WinFormLogger.csproj 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,79 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="3.5" 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>{F99594FA-9EF1-4D8E-88B2-C15F955A07EF}</ProjectGuid>
+ <OutputType>Library</OutputType>
+ <AppDesignerFolder>Properties</AppDesignerFolder>
+ <RootNamespace>WinFormLogger</RootNamespace>
+ <AssemblyName>WinFormLogger</AssemblyName>
+ <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+ <FileAlignment>512</FileAlignment>
+ </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>
+ </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>
+ </PropertyGroup>
+ <ItemGroup>
+ <Reference Include="System" />
+ <Reference Include="System.Core">
+ <RequiredTargetFramework>3.5</RequiredTargetFramework>
+ </Reference>
+ <Reference Include="System.Drawing" />
+ <Reference Include="System.Windows.Forms" />
+ <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="FormLoader.cs" />
+ <Compile Include="FormLogger.cs" />
+ <Compile Include="LogForm.cs">
+ <SubType>Form</SubType>
+ </Compile>
+ <Compile Include="LogForm.Designer.cs">
+ <DependentUpon>LogForm.cs</DependentUpon>
+ </Compile>
+ <Compile Include="Properties\AssemblyInfo.cs" />
+ </ItemGroup>
+ <ItemGroup>
+ <ProjectReference Include="..\..\..\FreeSWITCH.Managed.csproj">
+ <Project>{834E2B2F-5483-4B80-8FE3-FE48FF76E5C0}</Project>
+ <Name>FreeSWITCH.Managed</Name>
+ </ProjectReference>
+ </ItemGroup>
+ <ItemGroup>
+ <EmbeddedResource Include="LogForm.resx">
+ <DependentUpon>LogForm.cs</DependentUpon>
+ </EmbeddedResource>
+ </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>
\ No newline at end of file
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/bin/Debug/FreeSWITCH.Managed.dll
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/bin/Debug/FreeSWITCH.Managed.pdb
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/bin/Debug/WinFormLogger.dll
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/bin/Debug/WinFormLogger.pdb
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/obj/Debug/WinFormLogger.LogForm.resources
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/obj/Debug/WinFormLogger.csproj.FileListAbsolute.txt (0 => 15281)
--- freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/obj/Debug/WinFormLogger.csproj.FileListAbsolute.txt (rev 0)
+++ freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/obj/Debug/WinFormLogger.csproj.FileListAbsolute.txt 2009-10-30 00:09:12 UTC (rev 15281)
@@ -0,0 +1,9 @@
+C:\RTI Development\FreeSWITCH.Managed\examples\ExtensionSample\WinFormLogger\bin\Debug\WinFormLogger.dll
+C:\RTI Development\FreeSWITCH.Managed\examples\ExtensionSample\WinFormLogger\bin\Debug\WinFormLogger.pdb
+C:\RTI Development\FreeSWITCH.Managed\examples\ExtensionSample\WinFormLogger\bin\Debug\FreeSWITCH.Managed.dll
+C:\RTI Development\FreeSWITCH.Managed\examples\ExtensionSample\WinFormLogger\bin\Debug\FreeSWITCH.Managed.pdb
+C:\RTI Development\FreeSWITCH.Managed\examples\ExtensionSample\WinFormLogger\obj\Debug\ResolveAssemblyReference.cache
+C:\RTI Development\FreeSWITCH.Managed\examples\ExtensionSample\WinFormLogger\obj\Debug\WinFormLogger.LogForm.resources
+C:\RTI Development\FreeSWITCH.Managed\examples\ExtensionSample\WinFormLogger\obj\Debug\WinFormLogger.csproj.GenerateResource.Cache
+C:\RTI Development\FreeSWITCH.Managed\examples\ExtensionSample\WinFormLogger\obj\Debug\WinFormLogger.dll
+C:\RTI Development\FreeSWITCH.Managed\examples\ExtensionSample\WinFormLogger\obj\Debug\WinFormLogger.pdb
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/obj/Debug/WinFormLogger.csproj.GenerateResource.Cache
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/obj/Debug/WinFormLogger.dll
(Binary files differ)
Added: freeswitch/branches/joshrivers/mod_managed_experimental_refactor/src/mod/languages/mod_managed/managed/examples/ExtensionSample/WinFormLogger/obj/Debug/WinFormLogger.pdb
(Binary files differ)