diff --git a/TaxCalculation.Console/App.config b/TaxCalculation.Console/App.config
new file mode 100644
index 0000000..8e15646
--- /dev/null
+++ b/TaxCalculation.Console/App.config
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/TaxCalculation.Console/Program.cs b/TaxCalculation.Console/Program.cs
new file mode 100644
index 0000000..d59c768
--- /dev/null
+++ b/TaxCalculation.Console/Program.cs
@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TaxCalculation.Domain;
+using TaxCalculation.Domain.Enums;
+using TaxCalculation.Domain.Factories;
+using TaxCalculation.Domain.Interfaces;
+using TaxCalculation.Domain.Repositories;
+
+
+namespace TaxCalculation.ConsoleApp
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ IOrdersRepository repository = new OrdersRepository();
+ //
+ var orders = repository.ReadOrders("SalesData.txt");
+
+ foreach (var order in orders)
+ {
+ System.Console.WriteLine(order.OrderNumber);
+ foreach(var lineItem in order.LineItems)
+ {
+ System.Console.WriteLine(lineItem.GetQuantity() + " " + lineItem.Name + " " + decimal.Round(lineItem.GetTotal(),2));
+ }
+ Console.WriteLine("Sales Taxes: " + order.GetOrderLineTax());
+ Console.WriteLine("Total: " + order.GetOrderTotal());
+ Console.WriteLine(Environment.NewLine);
+ }
+ Console.ReadLine();
+ }
+
+
+ }
+}
diff --git a/TaxCalculation.Console/Properties/AssemblyInfo.cs b/TaxCalculation.Console/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..db2ada9
--- /dev/null
+++ b/TaxCalculation.Console/Properties/AssemblyInfo.cs
@@ -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("TaxCalculation.Console")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("TaxCalculation.Console")]
+[assembly: AssemblyCopyright("Copyright © 2013")]
+[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("214b66b9-646e-45fb-913c-c28e725cfca9")]
+
+// 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")]
diff --git a/TaxCalculation.Console/TaxCalculation.ConsoleApp.csproj b/TaxCalculation.Console/TaxCalculation.ConsoleApp.csproj
new file mode 100644
index 0000000..7e22650
--- /dev/null
+++ b/TaxCalculation.Console/TaxCalculation.ConsoleApp.csproj
@@ -0,0 +1,64 @@
+
+
+
+
+ Debug
+ AnyCPU
+ {5D8F40B3-BAF4-4522-8A7D-EA3D8D6E89F5}
+ Exe
+ Properties
+ TaxCalculation.Console
+ TaxCalculation.Console
+ v4.5
+ 512
+
+
+ AnyCPU
+ true
+ full
+ false
+ bin\Debug\
+ DEBUG;TRACE
+ prompt
+ 4
+
+
+ AnyCPU
+ pdbonly
+ true
+ bin\Release\
+ TRACE
+ prompt
+ 4
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {690771c4-1c1d-425c-8ddb-5cfad55c3418}
+ TaxCalculation.Domain
+
+
+
+
+
\ No newline at end of file
diff --git a/TaxCalculation.Console/bin/Debug/SalesData.txt b/TaxCalculation.Console/bin/Debug/SalesData.txt
new file mode 100644
index 0000000..074c14d
--- /dev/null
+++ b/TaxCalculation.Console/bin/Debug/SalesData.txt
@@ -0,0 +1,13 @@
+#Quantity,Product,Price,ItemType
+Order 1
+1,book,12.49,Exempt
+1,music CD,14.99,Basic
+1,chocolate bar,0.85,Exempt
+Order 2
+1,imported box of chocolates,10.00,Import
+1,imported bottle of perfume,47.50,BasicImport
+Order 3
+1,imported bottle of perfume,27.99,BasicImport
+1,bottle of perfume,18.99,Basic
+1,packet of headache pills,9.75,Exempt
+1,imported box of chocolates,11.25,Import
diff --git a/TaxCalculation.Console/bin/Debug/TaxCalculation.Console.exe b/TaxCalculation.Console/bin/Debug/TaxCalculation.Console.exe
new file mode 100644
index 0000000..3e186e1
Binary files /dev/null and b/TaxCalculation.Console/bin/Debug/TaxCalculation.Console.exe differ
diff --git a/TaxCalculation.Console/bin/Debug/TaxCalculation.Console.exe.config b/TaxCalculation.Console/bin/Debug/TaxCalculation.Console.exe.config
new file mode 100644
index 0000000..8e15646
--- /dev/null
+++ b/TaxCalculation.Console/bin/Debug/TaxCalculation.Console.exe.config
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/TaxCalculation.Console/bin/Debug/TaxCalculation.Console.pdb b/TaxCalculation.Console/bin/Debug/TaxCalculation.Console.pdb
new file mode 100644
index 0000000..bdd5df5
Binary files /dev/null and b/TaxCalculation.Console/bin/Debug/TaxCalculation.Console.pdb differ
diff --git a/TaxCalculation.Console/bin/Debug/TaxCalculation.Console.vshost.exe b/TaxCalculation.Console/bin/Debug/TaxCalculation.Console.vshost.exe
new file mode 100644
index 0000000..8c84517
Binary files /dev/null and b/TaxCalculation.Console/bin/Debug/TaxCalculation.Console.vshost.exe differ
diff --git a/TaxCalculation.Console/bin/Debug/TaxCalculation.Domain.dll b/TaxCalculation.Console/bin/Debug/TaxCalculation.Domain.dll
new file mode 100644
index 0000000..09d7e9f
Binary files /dev/null and b/TaxCalculation.Console/bin/Debug/TaxCalculation.Domain.dll differ
diff --git a/TaxCalculation.Console/bin/Debug/TaxCalculation.Domain.pdb b/TaxCalculation.Console/bin/Debug/TaxCalculation.Domain.pdb
new file mode 100644
index 0000000..9a2a7d9
Binary files /dev/null and b/TaxCalculation.Console/bin/Debug/TaxCalculation.Domain.pdb differ
diff --git a/TaxCalculation.Console/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache b/TaxCalculation.Console/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache
new file mode 100644
index 0000000..1c72e4f
Binary files /dev/null and b/TaxCalculation.Console/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache differ
diff --git a/TaxCalculation.Console/obj/Debug/TaxCalculation.Console.csproj.FileListAbsolute.txt b/TaxCalculation.Console/obj/Debug/TaxCalculation.Console.csproj.FileListAbsolute.txt
new file mode 100644
index 0000000..cc600d6
--- /dev/null
+++ b/TaxCalculation.Console/obj/Debug/TaxCalculation.Console.csproj.FileListAbsolute.txt
@@ -0,0 +1,8 @@
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Console\obj\Debug\TaxCalculation.Console.csprojResolveAssemblyReference.cache
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Console\bin\Debug\TaxCalculation.Console.exe.config
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Console\bin\Debug\TaxCalculation.Console.exe
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Console\bin\Debug\TaxCalculation.Console.pdb
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Console\bin\Debug\TaxCalculation.Domain.dll
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Console\bin\Debug\TaxCalculation.Domain.pdb
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Console\obj\Debug\TaxCalculation.Console.exe
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Console\obj\Debug\TaxCalculation.Console.pdb
diff --git a/TaxCalculation.Console/obj/Debug/TaxCalculation.Console.csprojResolveAssemblyReference.cache b/TaxCalculation.Console/obj/Debug/TaxCalculation.Console.csprojResolveAssemblyReference.cache
new file mode 100644
index 0000000..2b4552b
Binary files /dev/null and b/TaxCalculation.Console/obj/Debug/TaxCalculation.Console.csprojResolveAssemblyReference.cache differ
diff --git a/TaxCalculation.Console/obj/Debug/TaxCalculation.Console.exe b/TaxCalculation.Console/obj/Debug/TaxCalculation.Console.exe
new file mode 100644
index 0000000..3e186e1
Binary files /dev/null and b/TaxCalculation.Console/obj/Debug/TaxCalculation.Console.exe differ
diff --git a/TaxCalculation.Console/obj/Debug/TaxCalculation.Console.pdb b/TaxCalculation.Console/obj/Debug/TaxCalculation.Console.pdb
new file mode 100644
index 0000000..bdd5df5
Binary files /dev/null and b/TaxCalculation.Console/obj/Debug/TaxCalculation.Console.pdb differ
diff --git a/TaxCalculation.Console/obj/Debug/TaxCalculation.ConsoleApp.csproj.FileListAbsolute.txt b/TaxCalculation.Console/obj/Debug/TaxCalculation.ConsoleApp.csproj.FileListAbsolute.txt
new file mode 100644
index 0000000..c029a6a
--- /dev/null
+++ b/TaxCalculation.Console/obj/Debug/TaxCalculation.ConsoleApp.csproj.FileListAbsolute.txt
@@ -0,0 +1,8 @@
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Console\bin\Debug\TaxCalculation.Console.exe.config
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Console\bin\Debug\TaxCalculation.Console.exe
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Console\bin\Debug\TaxCalculation.Console.pdb
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Console\bin\Debug\TaxCalculation.Domain.dll
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Console\bin\Debug\TaxCalculation.Domain.pdb
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Console\obj\Debug\TaxCalculation.Console.exe
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Console\obj\Debug\TaxCalculation.Console.pdb
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Console\obj\Debug\TaxCalculation.ConsoleApp.csprojResolveAssemblyReference.cache
diff --git a/TaxCalculation.Console/obj/Debug/TaxCalculation.ConsoleApp.csprojResolveAssemblyReference.cache b/TaxCalculation.Console/obj/Debug/TaxCalculation.ConsoleApp.csprojResolveAssemblyReference.cache
new file mode 100644
index 0000000..ae8897f
Binary files /dev/null and b/TaxCalculation.Console/obj/Debug/TaxCalculation.ConsoleApp.csprojResolveAssemblyReference.cache differ
diff --git a/TaxCalculation.Console/obj/Debug/TemporaryGeneratedFile_036C0B5B-1481-4323-8D20-8F5ADCB23D92.cs b/TaxCalculation.Console/obj/Debug/TemporaryGeneratedFile_036C0B5B-1481-4323-8D20-8F5ADCB23D92.cs
new file mode 100644
index 0000000..e69de29
diff --git a/TaxCalculation.Console/obj/Debug/TemporaryGeneratedFile_5937a670-0e60-4077-877b-f7221da3dda1.cs b/TaxCalculation.Console/obj/Debug/TemporaryGeneratedFile_5937a670-0e60-4077-877b-f7221da3dda1.cs
new file mode 100644
index 0000000..e69de29
diff --git a/TaxCalculation.Console/obj/Debug/TemporaryGeneratedFile_E7A71F73-0F8D-4B9B-B56E-8E70B10BC5D3.cs b/TaxCalculation.Console/obj/Debug/TemporaryGeneratedFile_E7A71F73-0F8D-4B9B-B56E-8E70B10BC5D3.cs
new file mode 100644
index 0000000..e69de29
diff --git a/TaxCalculation.Domain/Enums/ItemType.cs b/TaxCalculation.Domain/Enums/ItemType.cs
new file mode 100644
index 0000000..67eb774
--- /dev/null
+++ b/TaxCalculation.Domain/Enums/ItemType.cs
@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TaxCalculation.Domain.Enums
+{
+ [Flags]
+ public enum ItemType
+ {
+ Exempt = 0,
+ Basic = 1,
+ Import = 2
+ }
+}
diff --git a/TaxCalculation.Domain/Factories/LineItemFactory.cs b/TaxCalculation.Domain/Factories/LineItemFactory.cs
new file mode 100644
index 0000000..45ae3f3
--- /dev/null
+++ b/TaxCalculation.Domain/Factories/LineItemFactory.cs
@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using TaxCalculation.Domain.Enums;
+using TaxCalculation.Domain.Interfaces;
+
+namespace TaxCalculation.Domain.Factories
+{
+ public static class LineItemFactory
+ {
+ private static readonly Rounding ROUNDING = new Rounding(0.05M);
+ private static readonly ITax BASICTAX = new Tax(0.1M, ROUNDING);
+ private static readonly ITax IMPORTTAX = new Tax(0.05M, ROUNDING);
+ private static readonly ITax EXEMPTTAX = new Tax(0.0M, ROUNDING);
+
+ private static readonly Dictionary itemTaxLookup = new Dictionary()
+ {
+ { ItemType.Basic, BASICTAX },
+ { ItemType.Import, IMPORTTAX },
+ { ItemType.Exempt, EXEMPTTAX }
+ };
+
+ public static ILineItem GetLineItem(string name, decimal price, int quantity, ItemType itemType)
+ {
+ ILineItem item = new LineItem(name, price, quantity);
+
+ foreach (int flag in Enum.GetValues(typeof(ItemType)))
+ {
+ if ((flag & (int)itemType) == flag)
+ {
+ item = (ILineItem)Activator.CreateInstance(typeof(LineItemTaxDecorator), new object[] { item, itemTaxLookup[(ItemType)flag] });
+ }
+ }
+
+ return item;
+ }
+
+ public static ILineItem GetLineItem(string name, decimal price, int quantity)
+ {
+ return new LineItem(name, price, quantity);
+ }
+ }
+}
diff --git a/TaxCalculation.Domain/Interfaces/ILineItem.cs b/TaxCalculation.Domain/Interfaces/ILineItem.cs
new file mode 100644
index 0000000..524cbd5
--- /dev/null
+++ b/TaxCalculation.Domain/Interfaces/ILineItem.cs
@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TaxCalculation.Domain.Interfaces
+{
+ public interface ILineItem
+ {
+ string Name { get; }
+ decimal GetPrice();
+ int GetQuantity();
+ decimal GetLineTax();
+ decimal GetTotal();
+ }
+}
diff --git a/TaxCalculation.Domain/Interfaces/IOrdersRepository.cs b/TaxCalculation.Domain/Interfaces/IOrdersRepository.cs
new file mode 100644
index 0000000..7273ed9
--- /dev/null
+++ b/TaxCalculation.Domain/Interfaces/IOrdersRepository.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TaxCalculation.Domain.Interfaces
+{
+ public interface IOrdersRepository
+ {
+ List ReadOrders(string textFilePath);
+ }
+}
diff --git a/TaxCalculation.Domain/Interfaces/IRounding.cs b/TaxCalculation.Domain/Interfaces/IRounding.cs
new file mode 100644
index 0000000..f75f563
--- /dev/null
+++ b/TaxCalculation.Domain/Interfaces/IRounding.cs
@@ -0,0 +1,8 @@
+using System;
+namespace TaxCalculation.Domain.Interfaces
+{
+ public interface IRounding
+ {
+ decimal Round(decimal valToRound);
+ }
+}
diff --git a/TaxCalculation.Domain/Interfaces/ITax.cs b/TaxCalculation.Domain/Interfaces/ITax.cs
new file mode 100644
index 0000000..49e58fe
--- /dev/null
+++ b/TaxCalculation.Domain/Interfaces/ITax.cs
@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TaxCalculation.Domain.Interfaces
+{
+ public interface ITax
+ {
+ IRounding Rounding { get; }
+ decimal Rate { get; }
+ decimal CalculateTax(decimal itemPrice);
+ }
+}
diff --git a/TaxCalculation.Domain/LineItem.cs b/TaxCalculation.Domain/LineItem.cs
new file mode 100644
index 0000000..f5df321
--- /dev/null
+++ b/TaxCalculation.Domain/LineItem.cs
@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using TaxCalculation.Domain.Interfaces;
+
+namespace TaxCalculation.Domain
+{
+ public class LineItem : ILineItem
+ {
+ private string _name;
+ private decimal _price;
+ private int _quantity;
+
+ public LineItem(string name, decimal price, int quantity)
+ {
+ #region Parameter Checking
+ if (string.IsNullOrWhiteSpace(name))
+ throw new ArgumentException("name");
+ if(price < 0)
+ throw new ArgumentException("price");
+ #endregion
+
+ this._name = name;
+ this._price = price;
+ this._quantity = quantity;
+
+ }
+
+ #region ILineItem Members
+
+ public string Name
+ {
+ get { return this._name; }
+ }
+
+ public decimal GetPrice()
+ {
+ return this._price;
+ }
+
+ public int GetQuantity()
+ {
+ return this._quantity;
+ }
+
+ public decimal GetLineTax()
+ {
+ return 0.0M;
+ }
+
+ public decimal GetTotal()
+ {
+ return this.GetPrice() + this.GetLineTax();
+ }
+
+ #endregion
+ }
+}
diff --git a/TaxCalculation.Domain/LineItemTaxDecorator.cs b/TaxCalculation.Domain/LineItemTaxDecorator.cs
new file mode 100644
index 0000000..41a5801
--- /dev/null
+++ b/TaxCalculation.Domain/LineItemTaxDecorator.cs
@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using TaxCalculation.Domain.Interfaces;
+
+namespace TaxCalculation.Domain
+{
+ public class LineItemTaxDecorator: ILineItem
+ {
+ protected ILineItem _decoratedLineItem;
+ protected ITax _lineTax;
+
+ public LineItemTaxDecorator(ILineItem lineItem, ITax lineTax)
+ {
+ this._decoratedLineItem = lineItem;
+ this._lineTax = lineTax;
+ }
+
+ #region ILineItem Members
+
+ public string Name
+ {
+ get { return _decoratedLineItem.Name; }
+ }
+
+ public virtual decimal GetLineTax()
+ {
+ return this._decoratedLineItem.GetLineTax() + _lineTax.CalculateTax(this._decoratedLineItem.GetPrice());
+ }
+
+ public virtual decimal GetPrice()
+ {
+ return this._decoratedLineItem.GetPrice();
+ }
+
+ public virtual decimal GetTotal()
+ {
+ return this.GetPrice() + this.GetLineTax();
+ }
+
+ public int GetQuantity()
+ {
+ return this._decoratedLineItem.GetQuantity();
+ }
+
+ #endregion
+ }
+}
diff --git a/TaxCalculation.Domain/Order.cs b/TaxCalculation.Domain/Order.cs
new file mode 100644
index 0000000..57dcb36
--- /dev/null
+++ b/TaxCalculation.Domain/Order.cs
@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections.ObjectModel;
+using TaxCalculation.Domain.Interfaces;
+
+namespace TaxCalculation.Domain
+{
+ public class Order
+ {
+ private Collection _items = new Collection();
+ public string OrderNumber { get; set; }
+ public List LineItems { get { return _items.ToList(); } }
+ public Order()
+ {
+
+ }
+
+ public void AddItem(ILineItem item)
+ {
+ this._items.Add(item);
+ }
+
+ public decimal GetOrderPrice()
+ {
+ decimal total = 0.0M;
+ foreach (var item in this._items)
+ {
+ total += item.GetPrice();
+ }
+ return total;
+ }
+
+ public decimal GetOrderLineTax()
+ {
+ decimal total = 0.0M;
+ foreach (var item in this._items)
+ {
+ total += item.GetLineTax();
+ }
+ return total;
+ }
+
+ public decimal GetOrderTotal()
+ {
+ return this.GetOrderPrice() + this.GetOrderLineTax();
+ }
+ }
+}
diff --git a/TaxCalculation.Domain/Properties/AssemblyInfo.cs b/TaxCalculation.Domain/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..f6cfe49
--- /dev/null
+++ b/TaxCalculation.Domain/Properties/AssemblyInfo.cs
@@ -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("TaxCalculation.Domain")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("TaxCalculation.Domain")]
+[assembly: AssemblyCopyright("Copyright © 2013")]
+[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("2b867447-6a61-4ee8-ab3b-f4ba6777e453")]
+
+// 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")]
diff --git a/TaxCalculation.Domain/Repositories/OrdersRepository.cs b/TaxCalculation.Domain/Repositories/OrdersRepository.cs
new file mode 100644
index 0000000..2bc234b
--- /dev/null
+++ b/TaxCalculation.Domain/Repositories/OrdersRepository.cs
@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using TaxCalculation.Domain.Enums;
+using TaxCalculation.Domain.Factories;
+using TaxCalculation.Domain.Interfaces;
+
+namespace TaxCalculation.Domain.Repositories
+{
+ public class OrdersRepository : IOrdersRepository
+ {
+ ///
+ /// A repository implementation that fetches a list of Orders by reading from a text file
+ ///
+ /// A path to the text file
+ /// A generic list of Orders
+ public List ReadOrders(string textFilePath)
+ {
+ try
+ {
+ //Validate if the text file path is supplied and it exists
+ if (string.IsNullOrEmpty(textFilePath))
+ throw new ArgumentException("File should not be null or empty.");
+
+ if (!File.Exists(textFilePath))
+ throw new FileNotFoundException(String.Format("File {0} not exists",
+ textFilePath));
+
+ //Declare a generic list of Orders,
+ List orders = new List();
+ //Read the supplied text file using a StreamReader class,
+ using (StreamReader sr = new StreamReader(textFilePath))
+ {
+ Order order = null;
+ while (sr.Peek() >= 0)
+ {
+ string str;
+ string[] strArray;
+ str = sr.ReadLine();
+
+ //If a line starts with character '#' it denotes that it's headings and should be ignored,
+ if (!str.Contains("#"))
+ {
+ strArray = str.Split(',');
+
+ if (str.Contains("Order"))
+ {
+ order = new Order();
+ order.OrderNumber = strArray[0];
+ orders.Add(order);
+ }
+ else
+ {
+ //An item with basic and import tax supply ItemType.Basic | ItemType.Import
+ if (strArray[3].ToString() == "BasicImport")
+ {
+ //Use a lineItemFactory to build a LineItem,
+ order.AddItem(LineItemFactory.GetLineItem(strArray[1],
+ decimal.Parse(strArray[2].ToString()),
+ int.Parse(strArray[0].ToString()),
+ ItemType.Basic | ItemType.Import));
+ }
+ else
+ {
+ order.AddItem(LineItemFactory.GetLineItem(strArray[1],
+ decimal.Parse(strArray[2].ToString()),
+ int.Parse(strArray[0].ToString()),
+ ConvertToItemTypeEnum(strArray[3].ToString())));
+ }
+ }
+ }
+ }
+ }
+ return orders;
+ }
+ catch (Exception ex)
+ {
+ //Catch any file exceptions.
+ if (ex.GetType() == typeof(IndexOutOfRangeException) || ex.GetType() == typeof(ArgumentException) || ex.GetType() == typeof(FormatException))
+ throw new InvalidDataException(String.Format("File {0} has an invalid format, get further details on the inner exception.",
+ textFilePath),ex);
+ }
+ return new List();
+ }
+
+ private ItemType ConvertToItemTypeEnum(string value)
+ {
+ var type = Enum.Parse(typeof(ItemType), value);
+ return (ItemType)type;
+ }
+ }
+}
diff --git a/TaxCalculation.Domain/Rounding.cs b/TaxCalculation.Domain/Rounding.cs
new file mode 100644
index 0000000..5cadd93
--- /dev/null
+++ b/TaxCalculation.Domain/Rounding.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using TaxCalculation.Domain.Interfaces;
+
+namespace TaxCalculation.Domain
+{
+ public class Rounding : IRounding
+ {
+ private decimal _roundTo;
+
+ public Rounding(decimal roundTo)
+ {
+ this._roundTo = roundTo;
+ }
+
+ public decimal Round(decimal valToRound)
+ {
+ decimal remainder = Decimal.Remainder(valToRound, this._roundTo);
+ if (remainder < (this._roundTo / 2))
+ return valToRound - remainder;
+ else
+ return valToRound + (this._roundTo - remainder);
+ }
+
+ }
+}
diff --git a/TaxCalculation.Domain/Tax.cs b/TaxCalculation.Domain/Tax.cs
new file mode 100644
index 0000000..66ff7d1
--- /dev/null
+++ b/TaxCalculation.Domain/Tax.cs
@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using TaxCalculation.Domain.Interfaces;
+
+namespace TaxCalculation.Domain
+{
+ public class Tax : ITax
+ {
+ private decimal _rate;
+ private IRounding _rounding;
+
+ public Tax(decimal rate, IRounding rounding)
+ {
+ this._rate = rate;
+ this._rounding = rounding;
+ }
+
+ #region ILineTax Members
+
+ public decimal Rate
+ {
+ get { return this._rate; }
+ }
+
+ public IRounding Rounding
+ {
+ get { return this._rounding; }
+ }
+
+ public virtual decimal CalculateTax(decimal itemPrice)
+ {
+ decimal tempTax = itemPrice * this.Rate;
+ decimal roundedTax = Rounding.Round(tempTax);
+ return tempTax;
+ }
+
+ #endregion
+ }
+}
diff --git a/TaxCalculation.Domain/TaxCalculation.Domain.csproj b/TaxCalculation.Domain/TaxCalculation.Domain.csproj
new file mode 100644
index 0000000..df0c3b8
--- /dev/null
+++ b/TaxCalculation.Domain/TaxCalculation.Domain.csproj
@@ -0,0 +1,65 @@
+
+
+
+
+ Debug
+ AnyCPU
+ {690771C4-1C1D-425C-8DDB-5CFAD55C3418}
+ Library
+ Properties
+ TaxCalculation.Domain
+ TaxCalculation.Domain
+ v4.5
+ 512
+
+
+ true
+ full
+ false
+ bin\Debug\
+ DEBUG;TRACE
+ prompt
+ 4
+
+
+ pdbonly
+ true
+ bin\Release\
+ TRACE
+ prompt
+ 4
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/TaxCalculation.Domain/bin/Debug/TaxCalculation.Domain.dll b/TaxCalculation.Domain/bin/Debug/TaxCalculation.Domain.dll
new file mode 100644
index 0000000..09d7e9f
Binary files /dev/null and b/TaxCalculation.Domain/bin/Debug/TaxCalculation.Domain.dll differ
diff --git a/TaxCalculation.Domain/bin/Debug/TaxCalculation.Domain.pdb b/TaxCalculation.Domain/bin/Debug/TaxCalculation.Domain.pdb
new file mode 100644
index 0000000..9a2a7d9
Binary files /dev/null and b/TaxCalculation.Domain/bin/Debug/TaxCalculation.Domain.pdb differ
diff --git a/TaxCalculation.Domain/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache b/TaxCalculation.Domain/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache
new file mode 100644
index 0000000..4d40672
Binary files /dev/null and b/TaxCalculation.Domain/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache differ
diff --git a/TaxCalculation.Domain/obj/Debug/TaxCalculation.Domain.csproj.FileListAbsolute.txt b/TaxCalculation.Domain/obj/Debug/TaxCalculation.Domain.csproj.FileListAbsolute.txt
new file mode 100644
index 0000000..fc42050
--- /dev/null
+++ b/TaxCalculation.Domain/obj/Debug/TaxCalculation.Domain.csproj.FileListAbsolute.txt
@@ -0,0 +1,5 @@
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Domain\bin\Debug\TaxCalculation.Domain.dll
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Domain\bin\Debug\TaxCalculation.Domain.pdb
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Domain\obj\Debug\TaxCalculation.Domain.csprojResolveAssemblyReference.cache
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Domain\obj\Debug\TaxCalculation.Domain.dll
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculation.Domain\obj\Debug\TaxCalculation.Domain.pdb
diff --git a/TaxCalculation.Domain/obj/Debug/TaxCalculation.Domain.csprojResolveAssemblyReference.cache b/TaxCalculation.Domain/obj/Debug/TaxCalculation.Domain.csprojResolveAssemblyReference.cache
new file mode 100644
index 0000000..5308b05
Binary files /dev/null and b/TaxCalculation.Domain/obj/Debug/TaxCalculation.Domain.csprojResolveAssemblyReference.cache differ
diff --git a/TaxCalculation.Domain/obj/Debug/TaxCalculation.Domain.dll b/TaxCalculation.Domain/obj/Debug/TaxCalculation.Domain.dll
new file mode 100644
index 0000000..09d7e9f
Binary files /dev/null and b/TaxCalculation.Domain/obj/Debug/TaxCalculation.Domain.dll differ
diff --git a/TaxCalculation.Domain/obj/Debug/TaxCalculation.Domain.pdb b/TaxCalculation.Domain/obj/Debug/TaxCalculation.Domain.pdb
new file mode 100644
index 0000000..9a2a7d9
Binary files /dev/null and b/TaxCalculation.Domain/obj/Debug/TaxCalculation.Domain.pdb differ
diff --git a/TaxCalculation.Domain/obj/Debug/TemporaryGeneratedFile_036C0B5B-1481-4323-8D20-8F5ADCB23D92.cs b/TaxCalculation.Domain/obj/Debug/TemporaryGeneratedFile_036C0B5B-1481-4323-8D20-8F5ADCB23D92.cs
new file mode 100644
index 0000000..e69de29
diff --git a/TaxCalculation.Domain/obj/Debug/TemporaryGeneratedFile_5937a670-0e60-4077-877b-f7221da3dda1.cs b/TaxCalculation.Domain/obj/Debug/TemporaryGeneratedFile_5937a670-0e60-4077-877b-f7221da3dda1.cs
new file mode 100644
index 0000000..e69de29
diff --git a/TaxCalculation.Domain/obj/Debug/TemporaryGeneratedFile_E7A71F73-0F8D-4B9B-B56E-8E70B10BC5D3.cs b/TaxCalculation.Domain/obj/Debug/TemporaryGeneratedFile_E7A71F73-0F8D-4B9B-B56E-8E70B10BC5D3.cs
new file mode 100644
index 0000000..e69de29
diff --git a/TaxCalculationApp.sln b/TaxCalculationApp.sln
new file mode 100644
index 0000000..6c5139e
--- /dev/null
+++ b/TaxCalculationApp.sln
@@ -0,0 +1,32 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2012
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TaxCalculation.Tests", "TaxCalculatorTests\TaxCalculation.Tests.csproj", "{D6FE6A77-FCFA-4C4D-9F74-BE463F85670F}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TaxCalculation.Domain", "TaxCalculation.Domain\TaxCalculation.Domain.csproj", "{690771C4-1C1D-425C-8DDB-5CFAD55C3418}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TaxCalculation.ConsoleApp", "TaxCalculation.Console\TaxCalculation.ConsoleApp.csproj", "{5D8F40B3-BAF4-4522-8A7D-EA3D8D6E89F5}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Any CPU = Debug|Any CPU
+ Release|Any CPU = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {D6FE6A77-FCFA-4C4D-9F74-BE463F85670F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {D6FE6A77-FCFA-4C4D-9F74-BE463F85670F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {D6FE6A77-FCFA-4C4D-9F74-BE463F85670F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {D6FE6A77-FCFA-4C4D-9F74-BE463F85670F}.Release|Any CPU.Build.0 = Release|Any CPU
+ {690771C4-1C1D-425C-8DDB-5CFAD55C3418}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {690771C4-1C1D-425C-8DDB-5CFAD55C3418}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {690771C4-1C1D-425C-8DDB-5CFAD55C3418}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {690771C4-1C1D-425C-8DDB-5CFAD55C3418}.Release|Any CPU.Build.0 = Release|Any CPU
+ {5D8F40B3-BAF4-4522-8A7D-EA3D8D6E89F5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {5D8F40B3-BAF4-4522-8A7D-EA3D8D6E89F5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {5D8F40B3-BAF4-4522-8A7D-EA3D8D6E89F5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {5D8F40B3-BAF4-4522-8A7D-EA3D8D6E89F5}.Release|Any CPU.Build.0 = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
diff --git a/TaxCalculationApp.suo b/TaxCalculationApp.suo
new file mode 100644
index 0000000..6140e40
Binary files /dev/null and b/TaxCalculationApp.suo differ
diff --git a/TaxCalculationApp.v11.suo b/TaxCalculationApp.v11.suo
new file mode 100644
index 0000000..0febbdc
Binary files /dev/null and b/TaxCalculationApp.v11.suo differ
diff --git a/TaxCalculatorTests/OrdersRepositoryTest.cs b/TaxCalculatorTests/OrdersRepositoryTest.cs
new file mode 100644
index 0000000..1b117f8
--- /dev/null
+++ b/TaxCalculatorTests/OrdersRepositoryTest.cs
@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using Rhino.Mocks;
+using TaxCalculation.Domain;
+using TaxCalculation.Domain.Enums;
+using TaxCalculation.Domain.Factories;
+using TaxCalculation.Domain.Interfaces;
+
+namespace TaxCalculatorTests
+{
+ [TestFixture]
+ public class OrdersRepositoryTest
+ {
+ private IOrdersRepository mock;
+ private ITax stub;
+ private OrdersRepositoryTestClass ordersRepositoryTestClass;
+ private List listOrders = null;
+
+ [SetUp]
+ public void Setup()
+ {
+ mock = MockRepository.GenerateMock();
+ stub = MockRepository.GenerateStub();
+ ordersRepositoryTestClass = new OrdersRepositoryTestClass();
+ listOrders = new List();
+
+ Order order = new Order();
+ order.AddItem(LineItemFactory.GetLineItem("book", 12.49M,1,ItemType.Exempt));
+ order.AddItem(LineItemFactory.GetLineItem("CD", 14.99M, 1,ItemType.Basic));
+ order.AddItem(LineItemFactory.GetLineItem("chocolate bar", 0.85M, 1, ItemType.Exempt));
+ listOrders.Add(order);
+
+ order = new Order();
+ order.AddItem(LineItemFactory.GetLineItem("imported chocolates", 10.0M, 1, ItemType.Import));
+ order.AddItem(LineItemFactory.GetLineItem("imported perfume", 47.5M, 1, ItemType.Basic | ItemType.Import));
+ listOrders.Add(order);
+
+ order = new Order();
+ order.AddItem(LineItemFactory.GetLineItem("imported perfume", 27.99M, 1, ItemType.Basic | ItemType.Import));
+ order.AddItem(LineItemFactory.GetLineItem("perfume", 18.99M, 1, ItemType.Basic));
+ order.AddItem(LineItemFactory.GetLineItem("pills", 19.75M, 1, ItemType.Exempt));
+ order.AddItem(LineItemFactory.GetLineItem("imported chocolates", 1.25M,1, ItemType.Import));
+ listOrders.Add(order);
+ }
+
+ //[TestCase("", Description = "Empty File Test",
+ //ExpectedException = typeof(ArgumentException))]
+
+ //[TestCase(null, Description = "Null Test",
+ //ExpectedException = typeof(ArgumentException))]
+
+ //[TestCase("SalesData.txt", Description = "Invalid File Test",
+ //ExpectedException = typeof(FileNotFoundException))]
+
+ [TestCase("SalesData.txt",Description = "Positive Test")]
+ public void GetOrdersFileIsValidTestCases(string filePath)
+ {
+ mock.Expect(s => s.ReadOrders(filePath)).Return(listOrders);
+ ordersRepositoryTestClass.ActOnIOrdersRepository(mock, filePath).ToList();
+ //Verifying that the method (ReadOrders) was was called.
+ mock.VerifyAllExpectations();
+ }
+
+ [TestCase("SalesData.txt", Description = "GetOrdersNotEmpty Test")]
+ public void GetOrdersNotEmptyTestCases(string filePath)
+ {
+ List orders = new List();
+ mock.Expect(s => s.ReadOrders(filePath)).Return(listOrders);
+
+ var actualOrders = ordersRepositoryTestClass.ActOnIOrdersRepository(mock,filePath).ToList();
+
+ CollectionAssert.IsNotEmpty(actualOrders);
+ }
+ }
+
+ public class OrdersRepositoryTestClass
+ {
+ public List ActOnIOrdersRepository(IOrdersRepository ordersRepository, string filePath)
+ {
+ return ordersRepository.ReadOrders(filePath);
+ }
+ }
+
+}
diff --git a/TaxCalculatorTests/Properties/AssemblyInfo.cs b/TaxCalculatorTests/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..c9efce5
--- /dev/null
+++ b/TaxCalculatorTests/Properties/AssemblyInfo.cs
@@ -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("TaxCalculatorTests")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("TaxCalculatorTests")]
+[assembly: AssemblyCopyright("Copyright © 2013")]
+[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("1f36191d-e9e3-4faf-945c-b34d7e28b81a")]
+
+// 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")]
diff --git a/TaxCalculatorTests/TaxCalculation.Tests.csproj b/TaxCalculatorTests/TaxCalculation.Tests.csproj
new file mode 100644
index 0000000..4d6048b
--- /dev/null
+++ b/TaxCalculatorTests/TaxCalculation.Tests.csproj
@@ -0,0 +1,95 @@
+
+
+
+ Debug
+ AnyCPU
+ {D6FE6A77-FCFA-4C4D-9F74-BE463F85670F}
+ Library
+ Properties
+ TaxCalculatorTests
+ TaxCalculatorTests
+ v4.5
+ 512
+ {3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}
+ 10.0
+ $(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)
+ $(ProgramFiles)\Common Files\microsoft shared\VSTT\$(VisualStudioVersion)\UITestExtensionPackages
+ False
+ UnitTest
+
+
+ true
+ full
+ false
+ bin\Debug\
+ DEBUG;TRACE
+ prompt
+ 4
+
+
+ pdbonly
+ true
+ bin\Release\
+ TRACE
+ prompt
+ 4
+
+
+
+ ..\packages\NUnit.2.6.2\lib\nunit.framework.dll
+
+
+ ..\packages\RhinoMocks.3.6.1\lib\net\Rhino.Mocks.dll
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {690771c4-1c1d-425c-8ddb-5cfad55c3418}
+ TaxCalculation.Domain
+
+
+
+
+
+
+ False
+
+
+ False
+
+
+ False
+
+
+ False
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/TaxCalculatorTests/bin/Debug/Rhino.Mocks.dll b/TaxCalculatorTests/bin/Debug/Rhino.Mocks.dll
new file mode 100644
index 0000000..c6f4f53
Binary files /dev/null and b/TaxCalculatorTests/bin/Debug/Rhino.Mocks.dll differ
diff --git a/TaxCalculatorTests/bin/Debug/Rhino.Mocks.xml b/TaxCalculatorTests/bin/Debug/Rhino.Mocks.xml
new file mode 100644
index 0000000..b1f7638
--- /dev/null
+++ b/TaxCalculatorTests/bin/Debug/Rhino.Mocks.xml
@@ -0,0 +1,5624 @@
+
+
+
+ Rhino.Mocks
+
+
+
+
+ Defines constraints and return values for arguments of a mock.
+ Only use Arg inside a method call on a mock that is recording.
+ Example:
+ ExpectCall(
+ mock.foo(
+ Arg<int>.Is.GreaterThan(2),
+ Arg<string>.Is.Anything
+ ));
+ Use Arg.Text for string specific constraints
+ Use Arg<ListClass>.List for list specific constraints
+
+
+
+
+
+ Register the predicate as a constraint for the current call.
+
+ The predicate.
+ default(T)
+
+ Allow you to use code to create constraints
+
+ demo.AssertWasCalled(x => x.Bar(Arg{string}.Matches(a => a.StartsWith("b") && a.Contains("ba"))));
+
+
+
+
+
+ Define a complex constraint for this argument by passing several constraints
+ combined with operators. (Use Is in simple cases.)
+ Example: Arg<string>.Matches(Is.Equal("Hello") || Text.EndsWith("u"));
+
+ Constraints using Is, Text and List
+ Dummy to satisfy the compiler
+
+
+
+ Define a Ref argument.
+
+ Constraints for this argument
+ value returned by the mock
+
+
+
+
+ Define a out parameter. Use it together with the keyword out and use the
+ Dummy field available by the return value.
+ Example: mock.foo( out Arg<string>.Out("hello").Dummy );
+
+
+
+
+
+
+ Define a simple constraint for this argument. (Use Matches in simple cases.)
+ Example:
+ Arg<int>.Is.Anthing
+ Arg<string>.Is.Equal("hello")
+
+
+
+
+ Define Constraints on list arguments.
+
+
+
+
+ Use the Arg class (without generic) to define Text constraints
+
+
+
+
+ Evaluate an equal constraint for .
+
+ The object the parameter should equal to
+
+
+
+ Define constraints on text arguments.
+
+
+
+
+ Used to manage the static state of the Arg<T> class"/>
+
+
+
+
+ Resets the static state
+
+
+
+
+ Returns return values for the out and ref parameters
+ Note: the array returned has the size of the number of out and ref
+ argument definitions
+
+
+
+
+
+ Returns the constraints for all arguments.
+ Out arguments have an Is.Anything constraint and are also in the list.
+
+
+
+
+
+ What should BackToRecord clear
+
+
+
+
+ Retain all expectations and behaviors and return to mock
+
+
+
+
+ All expectations
+
+
+
+
+ Event subscribers for this instance
+
+
+
+
+ Methods that should be forwarded to the base class implementation
+
+
+
+
+ Properties that should behave like properties
+
+
+
+
+ Remove all the behavior of the object
+
+
+
+
+ Interface for constraints
+
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ And operator for constraints
+
+
+
+
+ Not operator for constraints
+
+
+
+
+ Or operator for constraints
+
+
+
+
+ Allow overriding of || or &&
+
+
+
+
+
+
+ Allow overriding of || or &&
+
+
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constrain that the public field has a specified value
+
+
+
+
+ Constrain that the public field matches another constraint.
+
+
+
+
+ Creates a new instance.
+
+ Name of the public field.
+ Constraint to place on the public field value.
+
+
+
+ Creates a new instance, specifying a disambiguating
+ for the public field.
+
+ The type that declares the public field, used to disambiguate between public fields.
+ Name of the public field.
+ Constraint to place on the public field value.
+
+
+
+ Determines if the object passes the constraint.
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Creates a new instance.
+
+ Name of the public field.
+ Expected value.
+
+
+
+ Creates a new instance, specifying a disambiguating
+ for the public field.
+
+ The type that declares the public field, used to disambiguate between public fields.
+ Name of the public field.
+ Expected value.
+
+
+
+ Constrain that the property has a specified value
+
+
+
+
+ Constrain that the property matches another constraint.
+
+
+
+
+ Creates a new instance.
+
+ Name of the property.
+ Constraint to place on the property value.
+
+
+
+ Creates a new instance, specifying a disambiguating
+ for the property.
+
+ The type that declares the property, used to disambiguate between properties.
+ Name of the property.
+ Constraint to place on the property value.
+
+
+
+ Determines if the object passes the constraint.
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Creates a new instance.
+
+ Name of the property.
+ Expected value.
+
+
+
+ Creates a new instance, specifying a disambiguating
+ for the property.
+
+ The type that declares the property, used to disambiguate between properties.
+ Name of the property.
+ Expected value.
+
+
+
+ Constrain that the parameter must be of the specified type
+
+
+
+
+ Creates a new instance.
+
+ Type.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that determines whether an object is the same object as another.
+
+
+
+
+ Creates a new instance.
+
+ Obj.
+
+
+
+ Determines if the object passes the constraints.
+
+
+
+
+ Gets the message for this constraint.
+
+
+
+
+ Evaluate a parameter using constraints
+
+
+
+
+ Create new instance
+
+
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ A constraint based on lambda expression, we are using Expression{T}
+ because we want to be able to get good error reporting on that.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expr.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constrain that the list contains the same items as the parameter list
+
+
+
+
+ Creates a new instance.
+
+ In list.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constrain that the parameter is one of the items in the list
+
+
+
+
+ Creates a new instance.
+
+ In list.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constrain that the object is inside the parameter list
+
+
+
+
+ Creates a new instance.
+
+ In list.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Applies another AbstractConstraint to the collection count.
+
+
+
+
+ Creates a new instance.
+
+ The constraint that should be applied to the collection count.
+
+
+
+ Determines if the parameter conforms to this constraint.
+
+
+
+
+ Gets the message for this constraint.
+
+
+
+
+ Applies another AbstractConstraint to a specific list element.
+
+
+
+
+ Creates a new instance.
+
+ The zero-based index of the list element.
+ The constraint that should be applied to the list element.
+
+
+
+ Determines if the parameter conforms to this constraint.
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Applies another AbstractConstraint to a specific generic keyed list element.
+
+
+
+
+ Creates a new instance.
+
+ The key of the list element.
+ The constraint that should be applied to the list element.
+
+
+
+ Determines if the parameter conforms to this constraint.
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constrains that all elements are in the parameter list
+
+
+
+
+ Initializes a new instance of the class.
+
+ The these.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Combines two constraints, constraint pass if either is fine.
+
+
+
+
+ Creates a new instance.
+
+ C1.
+ C2.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Negate a constraint
+
+
+
+
+ Creates a new instance.
+
+ C1.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Combines two constraints
+
+
+
+
+
+ Creates a new instance.
+
+ C1.
+ C2.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constrain the argument to validate according to regex pattern
+
+
+
+
+ Creates a new instance.
+
+ Pattern.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that evaluate whatever an argument contains the specified string.
+
+
+
+
+ Creates a new instance.
+
+ Inner string.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that evaluate whatever an argument ends with the specified string
+
+
+
+
+ Creates a new instance.
+
+ End.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that evaluate whatever an argument start with the specified string
+
+
+
+
+ Creates a new instance.
+
+ Start.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that evaluate whatever an object equals another
+
+
+
+
+ Creates a new instance.
+
+ Obj.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that always returns true
+
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that evaluate whatever a comparable is greater than another
+
+
+
+
+ Creates a new instance.
+
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Initializes a new constraint object.
+
+ The expected object, The actual object is passed in as a parameter to the method
+
+
+
+ Evaluate this constraint.
+
+ The actual object that was passed in the method call to the mock.
+ True when the constraint is met, else false.
+
+
+
+ Checks if the properties of the object
+ are the same as the properies of the object.
+
+ The expected object
+ The actual object
+ True when both objects have the same values, else False.
+
+
+
+
+
+
+
+
+ This is the real heart of the beast.
+
+
+
+ Used by CheckReferenceType to check all properties of the reference type.
+
+ The expected object
+ The actual object
+ True when both objects have the same values, else False.
+
+
+
+ Used by CheckReferenceType to check all fields of the reference type.
+
+ The expected object
+ The actual object
+ True when both objects have the same values, else False.
+
+
+
+ Checks the items of both collections
+
+ The expected collection
+
+ True if both collections contain the same items in the same order.
+
+
+
+ Builds a propertyname from the Stack _properties like 'Order.Product.Price'
+ to be used in the error message.
+
+ A nested property name.
+
+
+
+ Rhino.Mocks uses this property to generate an error message.
+
+
+ A message telling the tester why the constraint failed.
+
+
+
+
+ Provides access to the constraintes defined in the class to be used in context
+ with the syntax.
+
+ The type of the argument
+
+
+
+ Evaluate a greater than constraint for .
+
+ The object the parameter should be greater than
+
+
+
+ Evaluate a less than constraint for .
+
+ The object the parameter should be less than
+
+
+
+ Evaluate a less than or equal constraint for .
+
+ The object the parameter should be less than or equal to
+
+
+
+ Evaluate a greater than or equal constraint for .
+
+ The object the parameter should be greater than or equal to
+
+
+
+ Evaluate an equal constraint for .
+
+ The object the parameter should equal to
+
+
+
+ Converts the object type to a better match if this is a primitive type.
+
+ The obj.
+
+
+
+
+ Converts the object type to match.
+
+
+ Because of implicit conversions and the way ArgConstraints this method is needed to check
+ object type and potentially change the object type for a better "match" so that obj1.Equals(obj2)
+ will return the proper "answer"
+
+ The obj.
+
+
+
+
+ Evaluate a not equal constraint for .
+
+ The object the parameter should not equal to
+
+
+
+ Evaluate a same as constraint.
+
+ The object the parameter should the same as.
+
+
+
+ Evaluate a not same as constraint.
+
+ The object the parameter should not be the same as.
+
+
+
+ Throws NotSupportedException. Don't use Equals to define constraints. Use Equal instead.
+
+
+
+
+
+
+ Serves as a hash function for a particular type.
+
+
+ A hash code for the current .
+
+
+
+
+ A constraints that accept anything
+
+
+
+
+
+ A constraint that accept only nulls
+
+
+
+
+
+ A constraint that accept only non null values
+
+
+
+
+
+ A constraint that accept only value of the specified type.
+ The check is performed on the type that has been defined
+ as the argument type.
+
+
+
+
+ Provides access to the constraints defined in the class to be used in context
+ with the syntax.
+
+
+
+
+ Determines whether the specified object is in the parameter.
+ The parameter must be IEnumerable.
+
+ Obj.
+
+
+
+
+ Determines whatever the parameter is in the collection.
+
+
+
+
+ Determines that the parameter collection is identical to the specified collection
+
+
+
+
+ Determines that the parameter collection has the specified number of elements.
+
+ The constraint that should be applied to the collection count.
+
+
+
+ Determines that an element of the parameter collections conforms to another AbstractConstraint.
+
+ The zero-based index of the list element.
+ The constraint which should be applied to the list element.
+
+
+
+ Determines that all elements of the specified collection are in the the parameter collection
+
+ The collection to compare against
+ The constraint which should be applied to the list parameter.
+
+
+
+ Throws NotSupportedException. Don't use Equals to define constraints. Use Equal instead.
+
+
+
+
+
+
+ Serves as a hash function for a particular type.
+
+
+ A hash code for the current .
+
+
+
+
+ Provides a dummy field to pass as out or ref argument.
+
+
+
+
+
+ Dummy field to satisfy the compiler. Used for out and ref arguments.
+
+
+
+
+ Central location for constraints for object's public fields
+
+
+
+
+ Constrains the parameter to have a public field with the specified value
+
+ Name of the public field.
+ Expected value.
+
+
+
+
+ Constrains the parameter to have a public field with the specified value.
+
+ The type that declares the public field, used to disambiguate between public fields.
+ Name of the public field.
+ Expected value.
+
+
+
+
+ Constrains the parameter to have a public field satisfying a specified constraint.
+
+ Name of the public field.
+ Constraint for the public field.
+
+
+
+ Constrains the parameter to have a public field satisfying a specified constraint.
+
+ The type that declares the public field, used to disambiguate between public fields.
+ Name of the public field.
+ Constraint for the public field.
+
+
+
+ Determines whether the parameter has the specified public field and that it is null.
+
+ Name of the public field.
+
+
+
+
+ Determines whether the parameter has the specified public field and that it is null.
+
+ The type that declares the public field, used to disambiguate between public fields.
+ Name of the public field.
+
+
+
+
+ Determines whether the parameter has the specified public field and that it is not null.
+
+ Name of the public field.
+
+
+
+
+ Determines whether the parameter has the specified public field and that it is not null.
+
+ The type that declares the public field, used to disambiguate between public fields.
+ Name of the public field.
+
+
+
+
+ Central location for constraints
+
+
+
+
+ Evaluate a greater than constraint for .
+
+ The object the parameter should be greater than
+
+
+
+ Evaluate a less than constraint for .
+
+ The object the parameter should be less than
+
+
+
+ Evaluate a less than or equal constraint for .
+
+ The object the parameter should be less than or equal to
+
+
+
+ Evaluate a greater than or equal constraint for .
+
+ The object the parameter should be greater than or equal to
+
+
+
+ Evaluate an equal constraint for .
+
+ The object the parameter should equal to
+
+
+
+ Evaluate a not equal constraint for .
+
+ The object the parameter should not equal to
+
+
+
+ Evaluate a same as constraint.
+
+ The object the parameter should the same as.
+
+
+
+ Evaluate a not same as constraint.
+
+ The object the parameter should not be the same as.
+
+
+
+ A constraints that accept anything
+
+
+
+
+
+ A constraint that accept only nulls
+
+
+
+
+
+ A constraint that accept only non null values
+
+
+
+
+
+ A constraint that accept only value of the specified type
+
+
+
+
+ A constraint that accept only value of the specified type
+
+
+
+
+ Evaluate a parameter using a predicate
+
+ The predicate to use
+
+
+
+ Central location for constraints about lists and collections
+
+
+
+
+ Determines whether the specified obj is in the parameter.
+ The parameter must be IEnumerable.
+
+ Obj.
+
+
+
+
+ Determines whatever the parameter is in the collection.
+
+
+
+
+ Determines that the parameter collection is identical to the specified collection
+
+
+
+
+ Determines that the parameter collection has the specified number of elements.
+
+ The constraint that should be applied to the collection count.
+
+
+
+ Determines that an element of the parameter collections conforms to another AbstractConstraint.
+
+ The zero-based index of the list element.
+ The constraint which should be applied to the list element.
+
+
+
+ Determines that an element of the parameter collections conforms to another AbstractConstraint.
+
+ The key of the element.
+ The constraint which should be applied to the element.
+
+
+
+ Determines that all elements of the specified collection are in the the parameter collection
+
+ The collection to compare against
+ The constraint which should be applied to the list parameter.
+
+
+
+ Central location for constraints for object's properties
+
+
+
+
+ Constrains the parameter to have property with the specified value
+
+ Name of the property.
+ Expected value.
+
+
+
+
+ Constrains the parameter to have property with the specified value.
+
+ The type that declares the property, used to disambiguate between properties.
+ Name of the property.
+ Expected value.
+
+
+
+
+ Constrains the parameter to have a property satisfying a specified constraint.
+
+ Name of the property.
+ Constraint for the property.
+
+
+
+ Constrains the parameter to have a property satisfying a specified constraint.
+
+ The type that declares the property, used to disambiguate between properties.
+ Name of the property.
+ Constraint for the property.
+
+
+
+ Determines whether the parameter has the specified property and that it is null.
+
+ Name of the property.
+
+
+
+
+ Determines whether the parameter has the specified property and that it is null.
+
+ The type that declares the property, used to disambiguate between properties.
+ Name of the property.
+
+
+
+
+ Determines whether the parameter has the specified property and that it is not null.
+
+ Name of the property.
+
+
+
+
+ Determines whether the parameter has the specified property and that it is not null.
+
+ The type that declares the property, used to disambiguate between properties.
+ Name of the property.
+
+
+
+
+ constraints the parameter to have the exact same property values as the expected object.
+
+ An object, of the same type as the parameter, whose properties are set with the expected values.
+ An instance of the constraint that will do the actual check.
+
+ The parameter's public property values and public field values will be matched against the expected object's
+ public property values and public field values. The first mismatch will be reported and no further matching is done.
+ The matching is recursive for any property or field that has properties or fields of it's own.
+ Collections are supported through IEnumerable, which means the constraint will check if the actual and expected
+ collection contain the same values in the same order, where the values contained by the collection can have properties
+ and fields of their own that will be checked as well because of the recursive nature of this constraint.
+
+
+
+
+ Central location for all text related constraints
+
+
+
+
+ Constrain the argument to starts with the specified string
+
+
+
+
+ Constrain the argument to end with the specified string
+
+
+
+
+ Constrain the argument to contain the specified string
+
+
+
+
+ Constrain the argument to validate according to regex pattern
+
+
+
+
+ Provides access to the constraintes defined in the class to be used in context
+ with the syntax.
+
+
+
+
+ Constrain the argument to starts with the specified string
+
+
+
+
+
+ Constrain the argument to end with the specified string
+
+
+
+
+ Constrain the argument to contain the specified string
+
+
+
+
+ Constrain the argument to validate according to regex pattern
+
+
+
+
+ Throws NotSupportedException. Don't use Equals to define constraints. Use Equal instead.
+
+
+
+
+
+
+ Serves as a hash function for a particular type.
+
+
+ A hash code for the current .
+
+
+
+
+ This class defines a lot of method signatures, which we will use
+ to allow compatability on net-2.0
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ Allows expectations to be set on methods that should never be called.
+ For methods with void return value, you need to use LastCall or
+ DoNotExpect.Call() with a delegate.
+
+
+
+
+ Sets LastCall.Repeat.Never() on /any/ proxy on /any/ repository on the current thread.
+ This method if not safe for multi threading scenarios.
+
+
+
+
+ Accepts a delegate that will execute inside the method which
+ LastCall.Repeat.Never() will be applied to.
+ It is expected to be used with anonymous delegates / lambda expressions and only one
+ method should be called.
+
+
+ IService mockSrv = mocks.CreateMock(typeof(IService)) as IService;
+ DoNotExpect.Call(delegate{ mockSrv.Stop(); });
+ ...
+
+
+
+
+ An expectaton violation was detected.
+
+
+
+
+ Creates a new instance.
+
+ Message.
+
+
+
+ Serialization constructor
+
+
+
+
+ Signals that an object was call on a mock repository which doesn't
+ belong to this mock repository or not a mock
+
+
+
+
+ Creates a new instance.
+
+ Message.
+
+
+
+ Serialization constructor
+
+
+
+
+ Allows to set expectation on methods that has return values.
+ For methods with void return value, you need to use LastCall
+
+
+
+
+ The method options for the last call on /any/ proxy on /any/ repository on the current thread.
+ This method if not safe for multi threading scenarios, use .
+
+
+
+
+ Accepts a delegate that will execute inside the method, and then return the resulting
+ instance.
+ It is expected to be used with anonymous delegates / lambda expressions and only one
+ method should be called.
+
+
+ IService mockSrv = mocks.CreateMock(typeof(IService)) as IService;
+ Expect.Call(delegate{ mockSrv.Start(); }).Throw(new NetworkException());
+ ...
+
+
+
+
+ Get the method options for the last method call on the mockInstance.
+
+
+
+
+ A delegate that can be used to get better syntax on Expect.Call(delegate { foo.DoSomething(); });
+
+
+
+
+ Abstract class that holds common information for
+ expectations.
+
+
+
+
+ Interface to validate that a method call is correct.
+
+
+
+
+ Validate the arguments for the method.
+ This method can be called numerous times, so be careful about side effects
+
+ The arguments with which the method was called
+
+
+
+ Add an actual method call to this expectation
+
+
+
+
+ Returns the return value or throw the exception and setup any output / ref parameters
+ that has been set.
+
+
+
+
+ Builds the verification failure message.
+
+
+
+
+
+ Gets the error message.
+
+
+
+
+
+ Range of expected calls
+
+
+
+
+ Number of call actually made for this method
+
+
+
+
+ If this expectation is still waiting for calls.
+
+
+
+
+ The return value for a method matching this expectation
+
+
+
+
+ Gets or sets the exception to throw on a method matching this expectation.
+
+
+
+
+ Gets a value indicating whether this instance's action is staisfied.
+ A staisfied instance means that there are no more requirements from
+ this method. A method with non void return value must register either
+ a return value or an exception to throw.
+
+
+
+
+ Gets the method this expectation is for.
+
+
+
+
+ Gets or sets what special condtions there are for this method
+ repeating.
+
+
+
+
+ Gets a value indicating whether this expectation was satisfied
+
+
+
+
+ Specify whatever this expectation has a return value set
+ You can't check ReturnValue for this because a valid return value include null.
+
+
+
+
+ An action to execute when the method is matched.
+
+
+
+
+ Set the out / ref parameters for the method call.
+ The indexing is zero based and ignores any non out/ref parameter.
+ It is possible not to pass all the parameters. This method can be called only once.
+
+
+
+
+ Documentation Message
+
+
+
+
+ Gets the invocation for this expectation
+
+ The invocation.
+
+
+
+ Occurs when the exceptation is match on a method call
+
+
+
+
+ Allow to set the return value in the future, if it was already set.
+
+
+
+
+ Number of actuall calls made that passed this expectation
+
+
+
+
+ Range of expected calls that should pass this expectation.
+
+
+
+
+ The return value for a method matching this expectation
+
+
+
+
+ The exception to throw on a method matching this expectation.
+
+
+
+
+ The method this expectation is for.
+
+
+
+
+ The return value for this method was set
+
+
+
+
+ Whether this method will repeat
+ unlimited number of times.
+
+
+
+
+ A delegate that will be run when the
+ expectation is matched.
+
+
+
+
+ The arguments that matched this expectation.
+
+
+
+
+ Documentation message
+
+
+
+
+ The method originalInvocation
+
+
+
+
+ Get the hash code
+
+
+
+
+ Add an actual actualMethodCall call to this expectation
+
+
+
+
+ Builds the verification failure message.
+
+
+
+
+
+ Returns the return value or throw the exception and setup output / ref parameters
+
+
+
+
+ Validate the arguments for the method on the child methods
+
+ The arguments with which the method was called
+
+
+
+ Creates a new instance.
+
+ The originalInvocation for this method, required because it contains the generic type infromation
+ Number of method calls for this expectations
+
+
+
+ Creates a new instance.
+
+ Expectation.
+
+
+
+ Validate the arguments for the method on the child methods
+
+ The arguments with which the method was called
+
+
+
+ Determines if this object equal to obj
+
+
+
+
+ The error message for these arguments
+
+
+
+
+ Asserts that the delegate has the same parameters as the expectation's method call
+
+
+
+
+ Setter for the outpur / ref parameters for this expecataion.
+ Can only be set once.
+
+
+
+
+ Specify whether this expectation has a return value set
+ You can't check ReturnValue for this because a valid return value include null.
+
+
+
+
+ Gets the method this expectation is for.
+
+
+
+
+ Gets the originalInvocation for this expectation
+
+ The originalInvocation.
+
+
+
+ Gets or sets what special condtions there are for this method
+
+
+
+
+ Range of expected calls
+
+
+
+
+ Number of call actually made for this method
+
+
+
+
+ If this expectation is still waiting for calls.
+
+
+
+
+ Gets a value indicating whether this expectation was satisfied
+
+
+
+
+ The return value for a method matching this expectation
+
+
+
+
+ An action to execute when the method is matched.
+
+
+
+
+ Gets or sets the exception to throw on a method matching this expectation.
+
+
+
+
+ Gets a value indicating whether this instance's action is staisfied.
+ A staisfied instance means that there are no more requirements from
+ this method. A method with non void return value must register either
+ a return value or an exception to throw or an action to execute.
+
+
+
+
+ Documentation message
+
+
+
+
+ Occurs when the exceptation is match on a method call
+
+
+
+
+ Allow to set the return value in the future, if it was already set.
+
+
+
+
+ Gets the error message.
+
+
+
+
+
+ Expectation that matches any arguments for the method.
+
+
+
+
+ Creates a new instance.
+
+ Invocation for this expectation
+ Number of method calls for this expectations
+
+
+
+ Creates a new instance.
+
+ Expectation.
+
+
+
+ Validate the arguments for the method.
+
+ The arguments with which the method was called
+
+
+
+ Determines if the object equal to expectation
+
+
+
+
+ Get the hash code
+
+
+
+
+ Gets the error message.
+
+
+
+
+
+ Summary description for ArgsEqualExpectation.
+
+
+
+
+ Creates a new instance.
+
+ Expected args.
+ The invocation for this expectation
+ Number of method calls for this expectations
+
+
+
+ Validate the arguments for the method.
+
+ The arguments with which the method was called
+
+
+
+ Determines if the object equal to expectation
+
+
+
+
+ Get the hash code
+
+
+
+
+ Gets the error message.
+
+
+
+
+
+ Get the expected args.
+
+
+
+
+ Call a specified callback to verify the expectation
+
+
+
+
+ Creates a new instance.
+
+ Expectation.
+ Callback.
+
+
+
+ Creates a new instance.
+
+ Invocation for this expectation
+ Callback.
+ Number of method calls for this expectations
+
+
+
+ Validate the arguments for the method on the child methods
+
+ The arguments with which the method was called
+
+
+
+ Determines if the object equal to expectation
+
+
+
+
+ Get the hash code
+
+
+
+
+ Gets the error message.
+
+
+
+
+
+ Expect the method's arguments to match the contraints
+
+
+
+
+ Creates a new instance.
+
+ Invocation for this expectation
+ Constraints.
+ Number of method calls for this expectations
+
+
+
+ Creates a new instance.
+
+ Expectation.
+ Constraints.
+
+
+
+ Validate the arguments for the method.
+
+ The arguments with which the method was called
+
+
+
+ Determines if the object equal to expectation
+
+
+
+
+ Get the hash code
+
+
+
+
+ Gets the error message.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Summary for AndSpecification
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Summary description for FollowsEventNamingStandard
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Summary descritpion for NamedEventExistsOnDeclaringType
+
+
+
+
+
+
+
+
+ Doesn't log anything, just makes happy noises
+
+
+
+
+ Log expectations - allows to see what is going on inside Rhino Mocks
+
+
+
+
+ Logs the expectation as is was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the expectation as it was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the unexpected method call.
+
+ The invocation.
+ The message.
+
+
+
+ Logs the expectation as is was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the expectation as it was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the unexpected method call.
+
+ The invocation.
+ The message.
+
+
+
+ Operation on a remoting proxy
+
+
+ It is not possible to directly communicate to a real proxy via transparent proxy.
+ Transparent proxy impersonates a user type and only methods of that user type are callable.
+ The only methods that are guaranteed to exist on any transparent proxy are methods defined
+ in Object: namely ToString(), GetHashCode(), and Equals()).
+
+ These three methods are the only way to tell the real proxy to do something.
+ Equals() is the most suitable of all, since it accepts an arbitrary object parameter.
+ The RemotingProxy code is built so that if it is compared to an IRemotingProxyOperation,
+ transparentProxy.Equals(operation) will call operation.Process(realProxy).
+ This way we can retrieve a real proxy from transparent proxy and perform
+ arbitrary operation on it.
+
+
+
+
+ Generates remoting proxies and provides utility functions
+
+
+
+
+ Create the proxy using remoting
+
+
+
+
+ Check whether an object is a transparent proxy with a RemotingProxy behind it
+
+ Object to check
+ true if the object is a transparent proxy with a RemotingProxy instance behind it, false otherwise
+ We use Equals() method to communicate with the real proxy behind the object.
+ See IRemotingProxyOperation for more details
+
+
+
+ Retrieve a mocked object from a transparent proxy
+
+ Transparent proxy with a RemotingProxy instance behind it
+ Mocked object associated with the proxy
+ We use Equals() method to communicate with the real proxy behind the object.
+ See IRemotingProxyOperation for more details
+
+
+
+ Implementation of IInvocation based on remoting proxy
+
+ Some methods are marked NotSupported since they either don't make sense
+ for remoting proxies, or they are never called by Rhino Mocks
+
+
+
+ Rudimetry implementation that simply logs methods calls as text.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The writer.
+
+
+
+ Logs the expectation as it was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the expectation as it was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the unexpected method call.
+
+ The invocation.
+ The message.
+
+
+
+ Behave like a stub, all properties and events acts normally, methods calls
+ return default values by default (but can use expectations to set them up), etc.
+
+
+
+
+ Records all the expectations for a mock
+
+
+
+
+ Different actions on this mock
+
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Verify that this mock expectations have passed.
+
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Set the exception to throw when Verify is called.
+ This is used to report exception that may have happened but where caught in the code.
+ This way, they are reported anyway when Verify() is called.
+
+
+
+
+ This method is called to indicate that a property behavior call.
+ This is done so we generate good error message in the common case of people using
+ Stubbed properties with Return().
+
+
+
+
+ Gets the matching verify state for this state
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Set the exception to throw when Verify is called.
+ This is used to report exception that may have happened but where caught in the code.
+ This way, they are reported anyway when Verify() is called.
+
+
+
+
+ This method is called to indicate that a property behavior call.
+ This is done so we generate good error message in the common case of people using
+ Stubbed properties with Return().
+
+
+
+
+ Creates a new instance.
+
+ Repository.
+ The proxy that generates the method calls
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Verify that this mock expectations have passed.
+
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Asserts the previous method is closed (had an expectation set on it so we can replay it correctly)
+
+
+
+
+ Get the default call count range expectation
+
+
+
+
+
+ Gets the last expectation.
+
+
+
+
+ Gets the total method calls count.
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Gets the matching verify state for this state
+
+
+
+
+ Initializes a new instance of the class.
+
+ The proxy that generates the method calls
+ Repository.
+
+
+
+ We don't care much about expectations here, so we will remove the expectation if
+ it is not closed.
+
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+
+ Get the default call count range expectation
+
+
+
+
+
+ Validate expectations on recorded methods, but in general completely ignoring them.
+ Similar to except that it would return a
+ when BackToRecord is called.
+
+
+
+
+ Validate all expectations on a mock
+
+
+
+
+ The repository for this state
+
+
+
+
+ The proxy object for this state
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Creates a new instance.
+
+ The previous state for this method
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Add a method call for this state' mock.
+ This allows derived method to cleanly get a the setupresult behavior while adding
+ their own.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Set the exception to throw when Verify is called.
+ This is used to report exception that may have happened but where caught in the code.
+ This way, they are reported anyway when Verify() is called.
+
+
+
+
+ not relevant
+
+
+
+
+ Verify that this mock expectations have passed.
+
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Gets the matching verify state for this state
+
+
+
+
+ Initializes a new instance of the class.
+
+ The previous state for this method
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Gets a mock state that matches the original mock state of the object.
+
+
+
+
+ Write rhino mocks log info to the trace
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ Initializes a new instance of the class.
+
+ if set to true [log recorded].
+ if set to true [log replayed].
+ if set to true [log unexpected].
+
+
+
+ Logs the expectation as is was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the expectation as it was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the unexpected method call.
+
+ The invocation.
+ The message.
+
+
+
+ Writes log information as stack traces about rhino mocks activity
+
+
+
+
+ Allows to redirect output to a different location.
+
+
+
+
+ Logs the expectation as is was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the expectation as it was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the unexpected method call.
+
+ The invocation.
+ The message.
+
+
+
+ Marker interface used to indicate that this is a partial mock.
+
+
+
+
+ Options for CallOriginalMethod
+
+
+
+
+ No expectation is created, the method will be called directly
+
+
+
+
+ Normal expectation is created, but when the method is later called, it will also call the original method
+
+
+
+
+ This is a data structure that is used by
+ to pass
+ the current method to the relevant delegate
+
+
+
+
+ Initializes a new instance of the class.
+
+ The invocation.
+
+
+
+ Gets the args for this method invocation
+
+
+
+
+ Get the method that was caused this invocation
+
+
+
+
+ Gets or sets the return value for this method invocation
+
+ The return value.
+
+
+
+ Adds optional new usage:
+ using(mockRepository.Record()) {
+ Expect.Call(mock.Method()).Return(retVal);
+ }
+ using(mockRepository.Playback()) {
+ // Execute code
+ }
+ N.B. mockRepository.ReplayAll() and mockRepository.VerifyAll()
+ calls are taken care of by Record/Playback
+
+
+ Creates proxied instances of types.
+
+
+
+ Generates a stub without needing a
+ Arguments for 's constructor
+ The of stub to create.
+ The stub
+
+
+
+ Generates a stub without needing a
+ The of stub.
+ Arguments for the 's constructor.
+ The stub
+
+
+
+ Generate a mock object without needing a
+ type of mock object to create.
+ Arguments for 's constructor
+ the mock object
+
+
+
+ Generate a multi-mock object without needing a
+ The typeof object to generate a mock for.
+ A second interface to generate a multi-mock for.
+ Arguments for 's constructor
+ the multi-mock object
+
+
+
+ Generate a multi-mock object without without needing a
+ The typeof object to generate a mock for.
+ An interface to generate a multi-mock for.
+ A second interface to generate a multi-mock for.
+ Arguments for 's constructor
+ the multi-mock object
+
+
+
+ Creates a multi-mock without without needing a
+ The type of mock to create, this can be a class
+ Any extra interfaces to add to the multi-mock, these can only be interfaces.
+ Arguments for 's constructor
+ the multi-mock object
+
+
+
+ Creates a strict mock without without needing a
+ Any arguments required for the 's constructor
+ The type of mock object to create.
+ The mock object with strict replay semantics
+
+
+
+ Creates a strict multi-mock without needing a
+ Any arguments required for the 's constructor
+ The type of mock object to create, this can be a class.
+ An interface to generate a multi-mock for, this must be an interface!
+ The multi-mock object with strict replay semantics
+
+
+
+ Creates a strict multi-mock without needing a
+ Any arguments required for the 's constructor
+ The type of mock object to create, this can be a class.
+ An interface to generate a multi-mock for, this must be an interface!
+ A second interface to generate a multi-mock for, this must be an interface!
+ The multi-mock object with strict replay semantics
+
+
+
+ Creates a strict multi-mock without needing a
+ The type of mock object to create, this can be a class
+ Any extra interfaces to generate a multi-mock for, these must be interaces!
+ Any arguments for the 's constructor
+ The strict multi-mock object
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Generate a mock object with dynamic replay semantics and remoting without needing the mock repository
+
+
+
+
+ Generate a mock object with strict replay semantics and remoting without needing the mock repository
+
+
+
+ Helper method to create a mock object without a repository instance and put the object back into replay mode.
+ The type of mock object to create
+ A delegate that uses a mock repository instance to create the underlying mock
+ The mock object in the replay mode.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This is a map of types to ProxyGenerators.
+
+
+
+
+ This is used to record the last repository that has a method called on it.
+
+
+
+
+ this is used to get to the last proxy on this repository.
+
+
+
+
+ For mock delegates, maps the proxy instance from intercepted invocations
+ back to the delegate that was originally returned to client code, if any.
+
+
+
+
+ All the proxies in the mock repositories
+
+
+
+
+ This is here because we can't put it in any of the recorders, since repeatable methods
+ have no orderring, and if we try to handle them using the usual manner, we would get into
+ wierd situations where repeatable method that was defined in an orderring block doesn't
+ exists until we enter this block.
+
+
+
+
+ Creates a new instance.
+
+
+
+
+ Move the repository to ordered mode
+
+
+
+
+ Move the repository to un-ordered mode
+
+
+
+
+ Creates a mock for the specified type.
+
+ Type.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a strict mock for the specified type.
+
+ Type.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a remoting mock for the specified type.
+
+ Type.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a strict remoting mock for the specified type.
+
+ Type.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a remoting mock for the specified type.
+
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+
+ Creates a strict remoting mock for the specified type.
+
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+
+ Creates a mock from several types, with strict semantics.
+ Only may be a class.
+
+
+
+
+ Creates a strict mock from several types, with strict semantics.
+ Only may be a class.
+
+
+
+
+ Creates a mock from several types, with strict semantics.
+ Only may be a class.
+
+ The main type to mock.
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class.
+
+
+
+ Creates a strict mock from several types, with strict semantics.
+ Only may be a class.
+
+ The main type to mock.
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class.
+
+
+
+ Creates a mock from several types, with dynamic semantics.
+ Only may be a class.
+
+ The main type to mock.
+ Extra interface types to mock.
+
+
+
+ Creates a mock from several types, with dynamic semantics.
+ Only may be a class.
+
+ The main type to mock.
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class.
+
+
+ Creates a dynamic mock for the specified type.
+ Type.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+ Creates a dynamic mock for the specified type.
+ Type.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+ Creates a dynamic mock for the specified type.
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a mock object that defaults to calling the class methods if no expectation is set on the method.
+ Type.
+ Arguments for the class' constructor.
+
+
+ Creates a mock object that defaults to calling the class methods.
+ Type.
+ Extra interface types to mock.
+
+
+ Creates a mock object that defaults to calling the class methods.
+ Type.
+ Extra interface types to mock.
+ Arguments for the class' constructor.
+
+
+ Creates a mock object using remoting proxies
+ Type to mock - must be MarshalByRefObject
+ Mock object
+ Proxy mock can mock non-virtual methods, but not static methods
+ Creates the mock state for this proxy
+
+
+
+ Cause the mock state to change to replay, any further call is compared to the
+ ones that were called in the record state.
+
+ This method *cannot* be called from inside an ordering.
+ the object to move to replay state
+
+
+
+ Cause the mock state to change to replay, any further call is compared to the
+ ones that were called in the record state.
+
+ the object to move to replay state
+
+
+
+ Move the mocked object back to record state.You can (and it's recommended) to run {Verify()} before you use this method.
+ Will delete all current expectations!
+
+
+
+ Move the mocked object back to record state.
+ Optionally, can delete all current expectations, but allows more granularity about how
+ it would behave with regard to the object state.
+
+
+
+
+ Verify that all the expectations for this object were fulfilled.
+
+ the object to verify the expectations for
+
+
+
+ Get the method options for the last call on
+ mockedInstance.
+
+ The mock object
+ Method options for the last call
+
+
+
+ Maps an invocation proxy back to the mock object instance that was originally
+ returned to client code which might have been a delegate to this proxy.
+
+ The mock object proxy from the intercepted invocation
+ The mock object
+
+
+ This is provided to allow advance extention functionality, where Rhino Mocks standard functionality is not enough.
+ The type to mock
+ Delegate that create the first state of the mocked object (usualy the record state).
+ Additional types to be implemented, this can be only interfaces
+ optional arguments for the constructor
+
+
+
+
+ Method: GetMockedObject
+ Get an IProxy from a mocked object instance, or throws if the
+ object is not a mock object.
+
+
+
+
+ Method: GetMockedObjectOrNull
+ Get an IProxy from a mocked object instance, or null if the
+ object is not a mock object.
+
+
+
+ Pops the recorder.
+
+
+ Pushes the recorder.
+ New recorder.
+
+
+
+ All the mock objects in this repository will be moved
+ to record state.
+
+
+
+
+ All the mock objects in this repository will be moved
+ to record state.
+
+
+
+
+ Replay all the mocks from this repository
+
+
+
+
+ Verify all the mocks from this repository
+
+
+
+
+ Gets the proxy generator for a specific type. Having a single ProxyGenerator
+ with multiple types linearly degrades the performance so this implementation
+ keeps one ProxyGenerator per type.
+
+
+
+ Set the exception to be thrown when verified is called.
+
+
+
+ Creates a mock for the spesified type with strict mocking semantics.
+ Strict semantics means that any call that wasn't explicitly recorded is considered an error and would cause an exception to be thrown.
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a mock for the spesified type with strict mocking semantics.
+ Strict semantics means that any call that wasn't explicitly recorded is considered an error and would cause an exception to be thrown.
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a dynamic mock for the specified type.
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a mock object from several types.
+
+
+
+
+ Creates a strict mock object from several types.
+
+
+
+
+ Create a mock object from several types with dynamic semantics.
+
+
+
+
+ Create a mock object from several types with partial semantics.
+
+
+
+
+ Create a mock object from several types with strict semantics.
+
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Create a strict mock object from several types with strict semantics.
+
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Create a mock object from several types with dynamic semantics.
+
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Create a mock object from several types with partial semantics.
+
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Create a mock object with from a class that defaults to calling the class methods
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Create a stub object, one that has properties and events ready for use, and
+ can have methods called on it. It requires an explicit step in order to create
+ an expectation for a stub.
+
+ The arguments for constructor.
+
+
+
+ Create a stub object, one that has properties and events ready for use, and
+ can have methods called on it. It requires an explicit step in order to create
+ an expectation for a stub.
+
+ The type.
+ The arguments for constructor.
+ The stub
+
+
+
+ Returns true if the passed mock is currently in replay mode.
+
+ The mock to test.
+ True if the mock is in replay mode, false otherwise.
+
+
+
+ Determines whether the specified proxy is a stub.
+
+ The proxy.
+
+
+
+ Register a call on a prperty behavior
+
+
+
+
+
+ Gets the recorder.
+
+
+
+
+
+ Gets the replayer for this repository.
+
+
+
+
+
+ Gets the last proxy which had a method call.
+
+
+
+
+ Delegate: CreateMockState
+ This is used internally to cleanly handle the creation of different
+ RecordMockStates.
+
+
+
+
+ A set of extension methods that adds Arrange Act Assert mode to Rhino Mocks
+
+
+
+
+ Create an expectation on this mock for this action to occur
+
+
+ The mock.
+ The action.
+
+
+
+
+ Reset all expectations on this mock object
+
+
+ The mock.
+
+
+
+ Reset the selected expectation on this mock object
+
+
+ The mock.
+ The options to reset the expectations on this mock.
+
+
+
+ Cause the mock state to change to replay, any further call is compared to the
+ ones that were called in the record state.
+
+ the mocked object to move to replay state
+
+
+
+ Gets the mock repository for this specificied mock object
+
+
+ The mock.
+
+
+
+
+ Create an expectation on this mock for this action to occur
+
+
+
+ The mock.
+ The action.
+
+
+
+
+ Tell the mock object to perform a certain action when a matching
+ method is called.
+ Does not create an expectation for this method.
+
+
+ The mock.
+ The action.
+
+
+
+
+ Tell the mock object to perform a certain action when a matching
+ method is called.
+ Does not create an expectation for this method.
+
+
+
+ The mock.
+ The action.
+
+
+
+
+ Gets the arguments for calls made on this mock object and the method that was called
+ in the action.
+
+
+ The mock.
+ The action.
+
+
+ Here we will get all the arguments for all the calls made to DoSomething(int)
+
+ var argsForCalls = foo54.GetArgumentsForCallsMadeOn(x => x.DoSomething(0))
+
+
+
+
+
+ Gets the arguments for calls made on this mock object and the method that was called
+ in the action and matches the given constraints
+
+
+ The mock.
+ The action.
+ The setup constraints.
+
+
+ Here we will get all the arguments for all the calls made to DoSomething(int)
+
+ var argsForCalls = foo54.GetArgumentsForCallsMadeOn(x => x.DoSomething(0))
+
+
+
+
+
+ Asserts that a particular method was called on this mock object
+
+
+ The mock.
+ The action.
+
+
+
+ Asserts that a particular method was called on this mock object that match
+ a particular constraint set.
+
+
+ The mock.
+ The action.
+ The setup constraints.
+
+
+
+ Asserts that a particular method was called on this mock object that match
+ a particular constraint set.
+
+
+ The mock.
+ The action.
+
+
+
+ Asserts that a particular method was called on this mock object that match
+ a particular constraint set.
+
+
+ The mock.
+ The action.
+ The setup constraints.
+
+
+
+ Asserts that a particular method was NOT called on this mock object
+
+
+ The mock.
+ The action.
+
+
+
+ Asserts that a particular method was NOT called on this mock object that match
+ a particular constraint set.
+
+
+ The mock.
+ The action.
+ The setup constraints.
+
+
+
+ Asserts that a particular method was NOT called on this mock object
+
+
+ The mock.
+ The action.
+
+
+
+ Asserts that a particular method was NOT called on this mock object
+
+
+ The mock.
+ The action.
+ The setup constraints.
+
+
+
+ Finds the approprite implementation type of this item.
+ This is the class or an interface outside of the rhino mocks.
+
+ The mocked obj.
+
+
+
+
+ Verifies all expectations on this mock object
+
+ The mock object.
+
+
+
+ Gets the event raiser for the event that was called in the action passed
+
+ The type of the event source.
+ The mock object.
+ The event subscription.
+
+
+
+
+ Raise the specified event using the passed arguments.
+ The even is extracted from the passed labmda
+
+ The type of the event source.
+ The mock object.
+ The event subscription.
+ The sender.
+ The instance containing the event data.
+
+
+
+ Raise the specified event using the passed arguments.
+ The even is extracted from the passed labmda
+
+ The type of the event source.
+ The mock object.
+ The event subscription.
+ The args.
+
+
+ TODO: Make this better! It currently breaks down when mocking classes or
+ ABC's that call other virtual methods which are getting intercepted too. I wish
+ we could just walk Expression{Action{Action{T}} to assert only a single
+ method is being made.
+
+ The workaround is to not call foo.AssertWasCalled .. rather foo.VerifyAllExpectations()
+ The type of mock object
+ The mock repository
+ The actual mock object to assert expectations on.
+
+
+
+ Fake type that disallow creating it.
+ Should have been System.Type, but we can't use it.
+
+
+
+
+ Utility class for dealing with messing generics scenarios.
+
+
+
+
+ There are issues with trying to get this to work correctly with open generic types, since this is an edge case,
+ I am letting the runtime handle it.
+
+
+
+
+ Gets the real type, including de-constructing and constructing the type of generic
+ methods parameters.
+
+ The type.
+ The invocation.
+
+
+
+
+ Because we need to support complex types here (simple generics were handled above) we
+ need to be aware of the following scenarios:
+ List[T] and List[Foo[T]]
+
+
+
+
+ ExpectationsList
+
+
+
+
+ Dictionary
+
+
+
+
+ Dictionary class
+
+
+
+
+ Create a new instance of ProxyStateDictionary
+
+
+
+
+ Allows to call a method and immediately get it's options.
+
+
+
+
+ Interface to allow calling a method and immediately get it's options.
+
+
+
+
+ Get the method options for the call
+
+ The method call should go here, the return value is ignored
+
+
+
+ Creates a new instance.
+
+
+
+
+ Get the method options for the call
+
+ The method call should go here, the return value is ignored
+
+
+
+ Allows to call a method and immediately get it's options.
+ Set the expected number for the call to Any()
+
+
+
+
+ Creates a new instance.
+
+ Proxy.
+ Mocked instance.
+
+
+
+ Get the method options for the call
+
+ The method call should go here, the return value is ignored
+
+
+
+ This class is reponsible for taking a delegate and creating a wrapper
+ interface around it, so it can be mocked.
+
+
+
+
+ The scope for all the delegate interfaces create by this mock repository.
+
+
+
+
+ Gets a type with an "Invoke" method suitable for use as a target of the
+ specified delegate type.
+
+
+
+
+
+
+ Raise events for all subscribers for an event
+
+
+
+
+ Raise events for all subscribers for an event
+
+
+
+
+ Raise the event
+
+
+
+
+ The most common form for the event handler signature
+
+
+
+
+ Create an event raiser for the specified event on this instance.
+
+
+
+
+ Creates a new instance of EventRaiser
+
+
+
+
+ Raise the event
+
+
+
+
+ The most common signature for events
+ Here to allow intellisense to make better guesses about how
+ it should suggest parameters.
+
+
+
+
+ Allows to define what would happen when a method
+ is called.
+
+
+
+
+ Allows to define what would happen when a method
+ is called.
+
+
+
+
+ Set the return value for the method.
+
+ The object the method will return
+ IRepeat that defines how many times the method will return this value
+
+
+
+ Allow to override this return value in the future
+
+ IRepeat that defines how many times the method will return this value
+
+
+
+ Throws the specified exception when the method is called.
+
+ Exception to throw
+
+
+
+ Ignores the arguments for this method. Any argument will be matched
+ againt this method.
+
+
+
+
+ Add constraints for the method's arguments.
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched
+ and allow to optionally modify the invocation as needed
+
+
+
+
+ Call the original method on the class, bypassing the mocking layers.
+
+
+
+
+
+ Call the original method on the class, optionally bypassing the mocking layers.
+
+
+
+
+
+ Use the property as a simple property, getting/setting the values without
+ causing mock expectations.
+
+
+
+
+ Expect last (property) call as property setting, ignore the argument given
+
+
+
+
+
+ Expect last (property) call as property setting with a given argument.
+
+
+
+
+
+
+ Get an event raiser for the last subscribed event.
+
+
+
+
+ Set the parameter values for out and ref parameters.
+ This is done using zero based indexing, and _ignoring_ any non out/ref parameter.
+
+
+
+
+ Documentation message for the expectation
+
+ Message
+
+
+
+ Better syntax to define repeats.
+
+
+
+
+ Allows to specify the number of time for method calls
+
+
+
+
+ Repeat the method twice.
+
+
+
+
+ Repeat the method once.
+
+
+
+
+ Repeat the method at least once, then repeat as many time as it would like.
+
+
+
+
+ Repeat the method any number of times.
+ This has special affects in that this method would now ignore orderring.
+
+
+
+
+ Set the range to repeat an action.
+
+ Min.
+ Max.
+
+
+
+ Set the amount of times to repeat an action.
+
+
+
+
+ This method must not appear in the replay state.
+ This has special affects in that this method would now ignore orderring.
+
+
+
+
+ Creates a new instance.
+
+ the repository for this expectation
+ the recorder for this proxy
+ the proxy for this expectation
+ Expectation.
+
+
+
+ Add constraints for the method's arguments.
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set the return value for the method.
+
+ The object the method will return
+ IRepeat that defines how many times the method will return this value
+
+
+
+ Set the return value for the method, but allow to override this return value in the future
+
+ IRepeat that defines how many times the method will return this value
+
+
+
+ Throws the specified exception when the method is called.
+
+ Exception to throw
+
+
+
+ Ignores the arguments for this method. Any argument will be matched
+ againt this method.
+
+
+
+
+ Call the original method on the class, bypassing the mocking layers.
+
+
+
+
+
+ Call the original method on the class, optionally bypassing the mocking layers
+
+
+
+
+
+ Use the property as a simple property, getting/setting the values without
+ causing mock expectations.
+
+
+
+
+ Expect last (property) call as property setting, ignore the argument given
+
+
+
+
+
+ Expect last (property) call as property setting with a given argument.
+
+
+
+
+
+
+ Gets the event raiser for the last event
+
+
+
+
+ Set the parameter values for out and ref parameters.
+ This is done using zero based indexing, and _ignoring_ any non out/ref parameter.
+
+
+
+
+ Repeat the method twice.
+
+
+
+
+ Repeat the method once.
+
+
+
+
+ Repeat the method at least once, then repeat as many time as it would like.
+
+
+
+
+ This method must not appear in the replay state.
+
+
+
+
+ Documentation message for the expectation
+
+ Message
+
+
+
+ Repeat the method any number of times.
+
+
+
+
+ Set the range to repeat an action.
+
+ Min.
+ Max.
+
+
+
+ Set the amount of times to repeat an action.
+
+
+
+
+ Better syntax to define repeats.
+
+
+
+
+ This class will provide hash code for hashtables without needing
+ to call the GetHashCode() on the object, which may very well be mocked.
+ This class has no state so it is a singelton to avoid creating a lot of objects
+ that does the exact same thing. See flyweight patterns.
+
+
+
+
+ Get the hash code for a proxy object without calling GetHashCode()
+ on the object.
+
+
+
+
+ Compares two instances of mocked objects
+
+
+
+
+ Compare two mocked objects
+
+
+
+
+ The next hash code value for a mock object.
+ This is safe for multi threading.
+
+
+
+
+ The sole instance of
+
+
+
+
+ This is a dummy type that is used merely to give DynamicProxy the proxy instance that
+ it needs to create IProxy's types.
+
+
+
+
+ Interface to find the repository of a mocked object
+
+
+
+
+ Return true if it should call the original method on the object
+ instead of pass it to the message chain.
+
+ The method to call
+
+
+
+ Register a method to be called on the object directly
+
+
+
+
+ Register a property on the object that will behave as a simple property
+
+
+
+
+ Check if the method was registered as a property method.
+
+
+
+
+ Do get/set on the property, according to need.
+
+
+
+
+ Do add/remove on the event
+
+
+
+
+ Get the subscribers of a spesific event
+
+
+
+
+ Gets the declaring type of the method, taking into acccount the possible generic
+ parameters that it was created with.
+
+
+
+
+ Clears the state of the object, remove original calls, property behavior, subscribed events, etc.
+
+
+
+
+ Get all the method calls arguments that were made against this object with the specificed
+ method.
+
+
+ Only method calls in replay mode are counted
+
+
+
+
+ Records the method call
+
+
+
+
+ Mocks that are tied to this mock lifestyle
+
+
+
+
+ The unique hash code of this mock, which is not related
+ to the value of the GetHashCode() call on the object.
+
+
+
+
+ Gets the repository.
+
+
+
+
+ Gets the implemented types by this mocked object
+
+ The implemented.
+
+
+
+ Gets or sets the constructor arguments.
+
+ The constructor arguments.
+
+
+
+ The mocked instance that this is representing
+
+
+
+
+ Create a new instance of
+
+
+
+
+ Return true if it should call the original method on the object
+ instead of pass it to the message chain.
+
+ The method to call
+
+
+
+ Register a method to be called on the object directly
+
+
+
+
+ Register a property on the object that will behave as a simple property
+ Return true if there is already a value for the property
+
+
+
+
+ Check if the method was registered as a property method.
+
+
+
+
+ Do get/set on the property, according to need.
+
+
+
+
+ Do add/remove on the event
+
+
+
+
+ Get the subscribers of a spesific event
+
+
+
+
+ Gets the declaring type of the method, taking into acccount the possible generic
+ parameters that it was created with.
+
+
+
+
+ Get all the method calls arguments that were made against this object with the specificed
+ method.
+
+
+
+
+ Only method calls in replay mode are counted
+
+
+
+
+ Records the method call
+
+
+
+
+
+
+ Clears the state of the object, remove original calls, property behavior, subscribed events, etc.
+
+
+
+
+ Mocks that are tied to this mock lifestyle
+
+
+
+
+ The unique hash code of this proxy, which is not related
+ to the value of the GetHashCode() call on the object.
+
+
+
+
+ Gets the repository.
+
+
+
+
+ Gets or sets the constructor arguments.
+
+ The constructor arguments.
+
+
+
+ The mocked instance that this is representing
+
+
+
+
+ Gets the implemented types by this mocked object
+
+ The implemented.
+
+
+
+ Range for expected method calls
+
+
+
+
+ Creates a new instance.
+
+ Min.
+ Max.
+
+
+
+ Return the string representation of this range.
+
+
+
+
+ Gets or sets the min.
+
+
+
+
+
+ Gets or sets the max.
+
+
+
+
+
+ Records all the expectations for a mock and
+ return a ReplayDynamicMockState when Replay()
+ is called.
+
+
+
+
+ Creates a new instance.
+
+ Repository.
+ The proxy that generates the method calls
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Get the default call count range expectation
+
+
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Records all the expectations for a mock and
+ return a ReplayPartialMockState when Replay()
+ is called.
+
+
+
+
+ Creates a new instance.
+
+ Repository.
+ The proxy that generates the method calls
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Gets a mock state that matches the original mock state of the object.
+
+
+
+
+ Options for special repeat option
+
+
+
+
+ This method can be called only as many times as the IMethodOptions.Expect allows.
+
+
+
+
+ This method should never be called
+
+
+
+
+ This method can be call any number of times
+
+
+
+
+ This method will call the original method
+
+
+
+
+ This method will call the original method, bypassing the mocking layer
+
+
+
+
+ This method will simulate simple property behavior
+
+
+
+
+ Validate all expectations on a mock and ignores calls to
+ any method that was not setup properly.
+
+
+
+
+ Creates a new instance.
+
+ The previous state for this method
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Validate all expectations on a mock and ignores calls to
+ any method that was not setup properly.
+
+
+
+
+ Creates a new instance.
+
+ The previous state for this method
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Summary description for RhinoInterceptor.
+
+
+
+
+ Creates a new instance.
+
+
+
+
+ Intercept a method call and direct it to the repository.
+
+
+
+
+ Validate arguments for methods
+
+
+
+
+ Validate that the passed argument is not null.
+
+ The object to validate
+ The name of the argument
+
+ If the obj is null, an ArgumentNullException with the passed name
+ is thrown.
+
+
+
+
+ Validate that the arguments are equal.
+
+ Expected args.
+ Actual Args.
+
+
+
+ Validate that the two arguments are equals, including validation for
+ when the arguments are collections, in which case it will validate their values.
+
+
+
+
+ This method is safe for use even if any of the objects is a mocked object
+ that override equals.
+
+
+
+
+ Throw an object already verified when accessed
+
+
+
+
+ Create a new instance of VerifiedMockState
+
+ The previous mock state, used to get the initial record state
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Verify that this mock expectations have passed.
+
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Set the exception to throw when Verify is called.
+ This is used to report exception that may have happened but where caught in the code.
+ This way, they are reported anyway when Verify() is called.
+
+
+
+
+ not relevant
+
+
+
+
+ Gets the matching verify state for this state
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Records the actions on all the mocks created by a repository.
+
+
+
+
+ Records the specified call with the specified args on the mocked object.
+
+
+
+
+ Get the expectation for this method on this object with this arguments
+
+
+
+
+ This check the methods that were setup using the SetupResult.For()
+ or LastCall.Repeat.Any() and that bypass the whole expectation model.
+
+
+
+
+ Gets the all expectations for a mocked object and method combination,
+ regardless of the expected arguments / callbacks / contraints.
+
+ Mocked object.
+ Method.
+ List of all relevant expectation
+
+
+
+ Gets the all expectations for proxy.
+
+ Mocked object.
+ List of all relevant expectation
+
+
+
+ Removes all the repeatable expectations for proxy.
+
+ Mocked object.
+
+
+
+ Replaces the old expectation with the new expectation for the specified proxy/method pair.
+ This replace ALL expectations that equal to old expectations.
+
+ Proxy.
+ Method.
+ Old expectation.
+ New expectation.
+
+
+
+ Adds the recorder and turn it into the active recorder.
+
+ Recorder.
+
+
+
+ Moves to previous recorder.
+
+
+
+
+ Gets the recorded expectation or null.
+
+
+
+
+ Gets the next expected calls string.
+
+
+
+
+ Moves to parent recorder.
+
+
+
+
+ Set the expectation so it can repeat any number of times.
+
+
+
+
+ Removes the expectation from the recorder
+
+
+
+
+ Clear the replayer to call (and all its chain of replayers)
+ This also removes it from the list of expectations, so it will never be considered again
+
+
+
+
+ Get the expectation for this method on this object with this arguments
+
+
+
+
+ Gets a value indicating whether this instance has expectations that weren't satisfied yet.
+
+
+ true if this instance has expectations; otherwise, false.
+
+
+
+
+ Allows to set various options for the last method call on
+ a specified object.
+ If the method has a return value, it's recommended to use Expect
+
+
+
+
+ Allows to get an interface to work on the last call.
+
+ The mocked object
+ Interface that allows to set options for the last method call on this object
+
+
+
+ Set the return value for the method.
+
+ The object the method will return
+ IRepeat that defines how many times the method will return this value
+
+
+
+ Set the return value for the method. This overload is needed for LastCall.Return(null)
+
+ The object the method will return
+ IRepeat that defines how many times the method will return this value
+
+
+
+ Throws the specified exception when the method is called.
+
+ Exception to throw
+
+
+
+ Ignores the arguments for this method. Any argument will be matched
+ againt this method.
+
+
+
+
+ Add constraints for the method's arguments.
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Call the original method on the class, bypassing the mocking layers, for the last call.
+
+
+
+
+ Call the original method on the class, optionally bypassing the mocking layers, for the last call.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Gets an interface that will raise the last event when called.
+
+
+
+
+ Set the parameter values for out and ref parameters.
+ This is done using zero based indexing, and _ignoring_ any non out/ref parameter.
+
+
+
+
+ Documentation message for the expectation
+
+ Message
+
+
+
+ Use the property as a simple property, getting/setting the values without
+ causing mock expectations.
+
+
+
+
+ Better syntax to define repeats.
+
+
+
+
+ Base class for method recorders, handle delegating to inner recorder if needed.
+
+
+
+
+ List of the expected actions on for this recorder
+ The legal values are:
+ * Expectations
+ * Method Recorders
+
+
+
+
+ The current recorder.
+
+
+
+
+ The current replayer;
+
+
+
+
+ The parent recorder of this one, may be null.
+
+
+
+
+ This contains a list of all the replayers that should be ignored
+ for a spesific method call. A replayer gets into this list by calling
+ ClearReplayerToCall() on its parent. This list is Clear()ed on each new invocation.
+
+
+
+
+ All the repeatable methods calls.
+
+
+
+
+ Counts the recursion depth of the current expectation search stack
+
+
+
+
+ Creates a new instance.
+
+
+
+
+ Creates a new instance.
+
+ Parent recorder.
+ Repeatable methods
+
+
+
+ Records the specified call with the specified args on the mocked object.
+
+
+
+
+ Get the expectation for this method on this object with this arguments
+
+
+
+
+ Gets the all expectations for a mocked object and method combination,
+ regardless of the expected arguments / callbacks / contraints.
+
+ Mocked object.
+ Method.
+ List of all relevant expectation
+
+
+
+ Gets the all expectations for proxy.
+
+ Mocked object.
+ List of all relevant expectation
+
+
+
+ Replaces the old expectation with the new expectation for the specified proxy/method pair.
+ This replace ALL expectations that equal to old expectations.
+
+ Proxy.
+ Method.
+ Old expectation.
+ New expectation.
+
+
+
+ Remove the all repeatable expectations for proxy.
+
+ Mocked object.
+
+
+
+ Set the expectation so it can repeat any number of times.
+
+
+
+
+ Removes the expectation from the recorder
+
+
+
+
+ Adds the recorder and turn it into the active recorder.
+
+ Recorder.
+
+
+
+ Moves to previous recorder.
+
+
+
+
+ Moves to parent recorder.
+
+
+
+
+ Gets the recorded expectation or null.
+
+
+
+
+ Clear the replayer to call (and all its chain of replayers).
+ This also removes it from the list of expectations, so it will never be considered again
+
+
+
+
+ Get the expectation for this method on this object with this arguments
+
+
+
+
+ Gets the next expected calls string.
+
+
+
+
+ Handles the real getting of the recorded expectation or null.
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Should this replayer be considered valid for this call?
+
+
+
+
+ This check the methods that were setup using the SetupResult.For()
+ or LastCall.Repeat.Any() and that bypass the whole expectation model.
+
+
+
+
+ Gets a value indicating whether this instance has expectations that weren't satisfied yet.
+
+
+ true if this instance has expectations; otherwise, false.
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Ordered collection of methods, methods must arrive in specified order
+ in order to pass.
+
+
+
+
+ Unordered collection of method records, any expectation that exist
+ will be matched.
+
+
+
+
+ The parent recorder we have redirected to.
+ Useful for certain edge cases in orderring.
+ See: FieldProblem_Entropy for the details.
+
+
+
+
+ Creates a new instance.
+
+ Parent recorder.
+ Repeatable methods
+
+
+
+ Creates a new instance.
+
+
+
+
+ Records the specified call with the specified args on the mocked object.
+
+ Mocked object.
+ Method.
+ Expectation.
+
+
+
+ Get the expectation for this method on this object with this arguments
+
+ Invocation for this method
+ Mocked object.
+ Method.
+ Args.
+ True is the call was recorded, false otherwise
+
+
+
+ Gets the all expectations for a mocked object and method combination,
+ regardless of the expected arguments / callbacks / contraints.
+
+ Mocked object.
+ Method.
+ List of all relevant expectation
+
+
+
+ Gets the all expectations for proxy.
+
+ Mocked object.
+ List of all relevant expectation
+
+
+
+ Replaces the old expectation with the new expectation for the specified proxy/method pair.
+ This replace ALL expectations that equal to old expectations.
+
+ Proxy.
+ Method.
+ Old expectation.
+ New expectation.
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Handles the real getting of the recorded expectation or null.
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Gets the next expected calls string.
+
+
+
+
+ Create an exception for an unexpected method call.
+
+
+
+
+ Gets a value indicating whether this instance has expectations that weren't satisfied yet.
+
+
+ true if this instance has expectations; otherwise, false.
+
+
+
+
+ Creates a new instance.
+
+ Parent recorder.
+ Repetable methods
+
+
+
+ Creates a new instance.
+
+
+
+
+ Handles the real getting of the recorded expectation or null.
+
+
+
+
+ Get the expectation for this method on this object with this arguments
+
+
+
+
+ Gets the next expected calls string.
+
+
+
+
+ Hold an expectation for a method call on an object
+
+
+
+
+ Creates a new instance.
+
+ Proxy.
+ Method.
+ Expectation.
+
+
+
+ Determines if the object equal to this instance
+
+ Obj.
+
+
+
+
+ Gets the hash code.
+
+
+
+
+
+ Gets the proxy.
+
+
+
+
+
+ Gets the method.
+
+
+
+
+
+ Gets the expectation.
+
+
+
+
+
+ Holds a pair of mocked object and a method
+ and allows to compare them against each other.
+ This allows us to have a distinction between mockOne.MyMethod() and
+ mockTwo.MyMethod()...
+
+
+
+
+ Creates a new instance.
+
+ Proxy.
+ Method.
+
+
+
+ Determines whatever obj equals to this instance.
+ ProxyMethodPairs are equal when they point to the same /instance/ of
+ an object, and to the same method.
+
+ Obj.
+
+
+
+
+ Gets the hash code.
+
+
+
+
+
+ Gets the proxy.
+
+
+
+
+
+ Gets the method.
+
+
+
+
+
+ Change the recorder from ordered to unordered and vice versa
+
+
+
+
+ Creates a new instance.
+
+
+
+
+ Disposes this instance.
+
+
+
+
+ Accessor for the current mocker
+
+
+
+
+ The current mocker
+
+
+
+
+ Used for [assembly: InternalsVisibleTo(RhinoMocks.StrongName)]
+ Used for [assembly: InternalsVisibleTo(RhinoMocks.NormalName)]
+
+
+
+
+ Strong name for the Dynamic Proxy assemblies. Used for InternalsVisibleTo specification.
+
+
+
+
+ Normal name for dynamic proxy assemblies. Used for InternalsVisibleTo specification.
+
+
+
+
+ Logs all method calls for methods
+
+
+
+
+ Setup method calls to repeat any number of times.
+
+
+
+
+ Get the method options and set the last method call to repeat
+ any number of times.
+ This also means that the method would transcend ordering
+
+
+
+
+ Get the method options for the last method call on the mockInstance and set it
+ to repeat any number of times.
+ This also means that the method would transcend ordering
+
+
+
+
+ Utility class for working with method calls.
+
+
+
+
+ Return the string representation of a method call and its arguments.
+
+ The method
+ The method arguments
+ Invocation of the method, used to get the generics arguments
+ Delegate to format the parameter
+ The string representation of this method call
+
+
+
+ Return the string representation of a method call and its arguments.
+
+ The invocation of the method, used to get the generic parameters
+ The method
+ The method arguments
+ The string representation of this method call
+
+
+
+ Delegate to format the argument for the string representation of
+ the method call.
+
+
+
+
+ Utility to get the default value for a type
+
+
+
+
+ The default value for a type.
+ Null for reference types and void
+ 0 for value types.
+ First element for enums
+ Note that we need to get the value even for opened generic types, such as those from
+ generic methods.
+
+ Type.
+ The invocation.
+ the default value
+
+
+
+ Allows easier access to MockRepository, works closely with Mocker.Current to
+ allow access to a context where the mock repository is automatially verified at
+ the end of the code block.
+
+
+
+
+ Initialize a code block where Mocker.Current is initialized.
+ At the end of the code block, all the expectation will be verified.
+ This overload will create a new MockRepository.
+
+ The code that will be executed under the mock context
+
+
+
+ Initialize a code block where Mocker.Current is initialized.
+ At the end of the code block, all the expectation will be verified.
+ This overload will create a new MockRepository.
+
+ The mock repository to use, at the end of the code block, VerifyAll() will be called on the repository.
+ The code that will be executed under the mock context
+
+
+
+ Create a FluentMocker
+
+ The mock repository to use.
+
+
+
+ A method with no arguments and no return value that will be called under the mock context.
+
+
+
+
+ FluentMocker implements some kind of fluent interface attempt
+ for saying "With the Mocks [mocks], Expecting (in same order) [things] verify [that]."
+
+
+
+
+ Interface to verify previously defined expectations
+
+
+
+
+ Verifies if a piece of code
+
+
+
+
+ Defines unordered expectations
+
+ A delegate describing the expectations
+ an IMockVerifier
+
+
+
+ Defines ordered expectations
+
+ A delegate describing the expectations
+ an IMockVerifier
+
+
+
+ Verifies previously defined expectations
+
+
+
+
+ This delegate is compatible with the System.Func{T,R} signature
+ We have to define our own to get compatability with 2.0
+
+
+
+
+ This attribute is here so we can get better Pex integration
+ Using this means that Pex will not try to inspect the work of
+ the actual proxies being generated by Rhino Mocks
+
+
+
+
diff --git a/TaxCalculatorTests/bin/Debug/TaxCalculation.Domain.dll b/TaxCalculatorTests/bin/Debug/TaxCalculation.Domain.dll
new file mode 100644
index 0000000..09d7e9f
Binary files /dev/null and b/TaxCalculatorTests/bin/Debug/TaxCalculation.Domain.dll differ
diff --git a/TaxCalculatorTests/bin/Debug/TaxCalculation.Domain.pdb b/TaxCalculatorTests/bin/Debug/TaxCalculation.Domain.pdb
new file mode 100644
index 0000000..9a2a7d9
Binary files /dev/null and b/TaxCalculatorTests/bin/Debug/TaxCalculation.Domain.pdb differ
diff --git a/TaxCalculatorTests/bin/Debug/TaxCalculatorTests.dll b/TaxCalculatorTests/bin/Debug/TaxCalculatorTests.dll
new file mode 100644
index 0000000..b4816af
Binary files /dev/null and b/TaxCalculatorTests/bin/Debug/TaxCalculatorTests.dll differ
diff --git a/TaxCalculatorTests/bin/Debug/TaxCalculatorTests.pdb b/TaxCalculatorTests/bin/Debug/TaxCalculatorTests.pdb
new file mode 100644
index 0000000..a4eedd9
Binary files /dev/null and b/TaxCalculatorTests/bin/Debug/TaxCalculatorTests.pdb differ
diff --git a/TaxCalculatorTests/bin/Debug/nunit.framework.dll b/TaxCalculatorTests/bin/Debug/nunit.framework.dll
new file mode 100644
index 0000000..3e24ba1
Binary files /dev/null and b/TaxCalculatorTests/bin/Debug/nunit.framework.dll differ
diff --git a/TaxCalculatorTests/bin/Debug/nunit.framework.xml b/TaxCalculatorTests/bin/Debug/nunit.framework.xml
new file mode 100644
index 0000000..c0bd9cb
--- /dev/null
+++ b/TaxCalculatorTests/bin/Debug/nunit.framework.xml
@@ -0,0 +1,10899 @@
+
+
+
+ nunit.framework
+
+
+
+
+ Attribute used to apply a category to a test
+
+
+
+
+ The name of the category
+
+
+
+
+ Construct attribute for a given category based on
+ a name. The name may not contain the characters ',',
+ '+', '-' or '!'. However, this is not checked in the
+ constructor since it would cause an error to arise at
+ as the test was loaded without giving a clear indication
+ of where the problem is located. The error is handled
+ in NUnitFramework.cs by marking the test as not
+ runnable.
+
+ The name of the category
+
+
+
+ Protected constructor uses the Type name as the name
+ of the category.
+
+
+
+
+ The name of the category
+
+
+
+
+ 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.
+
+
+
+
+ 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.
+
+
+
+
+ Attribute used to provide descriptive text about a
+ test case or fixture.
+
+
+
+
+ Construct the attribute
+
+ Text describing the test
+
+
+
+ Gets the test description
+
+
+
+
+ Enumeration indicating how the expected message parameter is to be used
+
+
+
+ Expect an exact match
+
+
+ Expect a message containing the parameter string
+
+
+ Match the regular expression provided as a parameter
+
+
+ Expect a message that starts with the parameter string
+
+
+
+ ExpectedExceptionAttribute
+
+
+
+
+
+ Constructor for a non-specific exception
+
+
+
+
+ Constructor for a given type of exception
+
+ The type of the expected exception
+
+
+
+ Constructor for a given exception name
+
+ The full name of the expected exception
+
+
+
+ Gets or sets the expected exception type
+
+
+
+
+ Gets or sets the full Type name of the expected exception
+
+
+
+
+ Gets or sets the expected message text
+
+
+
+
+ Gets or sets the user message displayed in case of failure
+
+
+
+
+ Gets or sets the type of match to be performed on the expected message
+
+
+
+
+ Gets the name of a method to be used as an exception handler
+
+
+
+
+ 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.
+
+
+
+
+ Default constructor
+
+
+
+
+ Constructor with a reason
+
+ The reason test is marked explicit
+
+
+
+ The reason test is marked explicit
+
+
+
+
+ Attribute used to mark a test that is to be ignored.
+ Ignored tests result in a warning message when the
+ tests are run.
+
+
+
+
+ Constructs the attribute without giving a reason
+ for ignoring the test.
+
+
+
+
+ Constructs the attribute giving a reason for ignoring the test
+
+ The reason for ignoring the test
+
+
+
+ The reason for ignoring a test
+
+
+
+
+ Abstract base for Attributes that are used to include tests
+ in the test run based on environmental settings.
+
+
+
+
+ Constructor with no included items specified, for use
+ with named property syntax.
+
+
+
+
+ Constructor taking one or more included items
+
+ Comma-delimited list of included items
+
+
+
+ Name of the item that is needed in order for
+ a test to run. Multiple itemss may be given,
+ separated by a comma.
+
+
+
+
+ Name of the item to be excluded. Multiple items
+ may be given, separated by a comma.
+
+
+
+
+ The reason for including or excluding the test
+
+
+
+
+ PlatformAttribute is used to mark a test fixture or an
+ individual method as applying to a particular platform only.
+
+
+
+
+ Constructor with no platforms specified, for use
+ with named property syntax.
+
+
+
+
+ Constructor taking one or more platforms
+
+ Comma-deliminted list of platforms
+
+
+
+ CultureAttribute is used to mark a test fixture or an
+ individual method as applying to a particular Culture only.
+
+
+
+
+ Constructor with no cultures specified, for use
+ with named property syntax.
+
+
+
+
+ Constructor taking one or more cultures
+
+ Comma-deliminted list of cultures
+
+
+
+ Marks a test to use a combinatorial join of any argument data
+ provided. NUnit will create a test case for every combination of
+ the arguments provided. This can result in a large number of test
+ cases and so should be used judiciously. This is the default join
+ type, so the attribute need not be used except as documentation.
+
+
+
+
+ PropertyAttribute is used to attach information to a test as a name/value pair..
+
+
+
+
+ Construct a PropertyAttribute with a name and string value
+
+ The name of the property
+ The property value
+
+
+
+ Construct a PropertyAttribute with a name and int value
+
+ The name of the property
+ The property value
+
+
+
+ Construct a PropertyAttribute with a name and double value
+
+ The name of the property
+ The property value
+
+
+
+ Constructor for derived classes that set the
+ property dictionary directly.
+
+
+
+
+ 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.
+
+
+
+
+ Gets the property dictionary for this attribute
+
+
+
+
+ Default constructor
+
+
+
+
+ Marks a test to use pairwise join of any argument data provided.
+ NUnit will attempt too excercise every pair of argument values at
+ least once, using as small a number of test cases as it can. With
+ only two arguments, this is the same as a combinatorial join.
+
+
+
+
+ Default constructor
+
+
+
+
+ Marks a test to use a sequential join of any argument data
+ provided. NUnit will use arguements for each parameter in
+ sequence, generating test cases up to the largest number
+ of argument values provided and using null for any arguments
+ for which it runs out of values. Normally, this should be
+ used with the same number of arguments for each parameter.
+
+
+
+
+ Default constructor
+
+
+
+
+ Summary description for MaxTimeAttribute.
+
+
+
+
+ Construct a MaxTimeAttribute, given a time in milliseconds.
+
+ The maximum elapsed time in milliseconds
+
+
+
+ RandomAttribute is used to supply a set of random values
+ to a single parameter of a parameterized test.
+
+
+
+
+ ValuesAttribute is used to provide literal arguments for
+ an individual parameter of a test.
+
+
+
+
+ Abstract base class for attributes that apply to parameters
+ and supply data for the parameter.
+
+
+
+
+ Gets the data to be provided to the specified parameter
+
+
+
+
+ The collection of data to be returned. Must
+ be set by any derived attribute classes.
+ We use an object[] so that the individual
+ elements may have their type changed in GetData
+ if necessary.
+
+
+
+
+ Construct with one argument
+
+
+
+
+
+ Construct with two arguments
+
+
+
+
+
+
+ Construct with three arguments
+
+
+
+
+
+
+
+ Construct with an array of arguments
+
+
+
+
+
+ Get the collection of values to be used as arguments
+
+
+
+
+ Construct a set of doubles from 0.0 to 1.0,
+ specifying only the count.
+
+
+
+
+
+ Construct a set of doubles from min to max
+
+
+
+
+
+
+
+ Construct a set of ints from min to max
+
+
+
+
+
+
+
+ Get the collection of values to be used as arguments
+
+
+
+
+ RangeAttribute is used to supply a range of values to an
+ individual parameter of a parameterized test.
+
+
+
+
+ Construct a range of ints using default step of 1
+
+
+
+
+
+
+ Construct a range of ints specifying the step size
+
+
+
+
+
+
+
+ Construct a range of longs
+
+
+
+
+
+
+
+ Construct a range of doubles
+
+
+
+
+
+
+
+ Construct a range of floats
+
+
+
+
+
+
+
+ RepeatAttribute may be applied to test case in order
+ to run it multiple times.
+
+
+
+
+ Construct a RepeatAttribute
+
+ The number of times to run the test
+
+
+
+ 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.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The required addin.
+
+
+
+ Gets the name of required addin.
+
+ The required addin name.
+
+
+
+ Summary description for SetCultureAttribute.
+
+
+
+
+ Construct given the name of a culture
+
+
+
+
+
+ Summary description for SetUICultureAttribute.
+
+
+
+
+ Construct given the name of a culture
+
+
+
+
+
+ SetUpAttribute is used in a TestFixture to identify a method
+ that is called immediately before each test is run. It is
+ also used in a SetUpFixture to identify the method that is
+ called once, before any of the subordinate tests are run.
+
+
+
+
+ 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.
+
+
+
+
+ Attribute used to mark a static (shared in VB) property
+ that returns a list of tests.
+
+
+
+
+ Attribute used in a TestFixture to identify a method that is
+ called immediately after each test is run. It is also used
+ in a SetUpFixture to identify the method that is called once,
+ after all subordinate tests have run. In either case, the method
+ is guaranteed to be called, even if an exception is thrown.
+
+
+
+
+ Provide actions to execute before and after tests.
+
+
+
+
+ When implemented by an attribute, this interface implemented to provide actions to execute before and after tests.
+
+
+
+
+ Executed before each test is run
+
+ Provides details about the test that is going to be run.
+
+
+
+ Executed after each test is run
+
+ Provides details about the test that has just been run.
+
+
+
+ Provides the target for the action attribute
+
+ The target for the action attribute
+
+
+
+ Adding this attribute to a method within a
+ 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.
+
+
+
+ [TestFixture]
+ public class Fixture
+ {
+ [Test]
+ public void MethodToTest()
+ {}
+
+ [Test(Description = "more detailed description")]
+ publc void TestDescriptionMethod()
+ {}
+ }
+
+
+
+
+
+ Descriptive text for this test
+
+
+
+
+ TestCaseAttribute is used to mark parameterized test cases
+ and provide them with their arguments.
+
+
+
+
+ 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.
+
+
+
+
+ Gets the argument list to be provided to the test
+
+
+
+
+ Gets the expected result
+
+
+
+
+ Indicates whether a result has been specified.
+ This is necessary because the result may be
+ null, so it's value cannot be checked.
+
+
+
+
+ Gets the expected exception Type
+
+
+
+
+ Gets the FullName of the expected exception
+
+
+
+
+ Gets the name to be used for the test
+
+
+
+
+ Gets the description of the test
+
+
+
+
+ Gets a value indicating whether this is ignored.
+
+ true if ignored; otherwise, false.
+
+
+
+ Gets a value indicating whether this is explicit.
+
+ true if explicit; otherwise, false.
+
+
+
+ Gets the ignore reason.
+
+ The ignore reason.
+
+
+
+ Construct a TestCaseAttribute with a list of arguments.
+ This constructor is not CLS-Compliant
+
+
+
+
+
+ Construct a TestCaseAttribute with a single argument
+
+
+
+
+
+ Construct a TestCaseAttribute with a two arguments
+
+
+
+
+
+
+ Construct a TestCaseAttribute with a three arguments
+
+
+
+
+
+
+
+ Gets the list of arguments to a test case
+
+
+
+
+ Gets or sets the expected result. Use
+ ExpectedResult by preference.
+
+ The result.
+
+
+
+ Gets or sets the expected result.
+
+ The result.
+
+
+
+ Gets a flag indicating whether an expected
+ result has been set.
+
+
+
+
+ Gets a list of categories associated with this test;
+
+
+
+
+ Gets or sets the category associated with this test.
+ May be a single category or a comma-separated list.
+
+
+
+
+ Gets or sets the expected exception.
+
+ The expected exception.
+
+
+
+ Gets or sets the name the expected exception.
+
+ The expected name of the exception.
+
+
+
+ Gets or sets the expected message of the expected exception
+
+ The expected message of the exception.
+
+
+
+ Gets or sets the type of match to be performed on the expected message
+
+
+
+
+ Gets or sets the description.
+
+ The description.
+
+
+
+ Gets or sets the name of the test.
+
+ The name of the test.
+
+
+
+ Gets or sets the ignored status of the test
+
+
+
+
+ Gets or sets the ignored status of the test
+
+
+
+
+ Gets or sets the explicit status of the test
+
+
+
+
+ Gets or sets the reason for not running the test
+
+
+
+
+ Gets or sets the reason for not running the test.
+ Set has the side effect of marking the test as ignored.
+
+ The ignore reason.
+
+
+
+ FactoryAttribute indicates the source to be used to
+ provide test cases for a test method.
+
+
+
+
+ Construct with the name of the data source, which must
+ be a property, field or method of the test class itself.
+
+ An array of the names of the factories that will provide data
+
+
+
+ Construct with a Type, which must implement IEnumerable
+
+ The Type that will provide data
+
+
+
+ Construct with a Type and name.
+ that don't support params arrays.
+
+ The Type that will provide data
+ The name of the method, property or field that will provide data
+
+
+
+ The name of a the method, property or fiend to be used as a source
+
+
+
+
+ A Type to be used as a source
+
+
+
+
+ Gets or sets the category associated with this test.
+ May be a single category or a comma-separated list.
+
+
+
+
+ [TestFixture]
+ public class ExampleClass
+ {}
+
+
+
+
+ Default constructor
+
+
+
+
+ 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.
+
+
+
+
+
+ Descriptive text for this fixture
+
+
+
+
+ Gets and sets the category for this fixture.
+ May be a comma-separated list of categories.
+
+
+
+
+ Gets a list of categories for this fixture
+
+
+
+
+ The arguments originally provided to the attribute
+
+
+
+
+ Gets or sets a value indicating whether this should be ignored.
+
+ true if ignore; otherwise, false.
+
+
+
+ Gets or sets the ignore reason. May set Ignored as a side effect.
+
+ The ignore reason.
+
+
+
+ Get or set the type arguments. If not set
+ explicitly, any leading arguments that are
+ Types are taken as type arguments.
+
+
+
+
+ Attribute used to identify a method that is
+ called before any tests in a fixture are run.
+
+
+
+
+ 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.
+
+
+
+
+ Adding this attribute to a method within a
+ 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.
+
+
+
+ [TestFixture]
+ public class Fixture
+ {
+ [Test]
+ public void MethodToTest()
+ {}
+
+ [Test(Description = "more detailed description")]
+ publc void TestDescriptionMethod()
+ {}
+ }
+
+
+
+
+
+ Used on a method, marks the test with a timeout value in milliseconds.
+ The test will be run in a separate thread and is cancelled if the timeout
+ is exceeded. Used on a method or assembly, sets the default timeout
+ for all contained test methods.
+
+
+
+
+ Construct a TimeoutAttribute given a time in milliseconds
+
+ The timeout value in milliseconds
+
+
+
+ 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.
+
+
+
+
+ Construct a RequiresSTAAttribute
+
+
+
+
+ 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.
+
+
+
+
+ Construct a RequiresMTAAttribute
+
+
+
+
+ Marks a test that must run on a separate thread.
+
+
+
+
+ Construct a RequiresThreadAttribute
+
+
+
+
+ Construct a RequiresThreadAttribute, specifying the apartment
+
+
+
+
+ ValueSourceAttribute indicates the source to be used to
+ provide data for one parameter of a test method.
+
+
+
+
+ Construct with the name of the factory - for use with languages
+ that don't support params arrays.
+
+ The name of the data source to be used
+
+
+
+ Construct with a Type and name - for use with languages
+ that don't support params arrays.
+
+ The Type that will provide data
+ The name of the method, property or field that will provide data
+
+
+
+ The name of a the method, property or fiend to be used as a source
+
+
+
+
+ A Type to be used as a source
+
+
+
+
+ AttributeExistsConstraint tests for the presence of a
+ specified attribute on a Type.
+
+
+
+
+ The Constraint class is the base of all built-in constraints
+ within NUnit. It provides the operator overloads used to combine
+ constraints.
+
+
+
+
+ The IConstraintExpression interface is implemented by all
+ complete and resolvable constraints and expressions.
+
+
+
+
+ Return the top-level constraint for this expression
+
+
+
+
+
+ Static UnsetObject used to detect derived constraints
+ failing to set the actual value.
+
+
+
+
+ The actual value being tested against a constraint
+
+
+
+
+ The display name of this Constraint for use by ToString()
+
+
+
+
+ Argument fields used by ToString();
+
+
+
+
+ The builder holding this constraint
+
+
+
+
+ Construct a constraint with no arguments
+
+
+
+
+ Construct a constraint with one argument
+
+
+
+
+ Construct a constraint with two arguments
+
+
+
+
+ Sets the ConstraintBuilder holding this constraint
+
+
+
+
+ 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.
+
+ The MessageWriter on which to display the message
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ 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.
+
+ An ActualValueDelegate
+ True for success, false for failure
+
+
+
+ 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.
+
+ A reference to the value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ 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.
+
+ The writer on which the actual value is displayed
+
+
+
+ Default override of ToString returns the constraint DisplayName
+ followed by any arguments within angle brackets.
+
+
+
+
+
+ Returns the string representation of this constraint
+
+
+
+
+ This operator creates a constraint that is satisfied only if both
+ argument constraints are satisfied.
+
+
+
+
+ This operator creates a constraint that is satisfied if either
+ of the argument constraints is satisfied.
+
+
+
+
+ This operator creates a constraint that is satisfied if the
+ argument constraint is not satisfied.
+
+
+
+
+ Returns a DelayedConstraint with the specified delay time.
+
+ The delay in milliseconds.
+
+
+
+
+ Returns a DelayedConstraint with the specified delay time
+ and polling interval.
+
+ The delay in milliseconds.
+ The interval at which to test the constraint.
+
+
+
+
+ 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.
+
+
+
+
+ Returns a ConstraintExpression by appending And
+ to the current constraint.
+
+
+
+
+ Returns a ConstraintExpression by appending And
+ to the current constraint.
+
+
+
+
+ Returns a ConstraintExpression by appending Or
+ to the current constraint.
+
+
+
+
+ Class used to detect any derived constraints
+ that fail to set the actual value in their
+ Matches override.
+
+
+
+
+ Constructs an AttributeExistsConstraint for a specific attribute Type
+
+
+
+
+
+ Tests whether the object provides the expected attribute.
+
+ A Type, MethodInfo, or other ICustomAttributeProvider
+ True if the expected attribute is present, otherwise false
+
+
+
+ Writes the description of the constraint to the specified writer
+
+
+
+
+ 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.
+
+
+
+
+ Abstract base class used for prefixes
+
+
+
+
+ The base constraint
+
+
+
+
+ Construct given a base constraint
+
+
+
+
+
+ Constructs an AttributeConstraint for a specified attriute
+ Type and base constraint.
+
+
+
+
+
+
+ Determines whether the Type or other provider has the
+ expected attribute and if its value matches the
+ additional constraint specified.
+
+
+
+
+ Writes a description of the attribute to the specified writer.
+
+
+
+
+ Writes the actual value supplied to the specified writer.
+
+
+
+
+ Returns a string representation of the constraint.
+
+
+
+
+ BasicConstraint is the abstract base for constraints that
+ perform a simple comparison to a constant value.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected.
+ The description.
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ NullConstraint tests that the actual value is null
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ TrueConstraint tests that the actual value is true
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ FalseConstraint tests that the actual value is false
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ NaNConstraint tests that the actual value is a double or float NaN
+
+
+
+
+ Test that the actual value is an NaN
+
+
+
+
+
+
+ Write the constraint description to a specified writer
+
+
+
+
+
+ BinaryConstraint is the abstract base of all constraints
+ that combine two other constraints in some fashion.
+
+
+
+
+ The first constraint being combined
+
+
+
+
+ The second constraint being combined
+
+
+
+
+ Construct a BinaryConstraint from two other constraints
+
+ The first constraint
+ The second constraint
+
+
+
+ AndConstraint succeeds only if both members succeed.
+
+
+
+
+ Create an AndConstraint from two other constraints
+
+ The first constraint
+ The second constraint
+
+
+
+ Apply both member constraints to an actual value, succeeding
+ succeeding only if both of them succeed.
+
+ The actual value
+ True if the constraints both succeeded
+
+
+
+ Write a description for this contraint to a MessageWriter
+
+ The MessageWriter to receive the description
+
+
+
+ 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.
+
+ The writer on which the actual value is displayed
+
+
+
+ OrConstraint succeeds if either member succeeds
+
+
+
+
+ Create an OrConstraint from two other constraints
+
+ The first constraint
+ The second constraint
+
+
+
+ Apply the member constraints to an actual value, succeeding
+ succeeding as soon as one of them succeeds.
+
+ The actual value
+ True if either constraint succeeded
+
+
+
+ Write a description for this contraint to a MessageWriter
+
+ The MessageWriter to receive the description
+
+
+
+ CollectionConstraint is the abstract base class for
+ constraints that operate on collections.
+
+
+
+
+ Construct an empty CollectionConstraint
+
+
+
+
+ Construct a CollectionConstraint
+
+
+
+
+
+ Determines whether the specified enumerable is empty.
+
+ The enumerable.
+
+ true if the specified enumerable is empty; otherwise, false.
+
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Protected method to be implemented by derived classes
+
+
+
+
+
+
+ CollectionItemsEqualConstraint is the abstract base class for all
+ collection constraints that apply some notion of item equality
+ as a part of their operation.
+
+
+
+
+ Construct an empty CollectionConstraint
+
+
+
+
+ Construct a CollectionConstraint
+
+
+
+
+
+ Flag the constraint to use the supplied IComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied Comparison object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IEqualityComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IEqualityComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Compares two collection members for equality
+
+
+
+
+ Return a new CollectionTally for use in making tests
+
+ The collection to be included in the tally
+
+
+
+ Flag the constraint to ignore case and return self.
+
+
+
+
+ EmptyCollectionConstraint tests whether a collection is empty.
+
+
+
+
+ Check that the collection is empty
+
+
+
+
+
+
+ Write the constraint description to a MessageWriter
+
+
+
+
+
+ UniqueItemsConstraint tests whether all the items in a
+ collection are unique.
+
+
+
+
+ Check that all items are unique.
+
+
+
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+
+
+
+
+ CollectionContainsConstraint is used to test whether a collection
+ contains an expected object as a member.
+
+
+
+
+ Construct a CollectionContainsConstraint
+
+
+
+
+
+ Test whether the expected item is contained in the collection
+
+
+
+
+
+
+ Write a descripton of the constraint to a MessageWriter
+
+
+
+
+
+ CollectionEquivalentCOnstraint is used to determine whether two
+ collections are equivalent.
+
+
+
+
+ Construct a CollectionEquivalentConstraint
+
+
+
+
+
+ Test whether two collections are equivalent
+
+
+
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+
+
+
+
+ CollectionSubsetConstraint is used to determine whether
+ one collection is a subset of another
+
+
+
+
+ Construct a CollectionSubsetConstraint
+
+ The collection that the actual value is expected to be a subset of
+
+
+
+ Test whether the actual collection is a subset of
+ the expected collection provided.
+
+
+
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+
+
+
+
+ CollectionOrderedConstraint is used to test whether a collection is ordered.
+
+
+
+
+ Construct a CollectionOrderedConstraint
+
+
+
+
+ Modifies the constraint to use an IComparer and returns self.
+
+
+
+
+ Modifies the constraint to use an IComparer<T> and returns self.
+
+
+
+
+ Modifies the constraint to use a Comparison<T> and returns self.
+
+
+
+
+ Modifies the constraint to test ordering by the value of
+ a specified property and returns self.
+
+
+
+
+ Test whether the collection is ordered
+
+
+
+
+
+
+ Write a description of the constraint to a MessageWriter
+
+
+
+
+
+ Returns the string representation of the constraint.
+
+
+
+
+
+ If used performs a reverse comparison
+
+
+
+
+ CollectionTally counts (tallies) the number of
+ occurences of each object in one or more enumerations.
+
+
+
+
+ Construct a CollectionTally object from a comparer and a collection
+
+
+
+
+ Try to remove an object from the tally
+
+ The object to remove
+ True if successful, false if the object was not found
+
+
+
+ Try to remove a set of objects from the tally
+
+ The objects to remove
+ True if successful, false if any object was not found
+
+
+
+ The number of objects remaining in the tally
+
+
+
+
+ ComparisonAdapter class centralizes all comparisons of
+ values in NUnit, adapting to the use of any provided
+ IComparer, IComparer<T> or Comparison<T>
+
+
+
+
+ Returns a ComparisonAdapter that wraps an IComparer
+
+
+
+
+ Returns a ComparisonAdapter that wraps an IComparer<T>
+
+
+
+
+ Returns a ComparisonAdapter that wraps a Comparison<T>
+
+
+
+
+ Compares two objects
+
+
+
+
+ Gets the default ComparisonAdapter, which wraps an
+ NUnitComparer object.
+
+
+
+
+ Construct a ComparisonAdapter for an IComparer
+
+
+
+
+ Compares two objects
+
+
+
+
+
+
+
+ Construct a default ComparisonAdapter
+
+
+
+
+ ComparisonAdapter<T> extends ComparisonAdapter and
+ allows use of an IComparer<T> or Comparison<T>
+ to actually perform the comparison.
+
+
+
+
+ Construct a ComparisonAdapter for an IComparer<T>
+
+
+
+
+ Compare a Type T to an object
+
+
+
+
+ Construct a ComparisonAdapter for a Comparison<T>
+
+
+
+
+ Compare a Type T to an object
+
+
+
+
+ Abstract base class for constraints that compare values to
+ determine if one is greater than, equal to or less than
+ the other. This class supplies the Using modifiers.
+
+
+
+
+ ComparisonAdapter to be used in making the comparison
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ Modifies the constraint to use an IComparer and returns self
+
+
+
+
+ Modifies the constraint to use an IComparer<T> and returns self
+
+
+
+
+ Modifies the constraint to use a Comparison<T> and returns self
+
+
+
+
+ Delegate used to delay evaluation of the actual value
+ to be used in evaluating a constraint
+
+
+
+
+ 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.
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ Appends the specified operator to the expression by first
+ reducing the operator stack and then pushing the new
+ operator on the stack.
+
+ The operator to push.
+
+
+
+ Appends the specified constraint to the expresson by pushing
+ it on the constraint stack.
+
+ The constraint to push.
+
+
+
+ Sets the top operator right context.
+
+ The right context.
+
+
+
+ Reduces the operator stack until the topmost item
+ precedence is greater than or equal to the target precedence.
+
+ The target precedence.
+
+
+
+ Resolves this instance, returning a Constraint. If the builder
+ is not currently in a resolvable state, an exception is thrown.
+
+ The resolved constraint
+
+
+
+ Gets a value indicating whether this instance is resolvable.
+
+
+ true if this instance is resolvable; otherwise, false.
+
+
+
+
+ OperatorStack is a type-safe stack for holding ConstraintOperators
+
+
+
+
+ Initializes a new instance of the class.
+
+ The builder.
+
+
+
+ Pushes the specified operator onto the stack.
+
+ The op.
+
+
+
+ Pops the topmost operator from the stack.
+
+
+
+
+
+ Gets a value indicating whether this is empty.
+
+ true if empty; otherwise, false.
+
+
+
+ Gets the topmost operator without modifying the stack.
+
+ The top.
+
+
+
+ ConstraintStack is a type-safe stack for holding Constraints
+
+
+
+
+ Initializes a new instance of the class.
+
+ The builder.
+
+
+
+ Pushes the specified constraint. As a side effect,
+ the constraint's builder field is set to the
+ ConstraintBuilder owning this stack.
+
+ The constraint.
+
+
+
+ Pops this topmost constrait from the stack.
+ As a side effect, the constraint's builder
+ field is set to null.
+
+
+
+
+
+ Gets a value indicating whether this is empty.
+
+ true if empty; otherwise, false.
+
+
+
+ Gets the topmost constraint without modifying the stack.
+
+ The topmost constraint
+
+
+
+ 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.
+
+
+
+
+ ConstraintExpressionBase is the abstract base class for the
+ ConstraintExpression class, which represents a
+ compound constraint in the process of being constructed
+ from a series of syntactic elements.
+
+ NOTE: ConstraintExpressionBase is separate because the
+ ConstraintExpression class was generated in earlier
+ versions of NUnit. The two classes may be combined
+ in a future version.
+
+
+
+
+ The ConstraintBuilder holding the elements recognized so far
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ Initializes a new instance of the
+ class passing in a ConstraintBuilder, which may be pre-populated.
+
+ The builder.
+
+
+
+ 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.
+
+
+
+
+
+ Appends an operator to the expression and returns the
+ resulting expression itself.
+
+
+
+
+ Appends a self-resolving operator to the expression and
+ returns a new ResolvableConstraintExpression.
+
+
+
+
+ Appends a constraint to the expression and returns that
+ constraint, which is associated with the current state
+ of the expression being built.
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ Initializes a new instance of the
+ class passing in a ConstraintBuilder, which may be pre-populated.
+
+ The builder.
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding only if a specified number of them succeed.
+
+
+
+
+ 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.
+
+
+
+
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+
+
+
+
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+
+
+
+
+ Returns the constraint provided as an argument - used to allow custom
+ custom constraints to easily participate in the syntax.
+
+
+
+
+ Returns the constraint provided as an argument - used to allow custom
+ custom constraints to easily participate in the syntax.
+
+
+
+
+ Returns a constraint that tests two items for equality
+
+
+
+
+ Returns a constraint that tests that two references are the same object
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is greater than the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is less than the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is a collection containing the same elements as the
+ collection supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is a subset of the collection supplied as an argument.
+
+
+
+
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+
+
+
+
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+
+
+
+
+ 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.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the path provided
+ is the same as an expected path after canonicalization.
+
+
+
+
+ Returns a constraint that tests whether the path provided
+ is the same path or under an expected path after canonicalization.
+
+
+
+
+ Returns a constraint that tests whether the path provided
+ is the same path or under an expected path after canonicalization.
+
+
+
+
+ Returns a constraint that tests whether the actual value falls
+ within a specified range.
+
+
+
+
+ Returns a ConstraintExpression that negates any
+ following constraint.
+
+
+
+
+ Returns a ConstraintExpression that negates any
+ following constraint.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if at least one of them succeeds.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them fail.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Length property of the object being tested.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Count property of the object being tested.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Message property of the object being tested.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the InnerException property of the object being tested.
+
+
+
+
+ With is currently a NOP - reserved for future use.
+
+
+
+
+ Returns a constraint that tests for null
+
+
+
+
+ Returns a constraint that tests for True
+
+
+
+
+ Returns a constraint that tests for False
+
+
+
+
+ Returns a constraint that tests for a positive value
+
+
+
+
+ Returns a constraint that tests for a negative value
+
+
+
+
+ Returns a constraint that tests for NaN
+
+
+
+
+ Returns a constraint that tests for empty
+
+
+
+
+ Returns a constraint that tests whether a collection
+ contains all unique items.
+
+
+
+
+ Returns a constraint that tests whether an object graph is serializable in binary format.
+
+
+
+
+ Returns a constraint that tests whether an object graph is serializable in xml format.
+
+
+
+
+ Returns a constraint that tests whether a collection is ordered
+
+
+
+
+ Helper class with properties and methods that supply
+ a number of constraints used in Asserts.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding only if a specified number of them succeed.
+
+
+
+
+ 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.
+
+
+
+
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+
+
+
+
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+
+
+
+
+ Returns a constraint that tests two items for equality
+
+
+
+
+ Returns a constraint that tests that two references are the same object
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is greater than the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is less than the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is a collection containing the same elements as the
+ collection supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is a subset of the collection supplied as an argument.
+
+
+
+
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+
+
+
+
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+
+
+
+
+ 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.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that fails if the actual
+ value contains the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that fails if the actual
+ value starts with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that fails if the actual
+ value ends with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+
+
+
+
+ Returns a constraint that fails if the actual
+ value matches the pattern supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the path provided
+ is the same as an expected path after canonicalization.
+
+
+
+
+ Returns a constraint that tests whether the path provided
+ is the same path or under an expected path after canonicalization.
+
+
+
+
+ Returns a constraint that tests whether the path provided
+ is the same path or under an expected path after canonicalization.
+
+
+
+
+ Returns a constraint that tests whether the actual value falls
+ within a specified range.
+
+
+
+
+ Returns a ConstraintExpression that negates any
+ following constraint.
+
+
+
+
+ Returns a ConstraintExpression that negates any
+ following constraint.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if at least one of them succeeds.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them fail.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Length property of the object being tested.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Count property of the object being tested.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Message property of the object being tested.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the InnerException property of the object being tested.
+
+
+
+
+ Returns a constraint that tests for null
+
+
+
+
+ Returns a constraint that tests for True
+
+
+
+
+ Returns a constraint that tests for False
+
+
+
+
+ Returns a constraint that tests for a positive value
+
+
+
+
+ Returns a constraint that tests for a negative value
+
+
+
+
+ Returns a constraint that tests for NaN
+
+
+
+
+ Returns a constraint that tests for empty
+
+
+
+
+ Returns a constraint that tests whether a collection
+ contains all unique items.
+
+
+
+
+ Returns a constraint that tests whether an object graph is serializable in binary format.
+
+
+
+
+ Returns a constraint that tests whether an object graph is serializable in xml format.
+
+
+
+
+ Returns a constraint that tests whether a collection is ordered
+
+
+
+
+ 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.
+
+
+
+
+ The precedence value used when the operator
+ is about to be pushed to the stack.
+
+
+
+
+ The precedence value used when the operator
+ is on the top of the stack.
+
+
+
+
+ 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.
+
+
+
+
+
+ The syntax element preceding this operator
+
+
+
+
+ The syntax element folowing this operator
+
+
+
+
+ The precedence value used when the operator
+ is about to be pushed to the stack.
+
+
+
+
+ The precedence value used when the operator
+ is on the top of the stack.
+
+
+
+
+ PrefixOperator takes a single constraint and modifies
+ it's action in some way.
+
+
+
+
+ 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.
+
+
+
+
+
+ Returns the constraint created by applying this
+ prefix to another constraint.
+
+
+
+
+
+
+ Negates the test of the constraint it wraps.
+
+
+
+
+ Constructs a new NotOperator
+
+
+
+
+ Returns a NotConstraint applied to its argument.
+
+
+
+
+ Abstract base for operators that indicate how to
+ apply a constraint to items in a collection.
+
+
+
+
+ Constructs a CollectionOperator
+
+
+
+
+ Represents a constraint that succeeds if all the
+ members of a collection match a base constraint.
+
+
+
+
+ Returns a constraint that will apply the argument
+ to the members of a collection, succeeding if
+ they all succeed.
+
+
+
+
+ Represents a constraint that succeeds if any of the
+ members of a collection match a base constraint.
+
+
+
+
+ Returns a constraint that will apply the argument
+ to the members of a collection, succeeding if
+ any of them succeed.
+
+
+
+
+ Represents a constraint that succeeds if none of the
+ members of a collection match a base constraint.
+
+
+
+
+ Returns a constraint that will apply the argument
+ to the members of a collection, succeeding if
+ none of them succeed.
+
+
+
+
+ Represents a constraint that succeeds if the specified
+ count of members of a collection match a base constraint.
+
+
+
+
+ Construct an ExactCountOperator for a specified count
+
+ The expected count
+
+
+
+ Returns a constraint that will apply the argument
+ to the members of a collection, succeeding if
+ none of them succeed.
+
+
+
+
+ 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.
+
+
+
+
+ Constructor for the WithOperator
+
+
+
+
+ Returns a constraint that wraps its argument
+
+
+
+
+ Abstract base class for operators that are able to reduce to a
+ constraint whether or not another syntactic element follows.
+
+
+
+
+ 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.
+
+
+
+
+ Constructs a PropOperator for a particular named property
+
+
+
+
+ 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.
+
+
+
+
+
+ Gets the name of the property to which the operator applies
+
+
+
+
+ Operator that tests for the presence of a particular attribute
+ on a type and optionally applies further tests to the attribute.
+
+
+
+
+ Construct an AttributeOperator for a particular Type
+
+ The Type of attribute tested
+
+
+
+ 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.
+
+
+
+
+ Operator that tests that an exception is thrown and
+ optionally applies further tests to the exception.
+
+
+
+
+ Construct a ThrowsOperator
+
+
+
+
+ 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.
+
+
+
+
+ Abstract base class for all binary operators
+
+
+
+
+ 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.
+
+
+
+
+
+ Abstract method that produces a constraint by applying
+ the operator to its left and right constraint arguments.
+
+
+
+
+ Gets the left precedence of the operator
+
+
+
+
+ Gets the right precedence of the operator
+
+
+
+
+ Operator that requires both it's arguments to succeed
+
+
+
+
+ Construct an AndOperator
+
+
+
+
+ Apply the operator to produce an AndConstraint
+
+
+
+
+ Operator that requires at least one of it's arguments to succeed
+
+
+
+
+ Construct an OrOperator
+
+
+
+
+ Apply the operator to produce an OrConstraint
+
+
+
+
+ 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.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected.
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ Flag the constraint to use the supplied IComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied Comparison object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IEqualityComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IEqualityComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to ignore case and return self.
+
+
+
+
+ Applies a delay to the match so that a match can be evaluated in the future.
+
+
+
+
+ Creates a new DelayedConstraint
+
+ The inner constraint two decorate
+ The time interval after which the match is performed
+ If the value of is less than 0
+
+
+
+ Creates a new DelayedConstraint
+
+ The inner constraint two decorate
+ The time interval after which the match is performed
+ The time interval used for polling
+ If the value of is less than 0
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for if the base constraint fails, false if it succeeds
+
+
+
+ Test whether the constraint is satisfied by a delegate
+
+ The delegate whose value is to be tested
+ True for if the base constraint fails, false if it succeeds
+
+
+
+ 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.
+
+ A reference to the value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ Write the actual value for a failing constraint test to a MessageWriter.
+
+ The writer on which the actual value is displayed
+
+
+
+ Returns the string representation of the constraint.
+
+
+
+
+ EmptyDirectoryConstraint is used to test that a directory is empty
+
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ 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.
+
+ The writer on which the actual value is displayed
+
+
+
+ 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.
+
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ 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.
+
+
+
+
+ If true, strings in error messages will be clipped
+
+
+
+
+ NUnitEqualityComparer used to test equality.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected value.
+
+
+
+ Flag the constraint to use a tolerance when determining equality.
+
+ Tolerance value to be used
+ Self.
+
+
+
+ Flag the constraint to use the supplied IComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied Comparison object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IEqualityComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IEqualityComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write a failure message. Overridden to provide custom
+ failure messages for EqualConstraint.
+
+ The MessageWriter to write to
+
+
+
+ Write description of this constraint
+
+ The MessageWriter to write to
+
+
+
+ Display the failure information for two collections that did not match.
+
+ The MessageWriter on which to display
+ The expected collection.
+ The actual collection
+ The depth of this failure in a set of nested collections
+
+
+
+ Displays a single line showing the types and sizes of the expected
+ and actual enumerations, collections or arrays. If both are identical,
+ the value is only shown once.
+
+ The MessageWriter on which to display
+ The expected collection or array
+ The actual collection or array
+ The indentation level for the message line
+
+
+
+ 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.
+
+ The MessageWriter on which to display
+ The expected array
+ The actual array
+ Index of the failure point in the underlying collections
+ The indentation level for the message line
+
+
+
+ Display the failure information for two IEnumerables that did not match.
+
+ The MessageWriter on which to display
+ The expected enumeration.
+ The actual enumeration
+ The depth of this failure in a set of nested collections
+
+
+
+ Flag the constraint to ignore case and return self.
+
+
+
+
+ Flag the constraint to suppress string clipping
+ and return self.
+
+
+
+
+ Flag the constraint to compare arrays as collections
+ and return self.
+
+
+
+
+ Switches the .Within() modifier to interpret its tolerance as
+ a distance in representable values (see remarks).
+
+ Self.
+
+ 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.
+
+
+
+
+ Switches the .Within() modifier to interpret its tolerance as
+ a percentage that the actual values is allowed to deviate from
+ the expected value.
+
+ Self
+
+
+
+ Causes the tolerance to be interpreted as a TimeSpan in days.
+
+ Self
+
+
+
+ Causes the tolerance to be interpreted as a TimeSpan in hours.
+
+ Self
+
+
+
+ Causes the tolerance to be interpreted as a TimeSpan in minutes.
+
+ Self
+
+
+
+ Causes the tolerance to be interpreted as a TimeSpan in seconds.
+
+ Self
+
+
+
+ Causes the tolerance to be interpreted as a TimeSpan in milliseconds.
+
+ Self
+
+
+
+ Causes the tolerance to be interpreted as a TimeSpan in clock ticks.
+
+ Self
+
+
+
+ EqualityAdapter class handles all equality comparisons
+ that use an IEqualityComparer, IEqualityComparer<T>
+ or a ComparisonAdapter.
+
+
+
+
+ Compares two objects, returning true if they are equal
+
+
+
+
+ Returns true if the two objects can be compared by this adapter.
+ The base adapter cannot handle IEnumerables except for strings.
+
+
+
+
+ Returns an EqualityAdapter that wraps an IComparer.
+
+
+
+
+ Returns an EqualityAdapter that wraps an IEqualityComparer.
+
+
+
+
+ Returns an EqualityAdapter that wraps an IEqualityComparer<T>.
+
+
+
+
+ Returns an EqualityAdapter that wraps an IComparer<T>.
+
+
+
+
+ Returns an EqualityAdapter that wraps a Comparison<T>.
+
+
+
+
+ EqualityAdapter that wraps an IComparer.
+
+
+
+
+ Returns true if the two objects can be compared by this adapter.
+ Generic adapter requires objects of the specified type.
+
+
+
+
+ EqualityAdapter that wraps an IComparer.
+
+
+
+ Helper routines for working with floating point numbers
+
+
+ The floating point comparison code is based on this excellent article:
+ http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm
+
+
+ "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.
+
+
+ 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.
+
+
+
+
+ Compares two floating point values for equality
+ First floating point value to be compared
+ Second floating point value t be compared
+
+ Maximum number of representable floating point values that are allowed to
+ be between the left and the right floating point values
+
+ True if both numbers are equal or close to being equal
+
+
+ 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.
+
+
+ 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.
+
+
+ Implementation partially follows the code outlined here:
+ http://www.anttirt.net/2007/08/19/proper-floating-point-comparisons/
+
+
+
+
+ Compares two double precision floating point values for equality
+ First double precision floating point value to be compared
+ Second double precision floating point value t be compared
+
+ 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
+
+ True if both numbers are equal or close to being equal
+
+
+ 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.
+
+
+ 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.
+
+
+ Implementation partially follows the code outlined here:
+ http://www.anttirt.net/2007/08/19/proper-floating-point-comparisons/
+
+
+
+
+
+ Reinterprets the memory contents of a floating point value as an integer value
+
+
+ Floating point value whose memory contents to reinterpret
+
+
+ The memory contents of the floating point value interpreted as an integer
+
+
+
+
+ Reinterprets the memory contents of a double precision floating point
+ value as an integer value
+
+
+ Double precision floating point value whose memory contents to reinterpret
+
+
+ The memory contents of the double precision floating point value
+ interpreted as an integer
+
+
+
+
+ Reinterprets the memory contents of an integer as a floating point value
+
+ Integer value whose memory contents to reinterpret
+
+ The memory contents of the integer value interpreted as a floating point value
+
+
+
+
+ Reinterprets the memory contents of an integer value as a double precision
+ floating point value
+
+ Integer whose memory contents to reinterpret
+
+ The memory contents of the integer interpreted as a double precision
+ floating point value
+
+
+
+ Union of a floating point variable and an integer
+
+
+ The union's value as a floating point variable
+
+
+ The union's value as an integer
+
+
+ The union's value as an unsigned integer
+
+
+ Union of a double precision floating point variable and a long
+
+
+ The union's value as a double precision floating point variable
+
+
+ The union's value as a long
+
+
+ The union's value as an unsigned long
+
+
+
+ Tests whether a value is greater than the value supplied to its constructor
+
+
+
+
+ The value against which a comparison is to be made
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected value.
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Tests whether a value is greater than or equal to the value supplied to its constructor
+
+
+
+
+ The value against which a comparison is to be made
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected value.
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Tests whether a value is less than the value supplied to its constructor
+
+
+
+
+ The value against which a comparison is to be made
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected value.
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Tests whether a value is less than or equal to the value supplied to its constructor
+
+
+
+
+ The value against which a comparison is to be made
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected value.
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ 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.
+
+
+
+
+ Construct a MessageWriter given a culture
+
+
+
+
+ Method to write single line message with optional args, usually
+ written to precede the general failure message.
+
+ The message to be written
+ Any arguments used in formatting the message
+
+
+
+ Method to write single line message with optional args, usually
+ written to precede the general failure message, at a givel
+ indentation level.
+
+ The indentation level of the message
+ The message to be written
+ Any arguments used in formatting the message
+
+
+
+ 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.
+
+ The constraint that failed
+
+
+
+ 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.
+
+ The expected value
+ The actual value causing the failure
+
+
+
+ Display Expected and Actual lines for given values, including
+ a tolerance value on the Expected line.
+
+ The expected value
+ The actual value causing the failure
+ The tolerance within which the test was made
+
+
+
+ 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.
+
+ The expected string value
+ The actual string value
+ The point at which the strings don't match or -1
+ If true, case is ignored in locating the point where the strings differ
+ If true, the strings should be clipped to fit the line
+
+
+
+ Writes the text for a connector.
+
+ The connector.
+
+
+
+ Writes the text for a predicate.
+
+ The predicate.
+
+
+
+ Writes the text for an expected value.
+
+ The expected value.
+
+
+
+ Writes the text for a modifier
+
+ The modifier.
+
+
+
+ Writes the text for an actual value.
+
+ The actual value.
+
+
+
+ Writes the text for a generalized value.
+
+ The value.
+
+
+
+ Writes the text for a collection value,
+ starting at a particular point, to a max length
+
+ The collection containing elements to write.
+ The starting point of the elements to write
+ The maximum number of elements to write
+
+
+
+ Abstract method to get the max line length
+
+
+
+
+ Static methods used in creating messages
+
+
+
+
+ Static string used when strings are clipped
+
+
+
+
+ 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.
+
+
+
+
+
+
+ Converts any control characters in a string
+ to their escaped representation.
+
+ The string to be converted
+ The converted string
+
+
+
+ Return the a string representation for a set of indices into an array
+
+ Array of indices for which a string is needed
+
+
+
+ Get an array of indices representing the point in a enumerable,
+ collection or array corresponding to a single int index into the
+ collection.
+
+ The collection to which the indices apply
+ Index in the collection
+ Array of indices
+
+
+
+ Clip a string to a given length, starting at a particular offset, returning the clipped
+ string with ellipses representing the removed parts
+
+ The string to be clipped
+ The maximum permitted length of the result string
+ The point at which to start clipping
+ The clipped string
+
+
+
+ Clip the expected and actual strings in a coordinated fashion,
+ so that they may be displayed together.
+
+
+
+
+
+
+
+
+ Shows the position two strings start to differ. Comparison
+ starts at the start index.
+
+ The expected string
+ The actual string
+ The index in the strings at which comparison should start
+ Boolean indicating whether case should be ignored
+ -1 if no mismatch found, or the index where mismatch found
+
+
+
+ The Numerics class contains common operations on numeric values.
+
+
+
+
+ Checks the type of the object, returning true if
+ the object is a numeric type.
+
+ The object to check
+ true if the object is a numeric type
+
+
+
+ Checks the type of the object, returning true if
+ the object is a floating point numeric type.
+
+ The object to check
+ true if the object is a floating point numeric type
+
+
+
+ Checks the type of the object, returning true if
+ the object is a fixed point numeric type.
+
+ The object to check
+ true if the object is a fixed point numeric type
+
+
+
+ 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.
+
+ The expected value
+ The actual value
+ A reference to the tolerance in effect
+ True if the values are equal
+
+
+
+ Compare two numeric values, performing the usual numeric conversions.
+
+ The expected value
+ The actual value
+ The relationship of the values to each other
+
+
+
+ NUnitComparer encapsulates NUnit's default behavior
+ in comparing two objects.
+
+
+
+
+ Compares two objects
+
+
+
+
+
+
+
+ Returns the default NUnitComparer.
+
+
+
+
+ Generic version of NUnitComparer
+
+
+
+
+
+ Compare two objects of the same type
+
+
+
+
+ NUnitEqualityComparer encapsulates NUnit's handling of
+ equality tests between objects.
+
+
+
+
+
+
+
+
+
+ Compares two objects for equality within a tolerance
+
+ The first object to compare
+ The second object to compare
+ The tolerance to use in the comparison
+
+
+
+
+ If true, all string comparisons will ignore case
+
+
+
+
+ If true, arrays will be treated as collections, allowing
+ those of different dimensions to be compared
+
+
+
+
+ Comparison objects used in comparisons for some constraints.
+
+
+
+
+ Compares two objects for equality within a tolerance.
+
+
+
+
+ Helper method to compare two arrays
+
+
+
+
+ Method to compare two DirectoryInfo objects
+
+ first directory to compare
+ second directory to compare
+ true if equivalent, false if not
+
+
+
+ Returns the default NUnitEqualityComparer
+
+
+
+
+ Gets and sets a flag indicating whether case should
+ be ignored in determining equality.
+
+
+
+
+ Gets and sets a flag indicating that arrays should be
+ compared as collections, without regard to their shape.
+
+
+
+
+ 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.
+
+
+
+
+ Gets the list of failure points for the last Match performed.
+
+
+
+
+ FailurePoint class represents one point of failure
+ in an equality test.
+
+
+
+
+ The location of the failure
+
+
+
+
+ The expected value
+
+
+
+
+ The actual value
+
+
+
+
+ Indicates whether the expected value is valid
+
+
+
+
+ Indicates whether the actual value is valid
+
+
+
+
+ PathConstraint serves as the abstract base of constraints
+ that operate on paths and provides several helper methods.
+
+
+
+
+ The expected path used in the constraint
+
+
+
+
+ The actual path being tested
+
+
+
+
+ Flag indicating whether a caseInsensitive comparison should be made
+
+
+
+
+ Construct a PathConstraint for a give expected path
+
+ The expected path
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Returns true if the expected path and actual path match
+
+
+
+
+ Returns the string representation of this constraint
+
+
+
+
+ Canonicalize the provided path
+
+
+ The path in standardized form
+
+
+
+ Test whether two paths are the same
+
+ The first path
+ The second path
+ Indicates whether case should be ignored
+
+
+
+
+ Test whether one path is under another path
+
+ The first path - supposed to be the parent path
+ The second path - supposed to be the child path
+ Indicates whether case should be ignored
+
+
+
+
+ Test whether one path is the same as or under another path
+
+ The first path - supposed to be the parent path
+ The second path - supposed to be the child path
+
+
+
+
+ Modifies the current instance to be case-insensitve
+ and returns it.
+
+
+
+
+ Modifies the current instance to be case-sensitve
+ and returns it.
+
+
+
+
+ Summary description for SamePathConstraint.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected path
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The expected path
+ The actual path
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ SubPathConstraint tests that the actual path is under the expected path
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected path
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The expected path
+ The actual path
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ SamePathOrUnderConstraint tests that one path is under another
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected path
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The expected path
+ The actual path
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ Predicate constraint wraps a Predicate in a constraint,
+ returning success if the predicate is true.
+
+
+
+
+ Construct a PredicateConstraint from a predicate
+
+
+
+
+ Determines whether the predicate succeeds when applied
+ to the actual value.
+
+
+
+
+ Writes the description to a MessageWriter
+
+
+
+
+ NotConstraint negates the effect of some other constraint
+
+
+
+
+ Initializes a new instance of the class.
+
+ The base constraint to be negated.
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for if the base constraint fails, false if it succeeds
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ Write the actual value for a failing constraint test to a MessageWriter.
+
+ The writer on which the actual value is displayed
+
+
+
+ AllItemsConstraint applies another constraint to each
+ item in a collection, succeeding if they all succeed.
+
+
+
+
+ Construct an AllItemsConstraint on top of an existing constraint
+
+
+
+
+
+ Apply the item constraint to each item in the collection,
+ failing if any item fails.
+
+
+
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+
+
+
+
+ SomeItemsConstraint applies another constraint to each
+ item in a collection, succeeding if any of them succeeds.
+
+
+
+
+ Construct a SomeItemsConstraint on top of an existing constraint
+
+
+
+
+
+ Apply the item constraint to each item in the collection,
+ succeeding if any item succeeds.
+
+
+
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+
+
+
+
+ NoItemConstraint applies another constraint to each
+ item in a collection, failing if any of them succeeds.
+
+
+
+
+ Construct a NoItemConstraint on top of an existing constraint
+
+
+
+
+
+ Apply the item constraint to each item in the collection,
+ failing if any item fails.
+
+
+
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+
+
+
+
+ ExactCoutConstraint applies another constraint to each
+ item in a collection, succeeding only if a specified
+ number of items succeed.
+
+
+
+
+ Construct an ExactCountConstraint on top of an existing constraint
+
+
+
+
+
+
+ Apply the item constraint to each item in the collection,
+ succeeding only if the expected number of items pass.
+
+
+
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+
+
+
+
+ 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.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The name of the property.
+
+
+
+ Test whether the property exists for a given object
+
+ The object to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ Write the actual value for a failing constraint test to a
+ MessageWriter.
+
+ The writer on which the actual value is displayed
+
+
+
+ Returns the string representation of the constraint.
+
+
+
+
+
+ PropertyConstraint extracts a named property and uses
+ its value as the actual value for a chained constraint.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The name.
+ The constraint to apply to the property.
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ 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.
+
+ The writer on which the actual value is displayed
+
+
+
+ Returns the string representation of the constraint.
+
+
+
+
+
+ RangeConstraint tests whethe two values are within a
+ specified range.
+
+
+
+
+ Initializes a new instance of the class.
+
+ From.
+ To.
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ 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.
+
+
+
+
+ Create a new instance of ResolvableConstraintExpression
+
+
+
+
+ Create a new instance of ResolvableConstraintExpression,
+ passing in a pre-populated ConstraintBuilder.
+
+
+
+
+ Resolve the current expression to a Constraint
+
+
+
+
+ This operator creates a constraint that is satisfied only if both
+ argument constraints are satisfied.
+
+
+
+
+ This operator creates a constraint that is satisfied only if both
+ argument constraints are satisfied.
+
+
+
+
+ This operator creates a constraint that is satisfied only if both
+ argument constraints are satisfied.
+
+
+
+
+ This operator creates a constraint that is satisfied if either
+ of the argument constraints is satisfied.
+
+
+
+
+ This operator creates a constraint that is satisfied if either
+ of the argument constraints is satisfied.
+
+
+
+
+ This operator creates a constraint that is satisfied if either
+ of the argument constraints is satisfied.
+
+
+
+
+ This operator creates a constraint that is satisfied if the
+ argument constraint is not satisfied.
+
+
+
+
+ Appends an And Operator to the expression
+
+
+
+
+ Appends an Or operator to the expression.
+
+
+
+
+ ReusableConstraint wraps a resolved constraint so that it
+ may be saved and reused as needed.
+
+
+
+
+ Construct a ReusableConstraint
+
+ The constraint or expression to be reused
+
+
+
+ Conversion operator from a normal constraint to a ReusableConstraint.
+
+ The original constraint to be wrapped as a ReusableConstraint
+
+
+
+
+ Returns the string representation of the constraint.
+
+ A string representing the constraint
+
+
+
+ Resolves the ReusableConstraint by returning the constraint
+ that it originally wrapped.
+
+ A resolved constraint
+
+
+
+ SameAsConstraint tests whether an object is identical to
+ the object passed to its constructor
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected object.
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ BinarySerializableConstraint tests whether
+ an object is serializable in binary format.
+
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ 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.
+
+ The writer on which the actual value is displayed
+
+
+
+ Returns the string representation
+
+
+
+
+ BinarySerializableConstraint tests whether
+ an object is serializable in binary format.
+
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ 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.
+
+ The writer on which the actual value is displayed
+
+
+
+ Returns the string representation of this constraint
+
+
+
+
+ StringConstraint is the abstract base for constraints
+ that operate on strings. It supports the IgnoreCase
+ modifier for string operations.
+
+
+
+
+ The expected value
+
+
+
+
+ Indicates whether tests should be case-insensitive
+
+
+
+
+ Constructs a StringConstraint given an expected value
+
+ The expected value
+
+
+
+ Modify the constraint to ignore case in matching.
+
+
+
+
+ EmptyStringConstraint tests whether a string is empty.
+
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ NullEmptyStringConstraint tests whether a string is either null or empty.
+
+
+
+
+ Constructs a new NullOrEmptyStringConstraint
+
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ SubstringConstraint can test whether a string contains
+ the expected substring.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected.
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ StartsWithConstraint can test whether a string starts
+ with an expected substring.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected string
+
+
+
+ Test whether the constraint is matched by the actual value.
+ This is a template method, which calls the IsMatch method
+ of the derived class.
+
+
+
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ EndsWithConstraint can test whether a string ends
+ with an expected substring.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected string
+
+
+
+ Test whether the constraint is matched by the actual value.
+ This is a template method, which calls the IsMatch method
+ of the derived class.
+
+
+
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ RegexConstraint can test whether a string matches
+ the pattern provided.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The pattern.
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ ThrowsConstraint is used to test the exception thrown by
+ a delegate by applying a constraint to it.
+
+
+
+
+ Initializes a new instance of the class,
+ using a constraint to be applied to the exception.
+
+ A constraint to apply to the caught exception.
+
+
+
+ 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.
+
+ A delegate representing the code to be tested
+ True if an exception is thrown and the constraint succeeds, otherwise false
+
+
+
+ Converts an ActualValueDelegate to a TestDelegate
+ before calling the primary overload.
+
+
+
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ 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.
+
+ The writer on which the actual value is displayed
+
+
+
+ Returns the string representation of this constraint
+
+
+
+
+ Get the actual exception thrown - used by Assert.Throws.
+
+
+
+
+ ThrowsNothingConstraint tests that a delegate does not
+ throw an exception.
+
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True if no exception is thrown, otherwise false
+
+
+
+ Converts an ActualValueDelegate to a TestDelegate
+ before calling the primary overload.
+
+
+
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ 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.
+
+ The writer on which the actual value is displayed
+
+
+
+ Modes in which the tolerance value for a comparison can
+ be interpreted.
+
+
+
+
+ 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.
+
+
+
+
+ The tolerance is used as a numeric range within which
+ two compared values are considered to be equal.
+
+
+
+
+ Interprets the tolerance as the percentage by which
+ the two compared values my deviate from each other.
+
+
+
+
+ Compares two values based in their distance in
+ representable numbers.
+
+
+
+
+ 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.
+
+
+
+
+ Constructs a linear tolerance of a specdified amount
+
+
+
+
+ Constructs a tolerance given an amount and ToleranceMode
+
+
+
+
+ Tests that the current Tolerance is linear with a
+ numeric value, throwing an exception if it is not.
+
+
+
+
+ Returns an empty Tolerance object, equivalent to
+ specifying no tolerance. In most cases, it results
+ in an exact match but for floats and doubles a
+ default tolerance may be used.
+
+
+
+
+ Returns a zero Tolerance object, equivalent to
+ specifying an exact match.
+
+
+
+
+ Gets the ToleranceMode for the current Tolerance
+
+
+
+
+ Gets the value of the current Tolerance instance.
+
+
+
+
+ Returns a new tolerance, using the current amount as a percentage.
+
+
+
+
+ Returns a new tolerance, using the current amount in Ulps.
+
+
+
+
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of days.
+
+
+
+
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of hours.
+
+
+
+
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of minutes.
+
+
+
+
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of seconds.
+
+
+
+
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of milliseconds.
+
+
+
+
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of clock ticks.
+
+
+
+
+ Returns true if the current tolerance is empty.
+
+
+
+
+ TypeConstraint is the abstract base for constraints
+ that take a Type as their expected value.
+
+
+
+
+ The expected Type used by the constraint
+
+
+
+
+ Construct a TypeConstraint for a given Type
+
+
+
+
+
+ Write the actual value for a failing constraint test to a
+ MessageWriter. TypeConstraints override this method to write
+ the name of the type.
+
+ The writer on which the actual value is displayed
+
+
+
+ ExactTypeConstraint is used to test that an object
+ is of the exact type provided in the constructor
+
+
+
+
+ Construct an ExactTypeConstraint for a given Type
+
+ The expected Type.
+
+
+
+ Test that an object is of the exact type specified
+
+ The actual value.
+ True if the tested object is of the exact type provided, otherwise false.
+
+
+
+ Write the description of this constraint to a MessageWriter
+
+ The MessageWriter to use
+
+
+
+ ExceptionTypeConstraint is a special version of ExactTypeConstraint
+ used to provided detailed info about the exception thrown in
+ an error message.
+
+
+
+
+ Constructs an ExceptionTypeConstraint
+
+
+
+
+ Write the actual value for a failing constraint test to a
+ MessageWriter. Overriden to write additional information
+ in the case of an Exception.
+
+ The MessageWriter to use
+
+
+
+ InstanceOfTypeConstraint is used to test that an object
+ is of the same type provided or derived from it.
+
+
+
+
+ Construct an InstanceOfTypeConstraint for the type provided
+
+ The expected Type
+
+
+
+ Test whether an object is of the specified type or a derived type
+
+ The object to be tested
+ True if the object is of the provided type or derives from it, otherwise false.
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+ The MessageWriter to use
+
+
+
+ AssignableFromConstraint is used to test that an object
+ can be assigned from a given Type.
+
+
+
+
+ Construct an AssignableFromConstraint for the type provided
+
+
+
+
+
+ Test whether an object can be assigned from the specified type
+
+ The object to be tested
+ True if the object can be assigned a value of the expected Type, otherwise false.
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+ The MessageWriter to use
+
+
+
+ AssignableToConstraint is used to test that an object
+ can be assigned to a given Type.
+
+
+
+
+ Construct an AssignableToConstraint for the type provided
+
+
+
+
+
+ Test whether an object can be assigned to the specified type
+
+ The object to be tested
+ True if the object can be assigned a value of the expected Type, otherwise false.
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+ The MessageWriter to use
+
+
+
+ Thrown when an assertion failed.
+
+
+
+
+ The error message that explains
+ the reason for the exception
+
+
+ The error message that explains
+ the reason for the exception
+ The exception that caused the
+ current exception
+
+
+
+ Serialization Constructor
+
+
+
+
+ Thrown when an assertion failed.
+
+
+
+
+
+
+ The error message that explains
+ the reason for the exception
+ The exception that caused the
+ current exception
+
+
+
+ Serialization Constructor
+
+
+
+
+ Thrown when a test executes inconclusively.
+
+
+
+
+ The error message that explains
+ the reason for the exception
+
+
+ The error message that explains
+ the reason for the exception
+ The exception that caused the
+ current exception
+
+
+
+ Serialization Constructor
+
+
+
+
+ Thrown when an assertion failed.
+
+
+
+
+
+
+ The error message that explains
+ the reason for the exception
+ The exception that caused the
+ current exception
+
+
+
+ Serialization Constructor
+
+
+
+
+
+
+
+
+
+
+ Compares two objects of a given Type for equality within a tolerance
+
+ The first object to compare
+ The second object to compare
+ The tolerance to use in the comparison
+
+
+
+
+ The different targets a test action attribute can be applied to
+
+
+
+
+ Default target, which is determined by where the action attribute is attached
+
+
+
+
+ Target a individual test case
+
+
+
+
+ Target a suite of test cases
+
+
+
+
+ Delegate used by tests that execute code and
+ capture any thrown exception.
+
+
+
+
+ The Assert class contains a collection of static methods that
+ implement the most common assertions used in NUnit.
+
+
+
+
+ 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.
+
+
+
+
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+
+
+
+
+
+
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+
+
+
+
+
+
+ Helper for Assert.AreEqual(double expected, double actual, ...)
+ allowing code generation to work consistently.
+
+ The expected value
+ The actual value
+ The maximum acceptable difference between the
+ the expected and the actual
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Throws a 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.
+
+ The message to initialize the with.
+ Arguments to be used in formatting the message
+
+
+
+ Throws a 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.
+
+ The message to initialize the with.
+
+
+
+ Throws a 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.
+
+
+
+
+ Throws an with the message and arguments
+ that are passed in. This is used by the other Assert functions.
+
+ The message to initialize the with.
+ Arguments to be used in formatting the message
+
+
+
+ Throws an with the message that is
+ passed in. This is used by the other Assert functions.
+
+ The message to initialize the with.
+
+
+
+ Throws an .
+ This is used by the other Assert functions.
+
+
+
+
+ Throws an with the message and arguments
+ that are passed in. This causes the test to be reported as ignored.
+
+ The message to initialize the with.
+ Arguments to be used in formatting the message
+
+
+
+ Throws an with the message that is
+ passed in. This causes the test to be reported as ignored.
+
+ The message to initialize the with.
+
+
+
+ Throws an .
+ This causes the test to be reported as ignored.
+
+
+
+
+ Throws an with the message and arguments
+ that are passed in. This causes the test to be reported as inconclusive.
+
+ The message to initialize the with.
+ Arguments to be used in formatting the message
+
+
+
+ Throws an with the message that is
+ passed in. This causes the test to be reported as inconclusive.
+
+ The message to initialize the with.
+
+
+
+ Throws an .
+ This causes the test to be reported as Inconclusive.
+
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint to be applied
+ The actual value to test
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint to be applied
+ The actual value to test
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint expression to be applied
+ The actual value to test
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint expression to be applied
+ An ActualValueDelegate returning the value to be tested
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint expression to be applied
+ An ActualValueDelegate returning the value to be tested
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ An ActualValueDelegate returning the value to be tested
+ A Constraint expression to be applied
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint to be applied
+ The actual value to test
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint to be applied
+ The actual value to test
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint to be applied
+ The actual value to test
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+ The message to display if the condition is false
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+ The message to display if the condition is false
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+
+
+
+ Asserts that the code represented by a delegate throws an exception
+ that satisfies the constraint provided.
+
+ A TestDelegate to be executed
+ A ThrowsConstraint used in the test
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ Used as a synonym for That in rare cases where a private setter
+ causes a Visual Basic compilation error.
+
+ A Constraint to be applied
+ The actual value to test
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ Used as a synonym for That in rare cases where a private setter
+ causes a Visual Basic compilation error.
+
+ A Constraint to be applied
+ The actual value to test
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ Used as a synonym for That in rare cases where a private setter
+ causes a Visual Basic compilation error.
+
+
+ This method is provided for use by VB developers needing to test
+ the value of properties with private setters.
+
+ A Constraint expression to be applied
+ The actual value to test
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ A constraint to be satisfied by the exception
+ A TestSnippet delegate
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ A constraint to be satisfied by the exception
+ A TestSnippet delegate
+ The message that will be displayed on failure
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ A constraint to be satisfied by the exception
+ A TestSnippet delegate
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ The exception Type expected
+ A TestSnippet delegate
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ The exception Type expected
+ A TestSnippet delegate
+ The message that will be displayed on failure
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ The exception Type expected
+ A TestSnippet delegate
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ Type of the expected exception
+ A TestSnippet delegate
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ Type of the expected exception
+ A TestSnippet delegate
+ The message that will be displayed on failure
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ Type of the expected exception
+ A TestSnippet delegate
+
+
+
+ Verifies that a delegate throws an exception when called
+ and returns it.
+
+ A TestDelegate
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Verifies that a delegate throws an exception when called
+ and returns it.
+
+ A TestDelegate
+ The message that will be displayed on failure
+
+
+
+ Verifies that a delegate throws an exception when called
+ and returns it.
+
+ A TestDelegate
+
+
+
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+
+ The expected Exception Type
+ A TestDelegate
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+
+ The expected Exception Type
+ A TestDelegate
+ The message that will be displayed on failure
+
+
+
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+
+ The expected Exception Type
+ A TestDelegate
+
+
+
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+
+ The expected Exception Type
+ A TestDelegate
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+
+ The expected Exception Type
+ A TestDelegate
+ The message that will be displayed on failure
+
+
+
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+
+ The expected Exception Type
+ A TestDelegate
+
+
+
+ Verifies that a delegate does not throw an exception
+
+ A TestSnippet delegate
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Verifies that a delegate does not throw an exception.
+
+ A TestSnippet delegate
+ The message that will be displayed on failure
+
+
+
+ Verifies that a delegate does not throw an exception.
+
+ A TestSnippet delegate
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+ The message to display in case of failure
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+ The message to display in case of failure
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+
+
+
+ Asserts that a condition is false. If the condition is true the method throws
+ an .
+
+ The evaluated condition
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that a condition is false. If the condition is true the method throws
+ an .
+
+ The evaluated condition
+ The message to display in case of failure
+
+
+
+ Asserts that a condition is false. If the condition is true the method throws
+ an .
+
+ The evaluated condition
+
+
+
+ Asserts that a condition is false. If the condition is true the method throws
+ an .
+
+ The evaluated condition
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that a condition is false. If the condition is true the method throws
+ an .
+
+ The evaluated condition
+ The message to display in case of failure
+
+
+
+ Asserts that a condition is false. If the condition is true the method throws
+ an .
+
+ The evaluated condition
+
+
+
+ Verifies that the object that is passed in is not equal to null
+ If the object is null
then an
+ is thrown.
+
+ The object that is to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the object that is passed in is not equal to null
+ If the object is null
then an
+ is thrown.
+
+ The object that is to be tested
+ The message to display in case of failure
+
+
+
+ Verifies that the object that is passed in is not equal to null
+ If the object is null
then an
+ is thrown.
+
+ The object that is to be tested
+
+
+
+ Verifies that the object that is passed in is not equal to null
+ If the object is null
then an
+ is thrown.
+
+ The object that is to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the object that is passed in is not equal to null
+ If the object is null
then an
+ is thrown.
+
+ The object that is to be tested
+ The message to display in case of failure
+
+
+
+ Verifies that the object that is passed in is not equal to null
+ If the object is null
then an
+ is thrown.
+
+ The object that is to be tested
+
+
+
+ Verifies that the object that is passed in is equal to null
+ If the object is not null
then an
+ is thrown.
+
+ The object that is to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the object that is passed in is equal to null
+ If the object is not null
then an
+ is thrown.
+
+ The object that is to be tested
+ The message to display in case of failure
+
+
+
+ Verifies that the object that is passed in is equal to null
+ If the object is not null
then an
+ is thrown.
+
+ The object that is to be tested
+
+
+
+ Verifies that the object that is passed in is equal to null
+ If the object is not null
then an
+ is thrown.
+
+ The object that is to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the object that is passed in is equal to null
+ If the object is not null
then an
+ is thrown.
+
+ The object that is to be tested
+ The message to display in case of failure
+
+
+
+ Verifies that the object that is passed in is equal to null
+ If the object is not null
then an
+ is thrown.
+
+ The object that is to be tested
+
+
+
+ Verifies that the double that is passed in is an NaN
value.
+ If the object is not NaN
then an
+ is thrown.
+
+ The value that is to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the double that is passed in is an NaN
value.
+ If the object is not NaN
then an
+ is thrown.
+
+ The value that is to be tested
+ The message to display in case of failure
+
+
+
+ Verifies that the double that is passed in is an NaN
value.
+ If the object is not NaN
then an
+ is thrown.
+
+ The value that is to be tested
+
+
+
+ Verifies that the double that is passed in is an NaN
value.
+ If the object is not NaN
then an
+ is thrown.
+
+ The value that is to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the double that is passed in is an NaN
value.
+ If the object is not NaN
then an
+ is thrown.
+
+ The value that is to be tested
+ The message to display in case of failure
+
+
+
+ Verifies that the double that is passed in is an NaN
value.
+ If the object is not NaN
then an
+ is thrown.
+
+ The value that is to be tested
+
+
+
+ Assert that a string is empty - that is equal to string.Empty
+
+ The string to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Assert that a string is empty - that is equal to string.Empty
+
+ The string to be tested
+ The message to display in case of failure
+
+
+
+ Assert that a string is empty - that is equal to string.Empty
+
+ The string to be tested
+
+
+
+ Assert that an array, list or other collection is empty
+
+ An array, list or other collection implementing ICollection
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Assert that an array, list or other collection is empty
+
+ An array, list or other collection implementing ICollection
+ The message to display in case of failure
+
+
+
+ Assert that an array, list or other collection is empty
+
+ An array, list or other collection implementing ICollection
+
+
+
+ Assert that a string is not empty - that is not equal to string.Empty
+
+ The string to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Assert that a string is not empty - that is not equal to string.Empty
+
+ The string to be tested
+ The message to display in case of failure
+
+
+
+ Assert that a string is not empty - that is not equal to string.Empty
+
+ The string to be tested
+
+
+
+ Assert that an array, list or other collection is not empty
+
+ An array, list or other collection implementing ICollection
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Assert that an array, list or other collection is not empty
+
+ An array, list or other collection implementing ICollection
+ The message to display in case of failure
+
+
+
+ Assert that an array, list or other collection is not empty
+
+ An array, list or other collection implementing ICollection
+
+
+
+ Assert that a string is either null or equal to string.Empty
+
+ The string to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Assert that a string is either null or equal to string.Empty
+
+ The string to be tested
+ The message to display in case of failure
+
+
+
+ Assert that a string is either null or equal to string.Empty
+
+ The string to be tested
+
+
+
+ Assert that a string is not null or empty
+
+ The string to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Assert that a string is not null or empty
+
+ The string to be tested
+ The message to display in case of failure
+
+
+
+ Assert that a string is not null or empty
+
+ The string to be tested
+
+
+
+ Asserts that an object may be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object may be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+ The message to display in case of failure
+
+
+
+ Asserts that an object may be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+
+
+
+ Asserts that an object may be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object may be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+ The message to display in case of failure
+
+
+
+ Asserts that an object may be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+
+
+
+ Asserts that an object may not be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object may not be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+ The message to display in case of failure
+
+
+
+ Asserts that an object may not be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+
+
+
+ Asserts that an object may not be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object may not be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+ The message to display in case of failure
+
+
+
+ Asserts that an object may not be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+
+
+
+ Asserts that an object is an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object is an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+
+
+
+ Asserts that an object is an instance of a given type.
+
+ The expected Type
+ The object being examined
+
+
+
+ Asserts that an object is an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object is an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+
+
+
+ Asserts that an object is an instance of a given type.
+
+ The expected Type
+ The object being examined
+
+
+
+ Asserts that an object is an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object is an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+
+
+
+ Asserts that an object is an instance of a given type.
+
+ The expected Type
+ The object being examined
+
+
+
+ Asserts that an object is not an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object is not an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+
+
+
+ Asserts that an object is not an instance of a given type.
+
+ The expected Type
+ The object being examined
+
+
+
+ Asserts that an object is not an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object is not an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+
+
+
+ Asserts that an object is not an instance of a given type.
+
+ The expected Type
+ The object being examined
+
+
+
+ Asserts that an object is not an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object is not an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+
+
+
+ Asserts that an object is not an instance of a given type.
+
+ The expected Type
+ The object being examined
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ 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 is
+ thrown.
+
+ The expected value
+ The actual value
+ The maximum acceptable difference between the
+ the expected and the actual
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ 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 is
+ thrown.
+
+ The expected value
+ The actual value
+ The maximum acceptable difference between the
+ the expected and the actual
+ The message to display in case of failure
+
+
+
+ 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 is
+ thrown.
+
+ The expected value
+ The actual value
+ The maximum acceptable difference between the
+ the expected and the actual
+
+
+
+ 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 is
+ thrown.
+
+ The expected value
+ The actual value
+ The maximum acceptable difference between the
+ the expected and the actual
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ 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 is
+ thrown.
+
+ The expected value
+ The actual value
+ The maximum acceptable difference between the
+ the expected and the actual
+ The message to display in case of failure
+
+
+
+ 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 is
+ thrown.
+
+ The expected value
+ The actual value
+ The maximum acceptable difference between the
+ the expected and the actual
+
+
+
+ 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 is thrown.
+
+ The value that is expected
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ 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 is thrown.
+
+ The value that is expected
+ The actual value
+ The message to display in case of failure
+
+
+
+ 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 is thrown.
+
+ The value that is expected
+ The actual value
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ 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 is thrown.
+
+ The value that is expected
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ 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 is thrown.
+
+ The value that is expected
+ The actual value
+ The message to display in case of failure
+
+
+
+ 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 is thrown.
+
+ The value that is expected
+ The actual value
+
+
+
+ Asserts that two objects refer to the same object. If they
+ are not the same an is thrown.
+
+ The expected object
+ The actual object
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that two objects refer to the same object. If they
+ are not the same an is thrown.
+
+ The expected object
+ The actual object
+ The message to display in case of failure
+
+
+
+ Asserts that two objects refer to the same object. If they
+ are not the same an is thrown.
+
+ The expected object
+ The actual object
+
+
+
+ Asserts that two objects do not refer to the same object. If they
+ are the same an is thrown.
+
+ The expected object
+ The actual object
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that two objects do not refer to the same object. If they
+ are the same an is thrown.
+
+ The expected object
+ The actual object
+ The message to display in case of failure
+
+
+
+ Asserts that two objects do not refer to the same object. If they
+ are the same an is thrown.
+
+ The expected object
+ The actual object
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Asserts that an object is contained in a list.
+
+ The expected object
+ The list to be examined
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object is contained in a list.
+
+ The expected object
+ The list to be examined
+ The message to display in case of failure
+
+
+
+ Asserts that an object is contained in a list.
+
+ The expected object
+ The list to be examined
+
+
+
+ Gets the number of assertions executed so far and
+ resets the counter to zero.
+
+
+
+
+ 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
+ , from which it inherits much of its
+ behavior, in certain mock object frameworks.
+
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure. Works
+ identically to Assert.That
+
+ A Constraint to be applied
+ The actual value to test
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure. Works
+ identically to Assert.That.
+
+ A Constraint to be applied
+ The actual value to test
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure. Works
+ identically to Assert.That
+
+ A Constraint to be applied
+ The actual value to test
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint expression to be applied
+ An ActualValueDelegate returning the value to be tested
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint expression to be applied
+ An ActualValueDelegate returning the value to be tested
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ An ActualValueDelegate returning the value to be tested
+ A Constraint expression to be applied
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint to be applied
+ The actual value to test
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint to be applied
+ The actual value to test
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint to be applied
+ The actual value to test
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an . Works Identically to Assert.That.
+
+ The evaluated condition
+ The message to display if the condition is false
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an . Works Identically to Assert.That.
+
+ The evaluated condition
+ The message to display if the condition is false
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an . Works Identically Assert.That.
+
+ The evaluated condition
+
+
+
+ Asserts that the code represented by a delegate throws an exception
+ that satisfies the constraint provided.
+
+ A TestDelegate to be executed
+ A ThrowsConstraint used in the test
+
+
+
+ Returns a ListMapper based on a collection.
+
+ The original collection
+
+
+
+
+ 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.
+
+
+
+
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+
+
+
+
+
+
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+
+
+
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+
+ A Constraint expression to be applied
+ The actual value to test
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+
+ A Constraint expression to be applied
+ The actual value to test
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+
+ A Constraint expression to be applied
+ The actual value to test
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+
+ A Constraint expression to be applied
+ An ActualValueDelegate returning the value to be tested
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+
+ A Constraint expression to be applied
+ An ActualValueDelegate returning the value to be tested
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+
+ An ActualValueDelegate returning the value to be tested
+ A Constraint expression to be applied
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+
+ A Constraint expression to be applied
+ The actual value to test
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+
+ A Constraint expression to be applied
+ The actual value to test
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+
+ A Constraint expression to be applied
+ The actual value to test
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+ The message to display if the condition is false
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+ The message to display if the condition is false
+
+
+
+ Asserts that a condition is true. If the condition is false the
+ method throws an .
+
+ The evaluated condition
+
+
+
+ Asserts that the code represented by a delegate throws an exception
+ that satisfies the constraint provided.
+
+ A TestDelegate to be executed
+ A ThrowsConstraint used in the test
+
+
+
+ A set of Assert methods operationg on one or more collections
+
+
+
+
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+
+
+
+
+
+
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+
+
+
+
+
+
+ Asserts that all items contained in collection are of the type specified by expectedType.
+
+ IEnumerable containing objects to be considered
+ System.Type that all objects in collection must be instances of
+
+
+
+ Asserts that all items contained in collection are of the type specified by expectedType.
+
+ IEnumerable containing objects to be considered
+ System.Type that all objects in collection must be instances of
+ The message that will be displayed on failure
+
+
+
+ Asserts that all items contained in collection are of the type specified by expectedType.
+
+ IEnumerable containing objects to be considered
+ System.Type that all objects in collection must be instances of
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that all items contained in collection are not equal to null.
+
+ IEnumerable containing objects to be considered
+
+
+
+ Asserts that all items contained in collection are not equal to null.
+
+ IEnumerable containing objects to be considered
+ The message that will be displayed on failure
+
+
+
+ Asserts that all items contained in collection are not equal to null.
+
+ IEnumerable of objects to be considered
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Ensures that every object contained in collection exists within the collection
+ once and only once.
+
+ IEnumerable of objects to be considered
+
+
+
+ Ensures that every object contained in collection exists within the collection
+ once and only once.
+
+ IEnumerable of objects to be considered
+ The message that will be displayed on failure
+
+
+
+ Ensures that every object contained in collection exists within the collection
+ once and only once.
+
+ IEnumerable of objects to be considered
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ 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.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+
+
+
+ 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.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The IComparer to use in comparing objects from each IEnumerable
+
+
+
+ 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.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The message that will be displayed on failure
+
+
+
+ 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.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The IComparer to use in comparing objects from each IEnumerable
+ The message that will be displayed on failure
+
+
+
+ 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.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ 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.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The IComparer to use in comparing objects from each IEnumerable
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+
+
+
+ Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The message that will be displayed on failure
+
+
+
+ Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that expected and actual are not exactly equal.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+
+
+
+ Asserts that expected and actual are not exactly equal.
+ If comparer is not null then it will be used to compare the objects.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The IComparer to use in comparing objects from each IEnumerable
+
+
+
+ Asserts that expected and actual are not exactly equal.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The message that will be displayed on failure
+
+
+
+ Asserts that expected and actual are not exactly equal.
+ If comparer is not null then it will be used to compare the objects.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The IComparer to use in comparing objects from each IEnumerable
+ The message that will be displayed on failure
+
+
+
+ Asserts that expected and actual are not exactly equal.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that expected and actual are not exactly equal.
+ If comparer is not null then it will be used to compare the objects.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The IComparer to use in comparing objects from each IEnumerable
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that expected and actual are not equivalent.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+
+
+
+ Asserts that expected and actual are not equivalent.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The message that will be displayed on failure
+
+
+
+ Asserts that expected and actual are not equivalent.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that collection contains actual as an item.
+
+ IEnumerable of objects to be considered
+ Object to be found within collection
+
+
+
+ Asserts that collection contains actual as an item.
+
+ IEnumerable of objects to be considered
+ Object to be found within collection
+ The message that will be displayed on failure
+
+
+
+ Asserts that collection contains actual as an item.
+
+ IEnumerable of objects to be considered
+ Object to be found within collection
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that collection does not contain actual as an item.
+
+ IEnumerable of objects to be considered
+ Object that cannot exist within collection
+
+
+
+ Asserts that collection does not contain actual as an item.
+
+ IEnumerable of objects to be considered
+ Object that cannot exist within collection
+ The message that will be displayed on failure
+
+
+
+ Asserts that collection does not contain actual as an item.
+
+ IEnumerable of objects to be considered
+ Object that cannot exist within collection
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that superset is not a subject of subset.
+
+ The IEnumerable superset to be considered
+ The IEnumerable subset to be considered
+
+
+
+ Asserts that superset is not a subject of subset.
+
+ The IEnumerable superset to be considered
+ The IEnumerable subset to be considered
+ The message that will be displayed on failure
+
+
+
+ Asserts that superset is not a subject of subset.
+
+ The IEnumerable superset to be considered
+ The IEnumerable subset to be considered
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that superset is a subset of subset.
+
+ The IEnumerable superset to be considered
+ The IEnumerable subset to be considered
+
+
+
+ Asserts that superset is a subset of subset.
+
+ The IEnumerable superset to be considered
+ The IEnumerable subset to be considered
+ The message that will be displayed on failure
+
+
+
+ Asserts that superset is a subset of subset.
+
+ The IEnumerable superset to be considered
+ The IEnumerable subset to be considered
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Assert that an array, list or other collection is empty
+
+ An array, list or other collection implementing IEnumerable
+ The message to be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Assert that an array, list or other collection is empty
+
+ An array, list or other collection implementing IEnumerable
+ The message to be displayed on failure
+
+
+
+ Assert that an array,list or other collection is empty
+
+ An array, list or other collection implementing IEnumerable
+
+
+
+ Assert that an array, list or other collection is empty
+
+ An array, list or other collection implementing IEnumerable
+ The message to be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Assert that an array, list or other collection is empty
+
+ An array, list or other collection implementing IEnumerable
+ The message to be displayed on failure
+
+
+
+ Assert that an array,list or other collection is empty
+
+ An array, list or other collection implementing IEnumerable
+
+
+
+ Assert that an array, list or other collection is ordered
+
+ An array, list or other collection implementing IEnumerable
+ The message to be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Assert that an array, list or other collection is ordered
+
+ An array, list or other collection implementing IEnumerable
+ The message to be displayed on failure
+
+
+
+ Assert that an array, list or other collection is ordered
+
+ An array, list or other collection implementing IEnumerable
+
+
+
+ Assert that an array, list or other collection is ordered
+
+ An array, list or other collection implementing IEnumerable
+ A custom comparer to perform the comparisons
+ The message to be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Assert that an array, list or other collection is ordered
+
+ An array, list or other collection implementing IEnumerable
+ A custom comparer to perform the comparisons
+ The message to be displayed on failure
+
+
+
+ Assert that an array, list or other collection is ordered
+
+ An array, list or other collection implementing IEnumerable
+ A custom comparer to perform the comparisons
+
+
+
+ Static helper class used in the constraint-based syntax
+
+
+
+
+ Creates a new SubstringConstraint
+
+ The value of the substring
+ A SubstringConstraint
+
+
+
+ Creates a new CollectionContainsConstraint.
+
+ The item that should be found.
+ A new CollectionContainsConstraint
+
+
+
+ Summary description for DirectoryAssert
+
+
+
+
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+
+
+
+
+
+
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+
+
+
+
+
+
+ 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.
+
+
+
+
+ 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 is thrown.
+
+ A directory containing the value that is expected
+ A directory containing the actual value
+ The message to display if directories are not equal
+ Arguments to be used in formatting the message
+
+
+
+ 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 is thrown.
+
+ A directory containing the value that is expected
+ A directory containing the actual value
+ The message to display if directories are not equal
+
+
+
+ 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 is thrown.
+
+ A directory containing the value that is expected
+ A directory containing the actual value
+
+
+
+ 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 is thrown.
+
+ A directory path string containing the value that is expected
+ A directory path string containing the actual value
+ The message to display if directories are not equal
+ Arguments to be used in formatting the message
+
+
+
+ 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 is thrown.
+
+ A directory path string containing the value that is expected
+ A directory path string containing the actual value
+ The message to display if directories are not equal
+
+
+
+ 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 is thrown.
+
+ A directory path string containing the value that is expected
+ A directory path string containing the actual value
+
+
+
+ Asserts that two directories are not equal. If they are equal
+ an is thrown.
+
+ A directory containing the value that is expected
+ A directory containing the actual value
+ The message to display if directories are not equal
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that two directories are not equal. If they are equal
+ an is thrown.
+
+ A directory containing the value that is expected
+ A directory containing the actual value
+ The message to display if directories are not equal
+
+
+
+ Asserts that two directories are not equal. If they are equal
+ an is thrown.
+
+ A directory containing the value that is expected
+ A directory containing the actual value
+
+
+
+ Asserts that two directories are not equal. If they are equal
+ an is thrown.
+
+ A directory path string containing the value that is expected
+ A directory path string containing the actual value
+ The message to display if directories are equal
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that two directories are not equal. If they are equal
+ an is thrown.
+
+ A directory path string containing the value that is expected
+ A directory path string containing the actual value
+ The message to display if directories are equal
+
+
+
+ Asserts that two directories are not equal. If they are equal
+ an is thrown.
+
+ A directory path string containing the value that is expected
+ A directory path string containing the actual value
+
+
+
+ Asserts that the directory is empty. If it is not empty
+ an is thrown.
+
+ A directory to search
+ The message to display if directories are not equal
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that the directory is empty. If it is not empty
+ an is thrown.
+
+ A directory to search
+ The message to display if directories are not equal
+
+
+
+ Asserts that the directory is empty. If it is not empty
+ an is thrown.
+
+ A directory to search
+
+
+
+ Asserts that the directory is empty. If it is not empty
+ an is thrown.
+
+ A directory to search
+ The message to display if directories are not equal
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that the directory is empty. If it is not empty
+ an is thrown.
+
+ A directory to search
+ The message to display if directories are not equal
+
+
+
+ Asserts that the directory is empty. If it is not empty
+ an is thrown.
+
+ A directory to search
+
+
+
+ Asserts that the directory is not empty. If it is empty
+ an is thrown.
+
+ A directory to search
+ The message to display if directories are not equal
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that the directory is not empty. If it is empty
+ an is thrown.
+
+ A directory to search
+ The message to display if directories are not equal
+
+
+
+ Asserts that the directory is not empty. If it is empty
+ an is thrown.
+
+ A directory to search
+
+
+
+ Asserts that the directory is not empty. If it is empty
+ an is thrown.
+
+ A directory to search
+ The message to display if directories are not equal
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that the directory is not empty. If it is empty
+ an is thrown.
+
+ A directory to search
+ The message to display if directories are not equal
+
+
+
+ Asserts that the directory is not empty. If it is empty
+ an is thrown.
+
+ A directory to search
+
+
+
+ Asserts that path contains actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+ The message to display if directory is not within the path
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that path contains actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+ The message to display if directory is not within the path
+
+
+
+ Asserts that path contains actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+
+
+
+ Asserts that path contains actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+ The message to display if directory is not within the path
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that path contains actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+ The message to display if directory is not within the path
+
+
+
+ Asserts that path contains actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+
+
+
+ Asserts that path does not contain actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+ The message to display if directory is not within the path
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that path does not contain actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+ The message to display if directory is not within the path
+
+
+
+ Asserts that path does not contain actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+
+
+
+ Asserts that path does not contain actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+ The message to display if directory is not within the path
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that path does not contain actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+ The message to display if directory is not within the path
+
+
+
+ Asserts that path does not contain actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+
+
+
+ Summary description for FileAssert.
+
+
+
+
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+
+
+
+
+
+
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+
+
+
+
+
+
+ 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.
+
+
+
+
+ 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 is thrown.
+
+ The expected Stream
+ The actual Stream
+ The message to display if Streams are not equal
+ Arguments to be used in formatting the message
+
+
+
+ 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 is thrown.
+
+ The expected Stream
+ The actual Stream
+ The message to display if objects are not equal
+
+
+
+ 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 is thrown.
+
+ The expected Stream
+ The actual Stream
+
+
+
+ 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 is thrown.
+
+ A file containing the value that is expected
+ A file containing the actual value
+ The message to display if Streams are not equal
+ Arguments to be used in formatting the message
+
+
+
+ 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 is thrown.
+
+ A file containing the value that is expected
+ A file containing the actual value
+ The message to display if objects are not equal
+
+
+
+ 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 is thrown.
+
+ A file containing the value that is expected
+ A file containing the actual value
+
+
+
+ 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 is thrown.
+
+ The path to a file containing the value that is expected
+ The path to a file containing the actual value
+ The message to display if Streams are not equal
+ Arguments to be used in formatting the message
+
+
+
+ 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 is thrown.
+
+ The path to a file containing the value that is expected
+ The path to a file containing the actual value
+ The message to display if objects are not equal
+
+
+
+ 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 is thrown.
+
+ The path to a file containing the value that is expected
+ The path to a file containing the actual value
+
+
+
+ Asserts that two Streams are not equal. If they are equal
+ an is thrown.
+
+ The expected Stream
+ The actual Stream
+ The message to be displayed when the two Stream are the same.
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that two Streams are not equal. If they are equal
+ an is thrown.
+
+ The expected Stream
+ The actual Stream
+ The message to be displayed when the Streams are the same.
+
+
+
+ Asserts that two Streams are not equal. If they are equal
+ an is thrown.
+
+ The expected Stream
+ The actual Stream
+
+
+
+ Asserts that two files are not equal. If they are equal
+ an is thrown.
+
+ A file containing the value that is expected
+ A file containing the actual value
+ The message to display if Streams are not equal
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that two files are not equal. If they are equal
+ an is thrown.
+
+ A file containing the value that is expected
+ A file containing the actual value
+ The message to display if objects are not equal
+
+
+
+ Asserts that two files are not equal. If they are equal
+ an is thrown.
+
+ A file containing the value that is expected
+ A file containing the actual value
+
+
+
+ Asserts that two files are not equal. If they are equal
+ an is thrown.
+
+ The path to a file containing the value that is expected
+ The path to a file containing the actual value
+ The message to display if Streams are not equal
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that two files are not equal. If they are equal
+ an is thrown.
+
+ The path to a file containing the value that is expected
+ The path to a file containing the actual value
+ The message to display if objects are not equal
+
+
+
+ Asserts that two files are not equal. If they are equal
+ an is thrown.
+
+ The path to a file containing the value that is expected
+ The path to a file containing the actual value
+
+
+
+ GlobalSettings is a place for setting default values used
+ by the framework in performing asserts.
+
+
+
+
+ Default tolerance for floating point equality
+
+
+
+
+ Helper class with properties and methods that supply
+ a number of constraints used in Asserts.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding only if a specified number of them succeed.
+
+
+
+
+ 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.
+
+
+
+
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+
+
+
+
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+
+
+
+
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+
+
+
+
+ Returns a ConstraintExpression that negates any
+ following constraint.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if at least one of them succeeds.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them fail.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Length property of the object being tested.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Count property of the object being tested.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Message property of the object being tested.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the InnerException property of the object being tested.
+
+
+
+
+ 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.
+
+
+
+
+ Method to handle an expected exception
+
+ The exception to be handled
+
+
+
+ Helper class with properties and methods that supply
+ a number of constraints used in Asserts.
+
+
+
+
+ Returns a constraint that tests two items for equality
+
+
+
+
+ Returns a constraint that tests that two references are the same object
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is greater than the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is less than the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is a collection containing the same elements as the
+ collection supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is a subset of the collection supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the path provided
+ is the same as an expected path after canonicalization.
+
+
+
+
+ Returns a constraint that tests whether the path provided
+ is the same path or under an expected path after canonicalization.
+
+
+
+
+ Returns a constraint that tests whether the path provided
+ is the same path or under an expected path after canonicalization.
+
+
+
+
+ Returns a constraint that tests whether the actual value falls
+ within a specified range.
+
+
+
+
+ Returns a ConstraintExpression that negates any
+ following constraint.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+
+
+
+
+ Returns a constraint that tests for null
+
+
+
+
+ Returns a constraint that tests for True
+
+
+
+
+ Returns a constraint that tests for False
+
+
+
+
+ Returns a constraint that tests for a positive value
+
+
+
+
+ Returns a constraint that tests for a negative value
+
+
+
+
+ Returns a constraint that tests for NaN
+
+
+
+
+ Returns a constraint that tests for empty
+
+
+
+
+ Returns a constraint that tests whether a collection
+ contains all unique items.
+
+
+
+
+ Returns a constraint that tests whether an object graph is serializable in binary format.
+
+
+
+
+ Returns a constraint that tests whether an object graph is serializable in xml format.
+
+
+
+
+ Returns a constraint that tests whether a collection is ordered
+
+
+
+
+ The Iz class is a synonym for Is intended for use in VB,
+ which regards Is as a keyword.
+
+
+
+
+ The List class is a helper class with properties and methods
+ that supply a number of constraints used with lists and collections.
+
+
+
+
+ List.Map returns a ListMapper, which can be used to map
+ the original collection to another collection.
+
+
+
+
+
+
+ ListMapper is used to transform a collection used as an actual argument
+ producing another collection to be used in the assertion.
+
+
+
+
+ Construct a ListMapper based on a collection
+
+ The collection to be transformed
+
+
+
+ Produces a collection containing all the values of a property
+
+ The collection of property values
+
+
+
+
+ Randomizer returns a set of random values in a repeatable
+ way, to allow re-running of tests if necessary.
+
+
+
+
+ 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.
+
+
+
+
+ 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.
+
+
+
+
+ Construct a randomizer using a random seed
+
+
+
+
+ Construct a randomizer using a specified seed
+
+
+
+
+ Return an array of random doubles between 0.0 and 1.0.
+
+
+
+
+
+
+ Return an array of random doubles with values in a specified range.
+
+
+
+
+ Return an array of random ints with values in a specified range.
+
+
+
+
+ Get a random seed for use in creating a randomizer.
+
+
+
+
+ The SpecialValue enum is used to represent TestCase arguments
+ that cannot be used as arguments to an Attribute.
+
+
+
+
+ Null represents a null value, which cannot be used as an
+ argument to an attriute under .NET 1.x
+
+
+
+
+ Basic Asserts on strings.
+
+
+
+
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+
+
+
+
+
+
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+
+
+
+
+
+
+ Asserts that a string is found within another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that a string is found within another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+
+
+
+ Asserts that a string is found within another string.
+
+ The expected string
+ The string to be examined
+
+
+
+ Asserts that a string is not found within another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that a string is found within another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+
+
+
+ Asserts that a string is found within another string.
+
+ The expected string
+ The string to be examined
+
+
+
+ Asserts that a string starts with another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that a string starts with another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+
+
+
+ Asserts that a string starts with another string.
+
+ The expected string
+ The string to be examined
+
+
+
+ Asserts that a string does not start with another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that a string does not start with another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+
+
+
+ Asserts that a string does not start with another string.
+
+ The expected string
+ The string to be examined
+
+
+
+ Asserts that a string ends with another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that a string ends with another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+
+
+
+ Asserts that a string ends with another string.
+
+ The expected string
+ The string to be examined
+
+
+
+ Asserts that a string does not end with another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that a string does not end with another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+
+
+
+ Asserts that a string does not end with another string.
+
+ The expected string
+ The string to be examined
+
+
+
+ Asserts that two strings are equal, without regard to case.
+
+ The expected string
+ The actual string
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that two strings are equal, without regard to case.
+
+ The expected string
+ The actual string
+ The message to display in case of failure
+
+
+
+ Asserts that two strings are equal, without regard to case.
+
+ The expected string
+ The actual string
+
+
+
+ Asserts that two strings are not equal, without regard to case.
+
+ The expected string
+ The actual string
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that two strings are Notequal, without regard to case.
+
+ The expected string
+ The actual string
+ The message to display in case of failure
+
+
+
+ Asserts that two strings are not equal, without regard to case.
+
+ The expected string
+ The actual string
+
+
+
+ Asserts that a string matches an expected regular expression pattern.
+
+ The regex pattern to be matched
+ The actual string
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that a string matches an expected regular expression pattern.
+
+ The regex pattern to be matched
+ The actual string
+ The message to display in case of failure
+
+
+
+ Asserts that a string matches an expected regular expression pattern.
+
+ The regex pattern to be matched
+ The actual string
+
+
+
+ Asserts that a string does not match an expected regular expression pattern.
+
+ The regex pattern to be used
+ The actual string
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that a string does not match an expected regular expression pattern.
+
+ The regex pattern to be used
+ The actual string
+ The message to display in case of failure
+
+
+
+ Asserts that a string does not match an expected regular expression pattern.
+
+ The regex pattern to be used
+ The actual string
+
+
+
+ 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.
+
+
+
+
+ The argument list to be provided to the test
+
+
+
+
+ The expected result to be returned
+
+
+
+
+ Set to true if this has an expected result
+
+
+
+
+ The expected exception Type
+
+
+
+
+ The FullName of the expected exception
+
+
+
+
+ The name to be used for the test
+
+
+
+
+ The description of the test
+
+
+
+
+ A dictionary of properties, used to add information
+ to tests without requiring the class to change.
+
+
+
+
+ If true, indicates that the test case is to be ignored
+
+
+
+
+ If true, indicates that the test case is marked explicit
+
+
+
+
+ The reason for ignoring a test case
+
+
+
+
+ Initializes a new instance of the class.
+
+ The arguments.
+
+
+
+ Initializes a new instance of the class.
+
+ The argument.
+
+
+
+ Initializes a new instance of the class.
+
+ The first argument.
+ The second argument.
+
+
+
+ Initializes a new instance of the class.
+
+ The first argument.
+ The second argument.
+ The third argument.
+
+
+
+ Sets the expected result for the test
+
+ The expected result
+ A modified TestCaseData
+
+
+
+ Sets the expected exception type for the test
+
+ Type of the expected exception.
+ The modified TestCaseData instance
+
+
+
+ Sets the expected exception type for the test
+
+ FullName of the expected exception.
+ The modified TestCaseData instance
+
+
+
+ Sets the name of the test case
+
+ The modified TestCaseData instance
+
+
+
+ Sets the description for the test case
+ being constructed.
+
+ The description.
+ The modified TestCaseData instance.
+
+
+
+ Applies a category to the test
+
+
+
+
+
+
+ Applies a named property to the test
+
+
+
+
+
+
+
+ Applies a named property to the test
+
+
+
+
+
+
+
+ Applies a named property to the test
+
+
+
+
+
+
+
+ Ignores this TestCase.
+
+
+
+
+
+ Ignores this TestCase, specifying the reason.
+
+ The reason.
+
+
+
+
+ Marks this TestCase as Explicit
+
+
+
+
+
+ Marks this TestCase as Explicit, specifying the reason.
+
+ The reason.
+
+
+
+
+ Gets the argument list to be provided to the test
+
+
+
+
+ Gets the expected result
+
+
+
+
+ Returns true if the result has been set
+
+
+
+
+ Gets the expected exception Type
+
+
+
+
+ Gets the FullName of the expected exception
+
+
+
+
+ Gets the name to be used for the test
+
+
+
+
+ Gets the description of the test
+
+
+
+
+ Gets a value indicating whether this is ignored.
+
+ true if ignored; otherwise, false.
+
+
+
+ Gets a value indicating whether this is explicit.
+
+ true if explicit; otherwise, false.
+
+
+
+ Gets the ignore reason.
+
+ The ignore reason.
+
+
+
+ Gets a list of categories associated with this test.
+
+
+
+
+ Gets the property dictionary for this test
+
+
+
+
+ Provide the context information of the current test
+
+
+
+
+ Constructs a TestContext using the provided context dictionary
+
+ A context dictionary
+
+
+
+ Get the current test context. This is created
+ as needed. The user may save the context for
+ use within a test, but it should not be used
+ outside the test for which it is created.
+
+
+
+
+ Gets a TestAdapter representing the currently executing test in this context.
+
+
+
+
+ Gets a ResultAdapter representing the current result for the test
+ executing in this context.
+
+
+
+
+ Gets the directory containing the current test assembly.
+
+
+
+
+ Gets the directory to be used for outputing files created
+ by this test run.
+
+
+
+
+ TestAdapter adapts a Test for consumption by
+ the user test code.
+
+
+
+
+ Constructs a TestAdapter for this context
+
+ The context dictionary
+
+
+
+ The name of the test.
+
+
+
+
+ The FullName of the test
+
+
+
+
+ The properties of the test.
+
+
+
+
+ ResultAdapter adapts a TestResult for consumption by
+ the user test code.
+
+
+
+
+ Construct a ResultAdapter for a context
+
+ The context holding the result
+
+
+
+ The TestState of current test. This maps to the ResultState
+ used in nunit.core and is subject to change in the future.
+
+
+
+
+ The TestStatus of current test. This enum will be used
+ in future versions of NUnit and so is to be preferred
+ to the TestState value.
+
+
+
+
+ Provides details about a test
+
+
+
+
+ Creates an instance of TestDetails
+
+ The fixture that the test is a member of, if available.
+ The method that implements the test, if available.
+ The full name of the test.
+ A string representing the type of test, e.g. "Test Case".
+ Indicates if the test represents a suite of tests.
+
+
+
+ The fixture that the test is a member of, if available.
+
+
+
+
+ The method that implements the test, if available.
+
+
+
+
+ The full name of the test.
+
+
+
+
+ A string representing the type of test, e.g. "Test Case".
+
+
+
+
+ Indicates if the test represents a suite of tests.
+
+
+
+
+ The ResultState enum indicates the result of running a test
+
+
+
+
+ The result is inconclusive
+
+
+
+
+ The test was not runnable.
+
+
+
+
+ The test has been skipped.
+
+
+
+
+ The test has been ignored.
+
+
+
+
+ The test succeeded
+
+
+
+
+ The test failed
+
+
+
+
+ The test encountered an unexpected exception
+
+
+
+
+ The test was cancelled by the user
+
+
+
+
+ The TestStatus enum indicates the result of running a test
+
+
+
+
+ The test was inconclusive
+
+
+
+
+ The test has skipped
+
+
+
+
+ The test succeeded
+
+
+
+
+ The test failed
+
+
+
+
+ Helper class with static methods used to supply constraints
+ that operate on strings.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that fails if the actual
+ value contains the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that fails if the actual
+ value starts with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that fails if the actual
+ value ends with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+
+
+
+
+ Returns a constraint that fails if the actual
+ value matches the pattern supplied as an argument.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+
+
+
+
+ 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.
+
+
+
+
+ Prefix used for the expected value line of a message
+
+
+
+
+ Prefix used for the actual value line of a message
+
+
+
+
+ Length of a message prefix
+
+
+
+
+ Construct a TextMessageWriter
+
+
+
+
+ Construct a TextMessageWriter, specifying a user message
+ and optional formatting arguments.
+
+
+
+
+
+
+ Method to write single line message with optional args, usually
+ written to precede the general failure message, at a givel
+ indentation level.
+
+ The indentation level of the message
+ The message to be written
+ Any arguments used in formatting the message
+
+
+
+ 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.
+
+ The constraint that failed
+
+
+
+ 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.
+
+ The expected value
+ The actual value causing the failure
+
+
+
+ Display Expected and Actual lines for given values, including
+ a tolerance value on the expected line.
+
+ The expected value
+ The actual value causing the failure
+ The tolerance within which the test was made
+
+
+
+ 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.
+
+ The expected string value
+ The actual string value
+ The point at which the strings don't match or -1
+ If true, case is ignored in string comparisons
+ If true, clip the strings to fit the max line length
+
+
+
+ Writes the text for a connector.
+
+ The connector.
+
+
+
+ Writes the text for a predicate.
+
+ The predicate.
+
+
+
+ Write the text for a modifier.
+
+ The modifier.
+
+
+
+ Writes the text for an expected value.
+
+ The expected value.
+
+
+
+ Writes the text for an actual value.
+
+ The actual value.
+
+
+
+ Writes the text for a generalized value.
+
+ The value.
+
+
+
+ Writes the text for a collection value,
+ starting at a particular point, to a max length
+
+ The collection containing elements to write.
+ The starting point of the elements to write
+ The maximum number of elements to write
+
+
+
+ Write the generic 'Expected' line for a constraint
+
+ The constraint that failed
+
+
+
+ Write the generic 'Expected' line for a given value
+
+ The expected value
+
+
+
+ Write the generic 'Expected' line for a given value
+ and tolerance.
+
+ The expected value
+ The tolerance within which the test was made
+
+
+
+ Write the generic 'Actual' line for a constraint
+
+ The constraint for which the actual value is to be written
+
+
+
+ Write the generic 'Actual' line for a given value
+
+ The actual value causing a failure
+
+
+
+ Gets or sets the maximum line length for this writer
+
+
+
+
+ Helper class with properties and methods that supply
+ constraints that operate on exceptions.
+
+
+
+
+ Creates a constraint specifying the exact type of exception expected
+
+
+
+
+ Creates a constraint specifying the exact type of exception expected
+
+
+
+
+ Creates a constraint specifying the type of exception expected
+
+
+
+
+ Creates a constraint specifying the type of exception expected
+
+
+
+
+ Creates a constraint specifying an expected exception
+
+
+
+
+ Creates a constraint specifying an exception with a given InnerException
+
+
+
+
+ Creates a constraint specifying an expected TargetInvocationException
+
+
+
+
+ Creates a constraint specifying an expected TargetInvocationException
+
+
+
+
+ Creates a constraint specifying an expected TargetInvocationException
+
+
+
+
+ Creates a constraint specifying that no exception is thrown
+
+
+
+
diff --git a/TaxCalculatorTests/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache b/TaxCalculatorTests/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache
new file mode 100644
index 0000000..6d28d2b
Binary files /dev/null and b/TaxCalculatorTests/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache differ
diff --git a/TaxCalculatorTests/obj/Debug/TaxCalculation.Tests.csproj.FileListAbsolute.txt b/TaxCalculatorTests/obj/Debug/TaxCalculation.Tests.csproj.FileListAbsolute.txt
new file mode 100644
index 0000000..6ffd8b8
--- /dev/null
+++ b/TaxCalculatorTests/obj/Debug/TaxCalculation.Tests.csproj.FileListAbsolute.txt
@@ -0,0 +1,11 @@
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\bin\Debug\TaxCalculatorTests.dll
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\bin\Debug\TaxCalculatorTests.pdb
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\bin\Debug\nunit.framework.dll
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\bin\Debug\Rhino.Mocks.dll
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\bin\Debug\TaxCalculation.Domain.dll
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\bin\Debug\TaxCalculation.Domain.pdb
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\bin\Debug\nunit.framework.xml
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\bin\Debug\Rhino.Mocks.xml
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\obj\Debug\TaxCalculation.Tests.csprojResolveAssemblyReference.cache
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\obj\Debug\TaxCalculatorTests.dll
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\obj\Debug\TaxCalculatorTests.pdb
diff --git a/TaxCalculatorTests/obj/Debug/TaxCalculation.Tests.csprojResolveAssemblyReference.cache b/TaxCalculatorTests/obj/Debug/TaxCalculation.Tests.csprojResolveAssemblyReference.cache
new file mode 100644
index 0000000..7514624
Binary files /dev/null and b/TaxCalculatorTests/obj/Debug/TaxCalculation.Tests.csprojResolveAssemblyReference.cache differ
diff --git a/TaxCalculatorTests/obj/Debug/TaxCalculationTests.csproj.FileListAbsolute.txt b/TaxCalculatorTests/obj/Debug/TaxCalculationTests.csproj.FileListAbsolute.txt
new file mode 100644
index 0000000..98c0efa
--- /dev/null
+++ b/TaxCalculatorTests/obj/Debug/TaxCalculationTests.csproj.FileListAbsolute.txt
@@ -0,0 +1,6 @@
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\bin\Debug\TaxCalculatorTests.dll
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\bin\Debug\TaxCalculatorTests.pdb
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\bin\Debug\nunit.framework.dll
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\bin\Debug\nunit.framework.xml
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\obj\Debug\TaxCalculatorTests.dll
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\obj\Debug\TaxCalculatorTests.pdb
diff --git a/TaxCalculatorTests/obj/Debug/TaxCalculatorTests.csproj.FileListAbsolute.txt b/TaxCalculatorTests/obj/Debug/TaxCalculatorTests.csproj.FileListAbsolute.txt
new file mode 100644
index 0000000..cf6d9f8
--- /dev/null
+++ b/TaxCalculatorTests/obj/Debug/TaxCalculatorTests.csproj.FileListAbsolute.txt
@@ -0,0 +1,5 @@
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\bin\Debug\TaxCalculatorTests.dll
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\bin\Debug\TaxCalculatorTests.pdb
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\obj\Debug\TaxCalculatorTests.csprojResolveAssemblyReference.cache
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\obj\Debug\TaxCalculatorTests.dll
+C:\Edwin\ThoughtWorks\TaxCalculator\TaxCalculatorTests\obj\Debug\TaxCalculatorTests.pdb
diff --git a/TaxCalculatorTests/obj/Debug/TaxCalculatorTests.csprojResolveAssemblyReference.cache b/TaxCalculatorTests/obj/Debug/TaxCalculatorTests.csprojResolveAssemblyReference.cache
new file mode 100644
index 0000000..8493443
Binary files /dev/null and b/TaxCalculatorTests/obj/Debug/TaxCalculatorTests.csprojResolveAssemblyReference.cache differ
diff --git a/TaxCalculatorTests/obj/Debug/TaxCalculatorTests.dll b/TaxCalculatorTests/obj/Debug/TaxCalculatorTests.dll
new file mode 100644
index 0000000..b4816af
Binary files /dev/null and b/TaxCalculatorTests/obj/Debug/TaxCalculatorTests.dll differ
diff --git a/TaxCalculatorTests/obj/Debug/TaxCalculatorTests.pdb b/TaxCalculatorTests/obj/Debug/TaxCalculatorTests.pdb
new file mode 100644
index 0000000..a4eedd9
Binary files /dev/null and b/TaxCalculatorTests/obj/Debug/TaxCalculatorTests.pdb differ
diff --git a/TaxCalculatorTests/obj/Debug/TemporaryGeneratedFile_036C0B5B-1481-4323-8D20-8F5ADCB23D92.cs b/TaxCalculatorTests/obj/Debug/TemporaryGeneratedFile_036C0B5B-1481-4323-8D20-8F5ADCB23D92.cs
new file mode 100644
index 0000000..e69de29
diff --git a/TaxCalculatorTests/obj/Debug/TemporaryGeneratedFile_5937a670-0e60-4077-877b-f7221da3dda1.cs b/TaxCalculatorTests/obj/Debug/TemporaryGeneratedFile_5937a670-0e60-4077-877b-f7221da3dda1.cs
new file mode 100644
index 0000000..e69de29
diff --git a/TaxCalculatorTests/obj/Debug/TemporaryGeneratedFile_E7A71F73-0F8D-4B9B-B56E-8E70B10BC5D3.cs b/TaxCalculatorTests/obj/Debug/TemporaryGeneratedFile_E7A71F73-0F8D-4B9B-B56E-8E70B10BC5D3.cs
new file mode 100644
index 0000000..e69de29
diff --git a/TestResults/TaxCalculationApp.TE.Tests.mdf b/TestResults/TaxCalculationApp.TE.Tests.mdf
new file mode 100644
index 0000000..389b500
Binary files /dev/null and b/TestResults/TaxCalculationApp.TE.Tests.mdf differ
diff --git a/TestResults/TaxCalculationApp.TE.Tests_log.ldf b/TestResults/TaxCalculationApp.TE.Tests_log.ldf
new file mode 100644
index 0000000..46b013b
Binary files /dev/null and b/TestResults/TaxCalculationApp.TE.Tests_log.ldf differ
diff --git a/TestResults/TaxCalculator.TE.Tests.mdf b/TestResults/TaxCalculator.TE.Tests.mdf
new file mode 100644
index 0000000..41b38fd
Binary files /dev/null and b/TestResults/TaxCalculator.TE.Tests.mdf differ
diff --git a/TestResults/TaxCalculator.TE.Tests_log.ldf b/TestResults/TaxCalculator.TE.Tests_log.ldf
new file mode 100644
index 0000000..2319239
Binary files /dev/null and b/TestResults/TaxCalculator.TE.Tests_log.ldf differ
diff --git a/build.bat b/build.bat
new file mode 100644
index 0000000..80e726e
--- /dev/null
+++ b/build.bat
@@ -0,0 +1 @@
+c:\Windows\Microsoft.NET\Framework64\v4.0.30319\msbuild.exe TaxCalculationApp.sln /t:Clean,Build
\ No newline at end of file
diff --git a/packages/NUnit.2.6.2/NUnit.2.6.2.nupkg b/packages/NUnit.2.6.2/NUnit.2.6.2.nupkg
new file mode 100644
index 0000000..26f15bd
Binary files /dev/null and b/packages/NUnit.2.6.2/NUnit.2.6.2.nupkg differ
diff --git a/packages/NUnit.2.6.2/NUnit.2.6.2.nuspec b/packages/NUnit.2.6.2/NUnit.2.6.2.nuspec
new file mode 100644
index 0000000..14d86a9
--- /dev/null
+++ b/packages/NUnit.2.6.2/NUnit.2.6.2.nuspec
@@ -0,0 +1,31 @@
+
+
+
+ NUnit
+ 2.6.2
+ NUnit
+ Charlie Poole
+ Charlie Poole
+ http://nunit.org/nuget/license.html
+ http://nunit.org/
+ http://nunit.org/nuget/nunit_32x32.png
+ false
+ NUnit features a fluent assert syntax, parameterized, generic and theory tests and is user-extensible. A number of runners, both from the NUnit project and by third parties, are able to execute NUnit tests.
+
+Version 2.6 is the seventh major release of this well-known and well-tested programming tool.
+
+This package includes only the framework assembly. You will need to install the NUnit.Runners package unless you are using a third-party runner.
+ NUnit is a unit-testing framework for all .Net languages with a strong TDD focus.
+ Version 2.6 is the seventh major release of NUnit.
+
+Unlike earlier versions, this package includes only the framework assembly. You will need to install the NUnit.Runners package unless you are using a third-party runner.
+
+The nunit.mocks assembly is now provided by the NUnit.Mocks package. The pnunit.framework assembly is provided by the pNUnit package.
+
+ en-US
+ test testing tdd framework fluent assert theory plugin addin
+
+
+
+
+
\ No newline at end of file
diff --git a/packages/NUnit.2.6.2/lib/nunit.framework.dll b/packages/NUnit.2.6.2/lib/nunit.framework.dll
new file mode 100644
index 0000000..3e24ba1
Binary files /dev/null and b/packages/NUnit.2.6.2/lib/nunit.framework.dll differ
diff --git a/packages/NUnit.2.6.2/lib/nunit.framework.xml b/packages/NUnit.2.6.2/lib/nunit.framework.xml
new file mode 100644
index 0000000..c0bd9cb
--- /dev/null
+++ b/packages/NUnit.2.6.2/lib/nunit.framework.xml
@@ -0,0 +1,10899 @@
+
+
+
+ nunit.framework
+
+
+
+
+ Attribute used to apply a category to a test
+
+
+
+
+ The name of the category
+
+
+
+
+ Construct attribute for a given category based on
+ a name. The name may not contain the characters ',',
+ '+', '-' or '!'. However, this is not checked in the
+ constructor since it would cause an error to arise at
+ as the test was loaded without giving a clear indication
+ of where the problem is located. The error is handled
+ in NUnitFramework.cs by marking the test as not
+ runnable.
+
+ The name of the category
+
+
+
+ Protected constructor uses the Type name as the name
+ of the category.
+
+
+
+
+ The name of the category
+
+
+
+
+ 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.
+
+
+
+
+ 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.
+
+
+
+
+ Attribute used to provide descriptive text about a
+ test case or fixture.
+
+
+
+
+ Construct the attribute
+
+ Text describing the test
+
+
+
+ Gets the test description
+
+
+
+
+ Enumeration indicating how the expected message parameter is to be used
+
+
+
+ Expect an exact match
+
+
+ Expect a message containing the parameter string
+
+
+ Match the regular expression provided as a parameter
+
+
+ Expect a message that starts with the parameter string
+
+
+
+ ExpectedExceptionAttribute
+
+
+
+
+
+ Constructor for a non-specific exception
+
+
+
+
+ Constructor for a given type of exception
+
+ The type of the expected exception
+
+
+
+ Constructor for a given exception name
+
+ The full name of the expected exception
+
+
+
+ Gets or sets the expected exception type
+
+
+
+
+ Gets or sets the full Type name of the expected exception
+
+
+
+
+ Gets or sets the expected message text
+
+
+
+
+ Gets or sets the user message displayed in case of failure
+
+
+
+
+ Gets or sets the type of match to be performed on the expected message
+
+
+
+
+ Gets the name of a method to be used as an exception handler
+
+
+
+
+ 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.
+
+
+
+
+ Default constructor
+
+
+
+
+ Constructor with a reason
+
+ The reason test is marked explicit
+
+
+
+ The reason test is marked explicit
+
+
+
+
+ Attribute used to mark a test that is to be ignored.
+ Ignored tests result in a warning message when the
+ tests are run.
+
+
+
+
+ Constructs the attribute without giving a reason
+ for ignoring the test.
+
+
+
+
+ Constructs the attribute giving a reason for ignoring the test
+
+ The reason for ignoring the test
+
+
+
+ The reason for ignoring a test
+
+
+
+
+ Abstract base for Attributes that are used to include tests
+ in the test run based on environmental settings.
+
+
+
+
+ Constructor with no included items specified, for use
+ with named property syntax.
+
+
+
+
+ Constructor taking one or more included items
+
+ Comma-delimited list of included items
+
+
+
+ Name of the item that is needed in order for
+ a test to run. Multiple itemss may be given,
+ separated by a comma.
+
+
+
+
+ Name of the item to be excluded. Multiple items
+ may be given, separated by a comma.
+
+
+
+
+ The reason for including or excluding the test
+
+
+
+
+ PlatformAttribute is used to mark a test fixture or an
+ individual method as applying to a particular platform only.
+
+
+
+
+ Constructor with no platforms specified, for use
+ with named property syntax.
+
+
+
+
+ Constructor taking one or more platforms
+
+ Comma-deliminted list of platforms
+
+
+
+ CultureAttribute is used to mark a test fixture or an
+ individual method as applying to a particular Culture only.
+
+
+
+
+ Constructor with no cultures specified, for use
+ with named property syntax.
+
+
+
+
+ Constructor taking one or more cultures
+
+ Comma-deliminted list of cultures
+
+
+
+ Marks a test to use a combinatorial join of any argument data
+ provided. NUnit will create a test case for every combination of
+ the arguments provided. This can result in a large number of test
+ cases and so should be used judiciously. This is the default join
+ type, so the attribute need not be used except as documentation.
+
+
+
+
+ PropertyAttribute is used to attach information to a test as a name/value pair..
+
+
+
+
+ Construct a PropertyAttribute with a name and string value
+
+ The name of the property
+ The property value
+
+
+
+ Construct a PropertyAttribute with a name and int value
+
+ The name of the property
+ The property value
+
+
+
+ Construct a PropertyAttribute with a name and double value
+
+ The name of the property
+ The property value
+
+
+
+ Constructor for derived classes that set the
+ property dictionary directly.
+
+
+
+
+ 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.
+
+
+
+
+ Gets the property dictionary for this attribute
+
+
+
+
+ Default constructor
+
+
+
+
+ Marks a test to use pairwise join of any argument data provided.
+ NUnit will attempt too excercise every pair of argument values at
+ least once, using as small a number of test cases as it can. With
+ only two arguments, this is the same as a combinatorial join.
+
+
+
+
+ Default constructor
+
+
+
+
+ Marks a test to use a sequential join of any argument data
+ provided. NUnit will use arguements for each parameter in
+ sequence, generating test cases up to the largest number
+ of argument values provided and using null for any arguments
+ for which it runs out of values. Normally, this should be
+ used with the same number of arguments for each parameter.
+
+
+
+
+ Default constructor
+
+
+
+
+ Summary description for MaxTimeAttribute.
+
+
+
+
+ Construct a MaxTimeAttribute, given a time in milliseconds.
+
+ The maximum elapsed time in milliseconds
+
+
+
+ RandomAttribute is used to supply a set of random values
+ to a single parameter of a parameterized test.
+
+
+
+
+ ValuesAttribute is used to provide literal arguments for
+ an individual parameter of a test.
+
+
+
+
+ Abstract base class for attributes that apply to parameters
+ and supply data for the parameter.
+
+
+
+
+ Gets the data to be provided to the specified parameter
+
+
+
+
+ The collection of data to be returned. Must
+ be set by any derived attribute classes.
+ We use an object[] so that the individual
+ elements may have their type changed in GetData
+ if necessary.
+
+
+
+
+ Construct with one argument
+
+
+
+
+
+ Construct with two arguments
+
+
+
+
+
+
+ Construct with three arguments
+
+
+
+
+
+
+
+ Construct with an array of arguments
+
+
+
+
+
+ Get the collection of values to be used as arguments
+
+
+
+
+ Construct a set of doubles from 0.0 to 1.0,
+ specifying only the count.
+
+
+
+
+
+ Construct a set of doubles from min to max
+
+
+
+
+
+
+
+ Construct a set of ints from min to max
+
+
+
+
+
+
+
+ Get the collection of values to be used as arguments
+
+
+
+
+ RangeAttribute is used to supply a range of values to an
+ individual parameter of a parameterized test.
+
+
+
+
+ Construct a range of ints using default step of 1
+
+
+
+
+
+
+ Construct a range of ints specifying the step size
+
+
+
+
+
+
+
+ Construct a range of longs
+
+
+
+
+
+
+
+ Construct a range of doubles
+
+
+
+
+
+
+
+ Construct a range of floats
+
+
+
+
+
+
+
+ RepeatAttribute may be applied to test case in order
+ to run it multiple times.
+
+
+
+
+ Construct a RepeatAttribute
+
+ The number of times to run the test
+
+
+
+ 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.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The required addin.
+
+
+
+ Gets the name of required addin.
+
+ The required addin name.
+
+
+
+ Summary description for SetCultureAttribute.
+
+
+
+
+ Construct given the name of a culture
+
+
+
+
+
+ Summary description for SetUICultureAttribute.
+
+
+
+
+ Construct given the name of a culture
+
+
+
+
+
+ SetUpAttribute is used in a TestFixture to identify a method
+ that is called immediately before each test is run. It is
+ also used in a SetUpFixture to identify the method that is
+ called once, before any of the subordinate tests are run.
+
+
+
+
+ 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.
+
+
+
+
+ Attribute used to mark a static (shared in VB) property
+ that returns a list of tests.
+
+
+
+
+ Attribute used in a TestFixture to identify a method that is
+ called immediately after each test is run. It is also used
+ in a SetUpFixture to identify the method that is called once,
+ after all subordinate tests have run. In either case, the method
+ is guaranteed to be called, even if an exception is thrown.
+
+
+
+
+ Provide actions to execute before and after tests.
+
+
+
+
+ When implemented by an attribute, this interface implemented to provide actions to execute before and after tests.
+
+
+
+
+ Executed before each test is run
+
+ Provides details about the test that is going to be run.
+
+
+
+ Executed after each test is run
+
+ Provides details about the test that has just been run.
+
+
+
+ Provides the target for the action attribute
+
+ The target for the action attribute
+
+
+
+ Adding this attribute to a method within a
+ 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.
+
+
+
+ [TestFixture]
+ public class Fixture
+ {
+ [Test]
+ public void MethodToTest()
+ {}
+
+ [Test(Description = "more detailed description")]
+ publc void TestDescriptionMethod()
+ {}
+ }
+
+
+
+
+
+ Descriptive text for this test
+
+
+
+
+ TestCaseAttribute is used to mark parameterized test cases
+ and provide them with their arguments.
+
+
+
+
+ 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.
+
+
+
+
+ Gets the argument list to be provided to the test
+
+
+
+
+ Gets the expected result
+
+
+
+
+ Indicates whether a result has been specified.
+ This is necessary because the result may be
+ null, so it's value cannot be checked.
+
+
+
+
+ Gets the expected exception Type
+
+
+
+
+ Gets the FullName of the expected exception
+
+
+
+
+ Gets the name to be used for the test
+
+
+
+
+ Gets the description of the test
+
+
+
+
+ Gets a value indicating whether this is ignored.
+
+ true if ignored; otherwise, false.
+
+
+
+ Gets a value indicating whether this is explicit.
+
+ true if explicit; otherwise, false.
+
+
+
+ Gets the ignore reason.
+
+ The ignore reason.
+
+
+
+ Construct a TestCaseAttribute with a list of arguments.
+ This constructor is not CLS-Compliant
+
+
+
+
+
+ Construct a TestCaseAttribute with a single argument
+
+
+
+
+
+ Construct a TestCaseAttribute with a two arguments
+
+
+
+
+
+
+ Construct a TestCaseAttribute with a three arguments
+
+
+
+
+
+
+
+ Gets the list of arguments to a test case
+
+
+
+
+ Gets or sets the expected result. Use
+ ExpectedResult by preference.
+
+ The result.
+
+
+
+ Gets or sets the expected result.
+
+ The result.
+
+
+
+ Gets a flag indicating whether an expected
+ result has been set.
+
+
+
+
+ Gets a list of categories associated with this test;
+
+
+
+
+ Gets or sets the category associated with this test.
+ May be a single category or a comma-separated list.
+
+
+
+
+ Gets or sets the expected exception.
+
+ The expected exception.
+
+
+
+ Gets or sets the name the expected exception.
+
+ The expected name of the exception.
+
+
+
+ Gets or sets the expected message of the expected exception
+
+ The expected message of the exception.
+
+
+
+ Gets or sets the type of match to be performed on the expected message
+
+
+
+
+ Gets or sets the description.
+
+ The description.
+
+
+
+ Gets or sets the name of the test.
+
+ The name of the test.
+
+
+
+ Gets or sets the ignored status of the test
+
+
+
+
+ Gets or sets the ignored status of the test
+
+
+
+
+ Gets or sets the explicit status of the test
+
+
+
+
+ Gets or sets the reason for not running the test
+
+
+
+
+ Gets or sets the reason for not running the test.
+ Set has the side effect of marking the test as ignored.
+
+ The ignore reason.
+
+
+
+ FactoryAttribute indicates the source to be used to
+ provide test cases for a test method.
+
+
+
+
+ Construct with the name of the data source, which must
+ be a property, field or method of the test class itself.
+
+ An array of the names of the factories that will provide data
+
+
+
+ Construct with a Type, which must implement IEnumerable
+
+ The Type that will provide data
+
+
+
+ Construct with a Type and name.
+ that don't support params arrays.
+
+ The Type that will provide data
+ The name of the method, property or field that will provide data
+
+
+
+ The name of a the method, property or fiend to be used as a source
+
+
+
+
+ A Type to be used as a source
+
+
+
+
+ Gets or sets the category associated with this test.
+ May be a single category or a comma-separated list.
+
+
+
+
+ [TestFixture]
+ public class ExampleClass
+ {}
+
+
+
+
+ Default constructor
+
+
+
+
+ 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.
+
+
+
+
+
+ Descriptive text for this fixture
+
+
+
+
+ Gets and sets the category for this fixture.
+ May be a comma-separated list of categories.
+
+
+
+
+ Gets a list of categories for this fixture
+
+
+
+
+ The arguments originally provided to the attribute
+
+
+
+
+ Gets or sets a value indicating whether this should be ignored.
+
+ true if ignore; otherwise, false.
+
+
+
+ Gets or sets the ignore reason. May set Ignored as a side effect.
+
+ The ignore reason.
+
+
+
+ Get or set the type arguments. If not set
+ explicitly, any leading arguments that are
+ Types are taken as type arguments.
+
+
+
+
+ Attribute used to identify a method that is
+ called before any tests in a fixture are run.
+
+
+
+
+ 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.
+
+
+
+
+ Adding this attribute to a method within a
+ 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.
+
+
+
+ [TestFixture]
+ public class Fixture
+ {
+ [Test]
+ public void MethodToTest()
+ {}
+
+ [Test(Description = "more detailed description")]
+ publc void TestDescriptionMethod()
+ {}
+ }
+
+
+
+
+
+ Used on a method, marks the test with a timeout value in milliseconds.
+ The test will be run in a separate thread and is cancelled if the timeout
+ is exceeded. Used on a method or assembly, sets the default timeout
+ for all contained test methods.
+
+
+
+
+ Construct a TimeoutAttribute given a time in milliseconds
+
+ The timeout value in milliseconds
+
+
+
+ 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.
+
+
+
+
+ Construct a RequiresSTAAttribute
+
+
+
+
+ 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.
+
+
+
+
+ Construct a RequiresMTAAttribute
+
+
+
+
+ Marks a test that must run on a separate thread.
+
+
+
+
+ Construct a RequiresThreadAttribute
+
+
+
+
+ Construct a RequiresThreadAttribute, specifying the apartment
+
+
+
+
+ ValueSourceAttribute indicates the source to be used to
+ provide data for one parameter of a test method.
+
+
+
+
+ Construct with the name of the factory - for use with languages
+ that don't support params arrays.
+
+ The name of the data source to be used
+
+
+
+ Construct with a Type and name - for use with languages
+ that don't support params arrays.
+
+ The Type that will provide data
+ The name of the method, property or field that will provide data
+
+
+
+ The name of a the method, property or fiend to be used as a source
+
+
+
+
+ A Type to be used as a source
+
+
+
+
+ AttributeExistsConstraint tests for the presence of a
+ specified attribute on a Type.
+
+
+
+
+ The Constraint class is the base of all built-in constraints
+ within NUnit. It provides the operator overloads used to combine
+ constraints.
+
+
+
+
+ The IConstraintExpression interface is implemented by all
+ complete and resolvable constraints and expressions.
+
+
+
+
+ Return the top-level constraint for this expression
+
+
+
+
+
+ Static UnsetObject used to detect derived constraints
+ failing to set the actual value.
+
+
+
+
+ The actual value being tested against a constraint
+
+
+
+
+ The display name of this Constraint for use by ToString()
+
+
+
+
+ Argument fields used by ToString();
+
+
+
+
+ The builder holding this constraint
+
+
+
+
+ Construct a constraint with no arguments
+
+
+
+
+ Construct a constraint with one argument
+
+
+
+
+ Construct a constraint with two arguments
+
+
+
+
+ Sets the ConstraintBuilder holding this constraint
+
+
+
+
+ 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.
+
+ The MessageWriter on which to display the message
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ 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.
+
+ An ActualValueDelegate
+ True for success, false for failure
+
+
+
+ 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.
+
+ A reference to the value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ 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.
+
+ The writer on which the actual value is displayed
+
+
+
+ Default override of ToString returns the constraint DisplayName
+ followed by any arguments within angle brackets.
+
+
+
+
+
+ Returns the string representation of this constraint
+
+
+
+
+ This operator creates a constraint that is satisfied only if both
+ argument constraints are satisfied.
+
+
+
+
+ This operator creates a constraint that is satisfied if either
+ of the argument constraints is satisfied.
+
+
+
+
+ This operator creates a constraint that is satisfied if the
+ argument constraint is not satisfied.
+
+
+
+
+ Returns a DelayedConstraint with the specified delay time.
+
+ The delay in milliseconds.
+
+
+
+
+ Returns a DelayedConstraint with the specified delay time
+ and polling interval.
+
+ The delay in milliseconds.
+ The interval at which to test the constraint.
+
+
+
+
+ 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.
+
+
+
+
+ Returns a ConstraintExpression by appending And
+ to the current constraint.
+
+
+
+
+ Returns a ConstraintExpression by appending And
+ to the current constraint.
+
+
+
+
+ Returns a ConstraintExpression by appending Or
+ to the current constraint.
+
+
+
+
+ Class used to detect any derived constraints
+ that fail to set the actual value in their
+ Matches override.
+
+
+
+
+ Constructs an AttributeExistsConstraint for a specific attribute Type
+
+
+
+
+
+ Tests whether the object provides the expected attribute.
+
+ A Type, MethodInfo, or other ICustomAttributeProvider
+ True if the expected attribute is present, otherwise false
+
+
+
+ Writes the description of the constraint to the specified writer
+
+
+
+
+ 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.
+
+
+
+
+ Abstract base class used for prefixes
+
+
+
+
+ The base constraint
+
+
+
+
+ Construct given a base constraint
+
+
+
+
+
+ Constructs an AttributeConstraint for a specified attriute
+ Type and base constraint.
+
+
+
+
+
+
+ Determines whether the Type or other provider has the
+ expected attribute and if its value matches the
+ additional constraint specified.
+
+
+
+
+ Writes a description of the attribute to the specified writer.
+
+
+
+
+ Writes the actual value supplied to the specified writer.
+
+
+
+
+ Returns a string representation of the constraint.
+
+
+
+
+ BasicConstraint is the abstract base for constraints that
+ perform a simple comparison to a constant value.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected.
+ The description.
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ NullConstraint tests that the actual value is null
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ TrueConstraint tests that the actual value is true
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ FalseConstraint tests that the actual value is false
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ NaNConstraint tests that the actual value is a double or float NaN
+
+
+
+
+ Test that the actual value is an NaN
+
+
+
+
+
+
+ Write the constraint description to a specified writer
+
+
+
+
+
+ BinaryConstraint is the abstract base of all constraints
+ that combine two other constraints in some fashion.
+
+
+
+
+ The first constraint being combined
+
+
+
+
+ The second constraint being combined
+
+
+
+
+ Construct a BinaryConstraint from two other constraints
+
+ The first constraint
+ The second constraint
+
+
+
+ AndConstraint succeeds only if both members succeed.
+
+
+
+
+ Create an AndConstraint from two other constraints
+
+ The first constraint
+ The second constraint
+
+
+
+ Apply both member constraints to an actual value, succeeding
+ succeeding only if both of them succeed.
+
+ The actual value
+ True if the constraints both succeeded
+
+
+
+ Write a description for this contraint to a MessageWriter
+
+ The MessageWriter to receive the description
+
+
+
+ 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.
+
+ The writer on which the actual value is displayed
+
+
+
+ OrConstraint succeeds if either member succeeds
+
+
+
+
+ Create an OrConstraint from two other constraints
+
+ The first constraint
+ The second constraint
+
+
+
+ Apply the member constraints to an actual value, succeeding
+ succeeding as soon as one of them succeeds.
+
+ The actual value
+ True if either constraint succeeded
+
+
+
+ Write a description for this contraint to a MessageWriter
+
+ The MessageWriter to receive the description
+
+
+
+ CollectionConstraint is the abstract base class for
+ constraints that operate on collections.
+
+
+
+
+ Construct an empty CollectionConstraint
+
+
+
+
+ Construct a CollectionConstraint
+
+
+
+
+
+ Determines whether the specified enumerable is empty.
+
+ The enumerable.
+
+ true if the specified enumerable is empty; otherwise, false.
+
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Protected method to be implemented by derived classes
+
+
+
+
+
+
+ CollectionItemsEqualConstraint is the abstract base class for all
+ collection constraints that apply some notion of item equality
+ as a part of their operation.
+
+
+
+
+ Construct an empty CollectionConstraint
+
+
+
+
+ Construct a CollectionConstraint
+
+
+
+
+
+ Flag the constraint to use the supplied IComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied Comparison object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IEqualityComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IEqualityComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Compares two collection members for equality
+
+
+
+
+ Return a new CollectionTally for use in making tests
+
+ The collection to be included in the tally
+
+
+
+ Flag the constraint to ignore case and return self.
+
+
+
+
+ EmptyCollectionConstraint tests whether a collection is empty.
+
+
+
+
+ Check that the collection is empty
+
+
+
+
+
+
+ Write the constraint description to a MessageWriter
+
+
+
+
+
+ UniqueItemsConstraint tests whether all the items in a
+ collection are unique.
+
+
+
+
+ Check that all items are unique.
+
+
+
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+
+
+
+
+ CollectionContainsConstraint is used to test whether a collection
+ contains an expected object as a member.
+
+
+
+
+ Construct a CollectionContainsConstraint
+
+
+
+
+
+ Test whether the expected item is contained in the collection
+
+
+
+
+
+
+ Write a descripton of the constraint to a MessageWriter
+
+
+
+
+
+ CollectionEquivalentCOnstraint is used to determine whether two
+ collections are equivalent.
+
+
+
+
+ Construct a CollectionEquivalentConstraint
+
+
+
+
+
+ Test whether two collections are equivalent
+
+
+
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+
+
+
+
+ CollectionSubsetConstraint is used to determine whether
+ one collection is a subset of another
+
+
+
+
+ Construct a CollectionSubsetConstraint
+
+ The collection that the actual value is expected to be a subset of
+
+
+
+ Test whether the actual collection is a subset of
+ the expected collection provided.
+
+
+
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+
+
+
+
+ CollectionOrderedConstraint is used to test whether a collection is ordered.
+
+
+
+
+ Construct a CollectionOrderedConstraint
+
+
+
+
+ Modifies the constraint to use an IComparer and returns self.
+
+
+
+
+ Modifies the constraint to use an IComparer<T> and returns self.
+
+
+
+
+ Modifies the constraint to use a Comparison<T> and returns self.
+
+
+
+
+ Modifies the constraint to test ordering by the value of
+ a specified property and returns self.
+
+
+
+
+ Test whether the collection is ordered
+
+
+
+
+
+
+ Write a description of the constraint to a MessageWriter
+
+
+
+
+
+ Returns the string representation of the constraint.
+
+
+
+
+
+ If used performs a reverse comparison
+
+
+
+
+ CollectionTally counts (tallies) the number of
+ occurences of each object in one or more enumerations.
+
+
+
+
+ Construct a CollectionTally object from a comparer and a collection
+
+
+
+
+ Try to remove an object from the tally
+
+ The object to remove
+ True if successful, false if the object was not found
+
+
+
+ Try to remove a set of objects from the tally
+
+ The objects to remove
+ True if successful, false if any object was not found
+
+
+
+ The number of objects remaining in the tally
+
+
+
+
+ ComparisonAdapter class centralizes all comparisons of
+ values in NUnit, adapting to the use of any provided
+ IComparer, IComparer<T> or Comparison<T>
+
+
+
+
+ Returns a ComparisonAdapter that wraps an IComparer
+
+
+
+
+ Returns a ComparisonAdapter that wraps an IComparer<T>
+
+
+
+
+ Returns a ComparisonAdapter that wraps a Comparison<T>
+
+
+
+
+ Compares two objects
+
+
+
+
+ Gets the default ComparisonAdapter, which wraps an
+ NUnitComparer object.
+
+
+
+
+ Construct a ComparisonAdapter for an IComparer
+
+
+
+
+ Compares two objects
+
+
+
+
+
+
+
+ Construct a default ComparisonAdapter
+
+
+
+
+ ComparisonAdapter<T> extends ComparisonAdapter and
+ allows use of an IComparer<T> or Comparison<T>
+ to actually perform the comparison.
+
+
+
+
+ Construct a ComparisonAdapter for an IComparer<T>
+
+
+
+
+ Compare a Type T to an object
+
+
+
+
+ Construct a ComparisonAdapter for a Comparison<T>
+
+
+
+
+ Compare a Type T to an object
+
+
+
+
+ Abstract base class for constraints that compare values to
+ determine if one is greater than, equal to or less than
+ the other. This class supplies the Using modifiers.
+
+
+
+
+ ComparisonAdapter to be used in making the comparison
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ Modifies the constraint to use an IComparer and returns self
+
+
+
+
+ Modifies the constraint to use an IComparer<T> and returns self
+
+
+
+
+ Modifies the constraint to use a Comparison<T> and returns self
+
+
+
+
+ Delegate used to delay evaluation of the actual value
+ to be used in evaluating a constraint
+
+
+
+
+ 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.
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ Appends the specified operator to the expression by first
+ reducing the operator stack and then pushing the new
+ operator on the stack.
+
+ The operator to push.
+
+
+
+ Appends the specified constraint to the expresson by pushing
+ it on the constraint stack.
+
+ The constraint to push.
+
+
+
+ Sets the top operator right context.
+
+ The right context.
+
+
+
+ Reduces the operator stack until the topmost item
+ precedence is greater than or equal to the target precedence.
+
+ The target precedence.
+
+
+
+ Resolves this instance, returning a Constraint. If the builder
+ is not currently in a resolvable state, an exception is thrown.
+
+ The resolved constraint
+
+
+
+ Gets a value indicating whether this instance is resolvable.
+
+
+ true if this instance is resolvable; otherwise, false.
+
+
+
+
+ OperatorStack is a type-safe stack for holding ConstraintOperators
+
+
+
+
+ Initializes a new instance of the class.
+
+ The builder.
+
+
+
+ Pushes the specified operator onto the stack.
+
+ The op.
+
+
+
+ Pops the topmost operator from the stack.
+
+
+
+
+
+ Gets a value indicating whether this is empty.
+
+ true if empty; otherwise, false.
+
+
+
+ Gets the topmost operator without modifying the stack.
+
+ The top.
+
+
+
+ ConstraintStack is a type-safe stack for holding Constraints
+
+
+
+
+ Initializes a new instance of the class.
+
+ The builder.
+
+
+
+ Pushes the specified constraint. As a side effect,
+ the constraint's builder field is set to the
+ ConstraintBuilder owning this stack.
+
+ The constraint.
+
+
+
+ Pops this topmost constrait from the stack.
+ As a side effect, the constraint's builder
+ field is set to null.
+
+
+
+
+
+ Gets a value indicating whether this is empty.
+
+ true if empty; otherwise, false.
+
+
+
+ Gets the topmost constraint without modifying the stack.
+
+ The topmost constraint
+
+
+
+ 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.
+
+
+
+
+ ConstraintExpressionBase is the abstract base class for the
+ ConstraintExpression class, which represents a
+ compound constraint in the process of being constructed
+ from a series of syntactic elements.
+
+ NOTE: ConstraintExpressionBase is separate because the
+ ConstraintExpression class was generated in earlier
+ versions of NUnit. The two classes may be combined
+ in a future version.
+
+
+
+
+ The ConstraintBuilder holding the elements recognized so far
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ Initializes a new instance of the
+ class passing in a ConstraintBuilder, which may be pre-populated.
+
+ The builder.
+
+
+
+ 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.
+
+
+
+
+
+ Appends an operator to the expression and returns the
+ resulting expression itself.
+
+
+
+
+ Appends a self-resolving operator to the expression and
+ returns a new ResolvableConstraintExpression.
+
+
+
+
+ Appends a constraint to the expression and returns that
+ constraint, which is associated with the current state
+ of the expression being built.
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ Initializes a new instance of the
+ class passing in a ConstraintBuilder, which may be pre-populated.
+
+ The builder.
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding only if a specified number of them succeed.
+
+
+
+
+ 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.
+
+
+
+
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+
+
+
+
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+
+
+
+
+ Returns the constraint provided as an argument - used to allow custom
+ custom constraints to easily participate in the syntax.
+
+
+
+
+ Returns the constraint provided as an argument - used to allow custom
+ custom constraints to easily participate in the syntax.
+
+
+
+
+ Returns a constraint that tests two items for equality
+
+
+
+
+ Returns a constraint that tests that two references are the same object
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is greater than the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is less than the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is a collection containing the same elements as the
+ collection supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is a subset of the collection supplied as an argument.
+
+
+
+
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+
+
+
+
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+
+
+
+
+ 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.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the path provided
+ is the same as an expected path after canonicalization.
+
+
+
+
+ Returns a constraint that tests whether the path provided
+ is the same path or under an expected path after canonicalization.
+
+
+
+
+ Returns a constraint that tests whether the path provided
+ is the same path or under an expected path after canonicalization.
+
+
+
+
+ Returns a constraint that tests whether the actual value falls
+ within a specified range.
+
+
+
+
+ Returns a ConstraintExpression that negates any
+ following constraint.
+
+
+
+
+ Returns a ConstraintExpression that negates any
+ following constraint.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if at least one of them succeeds.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them fail.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Length property of the object being tested.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Count property of the object being tested.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Message property of the object being tested.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the InnerException property of the object being tested.
+
+
+
+
+ With is currently a NOP - reserved for future use.
+
+
+
+
+ Returns a constraint that tests for null
+
+
+
+
+ Returns a constraint that tests for True
+
+
+
+
+ Returns a constraint that tests for False
+
+
+
+
+ Returns a constraint that tests for a positive value
+
+
+
+
+ Returns a constraint that tests for a negative value
+
+
+
+
+ Returns a constraint that tests for NaN
+
+
+
+
+ Returns a constraint that tests for empty
+
+
+
+
+ Returns a constraint that tests whether a collection
+ contains all unique items.
+
+
+
+
+ Returns a constraint that tests whether an object graph is serializable in binary format.
+
+
+
+
+ Returns a constraint that tests whether an object graph is serializable in xml format.
+
+
+
+
+ Returns a constraint that tests whether a collection is ordered
+
+
+
+
+ Helper class with properties and methods that supply
+ a number of constraints used in Asserts.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding only if a specified number of them succeed.
+
+
+
+
+ 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.
+
+
+
+
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+
+
+
+
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+
+
+
+
+ Returns a constraint that tests two items for equality
+
+
+
+
+ Returns a constraint that tests that two references are the same object
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is greater than the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is less than the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is a collection containing the same elements as the
+ collection supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is a subset of the collection supplied as an argument.
+
+
+
+
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+
+
+
+
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+
+
+
+
+ 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.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that fails if the actual
+ value contains the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that fails if the actual
+ value starts with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that fails if the actual
+ value ends with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+
+
+
+
+ Returns a constraint that fails if the actual
+ value matches the pattern supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the path provided
+ is the same as an expected path after canonicalization.
+
+
+
+
+ Returns a constraint that tests whether the path provided
+ is the same path or under an expected path after canonicalization.
+
+
+
+
+ Returns a constraint that tests whether the path provided
+ is the same path or under an expected path after canonicalization.
+
+
+
+
+ Returns a constraint that tests whether the actual value falls
+ within a specified range.
+
+
+
+
+ Returns a ConstraintExpression that negates any
+ following constraint.
+
+
+
+
+ Returns a ConstraintExpression that negates any
+ following constraint.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if at least one of them succeeds.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them fail.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Length property of the object being tested.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Count property of the object being tested.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Message property of the object being tested.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the InnerException property of the object being tested.
+
+
+
+
+ Returns a constraint that tests for null
+
+
+
+
+ Returns a constraint that tests for True
+
+
+
+
+ Returns a constraint that tests for False
+
+
+
+
+ Returns a constraint that tests for a positive value
+
+
+
+
+ Returns a constraint that tests for a negative value
+
+
+
+
+ Returns a constraint that tests for NaN
+
+
+
+
+ Returns a constraint that tests for empty
+
+
+
+
+ Returns a constraint that tests whether a collection
+ contains all unique items.
+
+
+
+
+ Returns a constraint that tests whether an object graph is serializable in binary format.
+
+
+
+
+ Returns a constraint that tests whether an object graph is serializable in xml format.
+
+
+
+
+ Returns a constraint that tests whether a collection is ordered
+
+
+
+
+ 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.
+
+
+
+
+ The precedence value used when the operator
+ is about to be pushed to the stack.
+
+
+
+
+ The precedence value used when the operator
+ is on the top of the stack.
+
+
+
+
+ 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.
+
+
+
+
+
+ The syntax element preceding this operator
+
+
+
+
+ The syntax element folowing this operator
+
+
+
+
+ The precedence value used when the operator
+ is about to be pushed to the stack.
+
+
+
+
+ The precedence value used when the operator
+ is on the top of the stack.
+
+
+
+
+ PrefixOperator takes a single constraint and modifies
+ it's action in some way.
+
+
+
+
+ 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.
+
+
+
+
+
+ Returns the constraint created by applying this
+ prefix to another constraint.
+
+
+
+
+
+
+ Negates the test of the constraint it wraps.
+
+
+
+
+ Constructs a new NotOperator
+
+
+
+
+ Returns a NotConstraint applied to its argument.
+
+
+
+
+ Abstract base for operators that indicate how to
+ apply a constraint to items in a collection.
+
+
+
+
+ Constructs a CollectionOperator
+
+
+
+
+ Represents a constraint that succeeds if all the
+ members of a collection match a base constraint.
+
+
+
+
+ Returns a constraint that will apply the argument
+ to the members of a collection, succeeding if
+ they all succeed.
+
+
+
+
+ Represents a constraint that succeeds if any of the
+ members of a collection match a base constraint.
+
+
+
+
+ Returns a constraint that will apply the argument
+ to the members of a collection, succeeding if
+ any of them succeed.
+
+
+
+
+ Represents a constraint that succeeds if none of the
+ members of a collection match a base constraint.
+
+
+
+
+ Returns a constraint that will apply the argument
+ to the members of a collection, succeeding if
+ none of them succeed.
+
+
+
+
+ Represents a constraint that succeeds if the specified
+ count of members of a collection match a base constraint.
+
+
+
+
+ Construct an ExactCountOperator for a specified count
+
+ The expected count
+
+
+
+ Returns a constraint that will apply the argument
+ to the members of a collection, succeeding if
+ none of them succeed.
+
+
+
+
+ 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.
+
+
+
+
+ Constructor for the WithOperator
+
+
+
+
+ Returns a constraint that wraps its argument
+
+
+
+
+ Abstract base class for operators that are able to reduce to a
+ constraint whether or not another syntactic element follows.
+
+
+
+
+ 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.
+
+
+
+
+ Constructs a PropOperator for a particular named property
+
+
+
+
+ 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.
+
+
+
+
+
+ Gets the name of the property to which the operator applies
+
+
+
+
+ Operator that tests for the presence of a particular attribute
+ on a type and optionally applies further tests to the attribute.
+
+
+
+
+ Construct an AttributeOperator for a particular Type
+
+ The Type of attribute tested
+
+
+
+ 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.
+
+
+
+
+ Operator that tests that an exception is thrown and
+ optionally applies further tests to the exception.
+
+
+
+
+ Construct a ThrowsOperator
+
+
+
+
+ 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.
+
+
+
+
+ Abstract base class for all binary operators
+
+
+
+
+ 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.
+
+
+
+
+
+ Abstract method that produces a constraint by applying
+ the operator to its left and right constraint arguments.
+
+
+
+
+ Gets the left precedence of the operator
+
+
+
+
+ Gets the right precedence of the operator
+
+
+
+
+ Operator that requires both it's arguments to succeed
+
+
+
+
+ Construct an AndOperator
+
+
+
+
+ Apply the operator to produce an AndConstraint
+
+
+
+
+ Operator that requires at least one of it's arguments to succeed
+
+
+
+
+ Construct an OrOperator
+
+
+
+
+ Apply the operator to produce an OrConstraint
+
+
+
+
+ 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.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected.
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ Flag the constraint to use the supplied IComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied Comparison object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IEqualityComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IEqualityComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to ignore case and return self.
+
+
+
+
+ Applies a delay to the match so that a match can be evaluated in the future.
+
+
+
+
+ Creates a new DelayedConstraint
+
+ The inner constraint two decorate
+ The time interval after which the match is performed
+ If the value of is less than 0
+
+
+
+ Creates a new DelayedConstraint
+
+ The inner constraint two decorate
+ The time interval after which the match is performed
+ The time interval used for polling
+ If the value of is less than 0
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for if the base constraint fails, false if it succeeds
+
+
+
+ Test whether the constraint is satisfied by a delegate
+
+ The delegate whose value is to be tested
+ True for if the base constraint fails, false if it succeeds
+
+
+
+ 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.
+
+ A reference to the value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ Write the actual value for a failing constraint test to a MessageWriter.
+
+ The writer on which the actual value is displayed
+
+
+
+ Returns the string representation of the constraint.
+
+
+
+
+ EmptyDirectoryConstraint is used to test that a directory is empty
+
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ 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.
+
+ The writer on which the actual value is displayed
+
+
+
+ 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.
+
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ 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.
+
+
+
+
+ If true, strings in error messages will be clipped
+
+
+
+
+ NUnitEqualityComparer used to test equality.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected value.
+
+
+
+ Flag the constraint to use a tolerance when determining equality.
+
+ Tolerance value to be used
+ Self.
+
+
+
+ Flag the constraint to use the supplied IComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied Comparison object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IEqualityComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Flag the constraint to use the supplied IEqualityComparer object.
+
+ The IComparer object to use.
+ Self.
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write a failure message. Overridden to provide custom
+ failure messages for EqualConstraint.
+
+ The MessageWriter to write to
+
+
+
+ Write description of this constraint
+
+ The MessageWriter to write to
+
+
+
+ Display the failure information for two collections that did not match.
+
+ The MessageWriter on which to display
+ The expected collection.
+ The actual collection
+ The depth of this failure in a set of nested collections
+
+
+
+ Displays a single line showing the types and sizes of the expected
+ and actual enumerations, collections or arrays. If both are identical,
+ the value is only shown once.
+
+ The MessageWriter on which to display
+ The expected collection or array
+ The actual collection or array
+ The indentation level for the message line
+
+
+
+ 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.
+
+ The MessageWriter on which to display
+ The expected array
+ The actual array
+ Index of the failure point in the underlying collections
+ The indentation level for the message line
+
+
+
+ Display the failure information for two IEnumerables that did not match.
+
+ The MessageWriter on which to display
+ The expected enumeration.
+ The actual enumeration
+ The depth of this failure in a set of nested collections
+
+
+
+ Flag the constraint to ignore case and return self.
+
+
+
+
+ Flag the constraint to suppress string clipping
+ and return self.
+
+
+
+
+ Flag the constraint to compare arrays as collections
+ and return self.
+
+
+
+
+ Switches the .Within() modifier to interpret its tolerance as
+ a distance in representable values (see remarks).
+
+ Self.
+
+ 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.
+
+
+
+
+ Switches the .Within() modifier to interpret its tolerance as
+ a percentage that the actual values is allowed to deviate from
+ the expected value.
+
+ Self
+
+
+
+ Causes the tolerance to be interpreted as a TimeSpan in days.
+
+ Self
+
+
+
+ Causes the tolerance to be interpreted as a TimeSpan in hours.
+
+ Self
+
+
+
+ Causes the tolerance to be interpreted as a TimeSpan in minutes.
+
+ Self
+
+
+
+ Causes the tolerance to be interpreted as a TimeSpan in seconds.
+
+ Self
+
+
+
+ Causes the tolerance to be interpreted as a TimeSpan in milliseconds.
+
+ Self
+
+
+
+ Causes the tolerance to be interpreted as a TimeSpan in clock ticks.
+
+ Self
+
+
+
+ EqualityAdapter class handles all equality comparisons
+ that use an IEqualityComparer, IEqualityComparer<T>
+ or a ComparisonAdapter.
+
+
+
+
+ Compares two objects, returning true if they are equal
+
+
+
+
+ Returns true if the two objects can be compared by this adapter.
+ The base adapter cannot handle IEnumerables except for strings.
+
+
+
+
+ Returns an EqualityAdapter that wraps an IComparer.
+
+
+
+
+ Returns an EqualityAdapter that wraps an IEqualityComparer.
+
+
+
+
+ Returns an EqualityAdapter that wraps an IEqualityComparer<T>.
+
+
+
+
+ Returns an EqualityAdapter that wraps an IComparer<T>.
+
+
+
+
+ Returns an EqualityAdapter that wraps a Comparison<T>.
+
+
+
+
+ EqualityAdapter that wraps an IComparer.
+
+
+
+
+ Returns true if the two objects can be compared by this adapter.
+ Generic adapter requires objects of the specified type.
+
+
+
+
+ EqualityAdapter that wraps an IComparer.
+
+
+
+ Helper routines for working with floating point numbers
+
+
+ The floating point comparison code is based on this excellent article:
+ http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm
+
+
+ "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.
+
+
+ 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.
+
+
+
+
+ Compares two floating point values for equality
+ First floating point value to be compared
+ Second floating point value t be compared
+
+ Maximum number of representable floating point values that are allowed to
+ be between the left and the right floating point values
+
+ True if both numbers are equal or close to being equal
+
+
+ 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.
+
+
+ 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.
+
+
+ Implementation partially follows the code outlined here:
+ http://www.anttirt.net/2007/08/19/proper-floating-point-comparisons/
+
+
+
+
+ Compares two double precision floating point values for equality
+ First double precision floating point value to be compared
+ Second double precision floating point value t be compared
+
+ 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
+
+ True if both numbers are equal or close to being equal
+
+
+ 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.
+
+
+ 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.
+
+
+ Implementation partially follows the code outlined here:
+ http://www.anttirt.net/2007/08/19/proper-floating-point-comparisons/
+
+
+
+
+
+ Reinterprets the memory contents of a floating point value as an integer value
+
+
+ Floating point value whose memory contents to reinterpret
+
+
+ The memory contents of the floating point value interpreted as an integer
+
+
+
+
+ Reinterprets the memory contents of a double precision floating point
+ value as an integer value
+
+
+ Double precision floating point value whose memory contents to reinterpret
+
+
+ The memory contents of the double precision floating point value
+ interpreted as an integer
+
+
+
+
+ Reinterprets the memory contents of an integer as a floating point value
+
+ Integer value whose memory contents to reinterpret
+
+ The memory contents of the integer value interpreted as a floating point value
+
+
+
+
+ Reinterprets the memory contents of an integer value as a double precision
+ floating point value
+
+ Integer whose memory contents to reinterpret
+
+ The memory contents of the integer interpreted as a double precision
+ floating point value
+
+
+
+ Union of a floating point variable and an integer
+
+
+ The union's value as a floating point variable
+
+
+ The union's value as an integer
+
+
+ The union's value as an unsigned integer
+
+
+ Union of a double precision floating point variable and a long
+
+
+ The union's value as a double precision floating point variable
+
+
+ The union's value as a long
+
+
+ The union's value as an unsigned long
+
+
+
+ Tests whether a value is greater than the value supplied to its constructor
+
+
+
+
+ The value against which a comparison is to be made
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected value.
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Tests whether a value is greater than or equal to the value supplied to its constructor
+
+
+
+
+ The value against which a comparison is to be made
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected value.
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Tests whether a value is less than the value supplied to its constructor
+
+
+
+
+ The value against which a comparison is to be made
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected value.
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Tests whether a value is less than or equal to the value supplied to its constructor
+
+
+
+
+ The value against which a comparison is to be made
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected value.
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ 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.
+
+
+
+
+ Construct a MessageWriter given a culture
+
+
+
+
+ Method to write single line message with optional args, usually
+ written to precede the general failure message.
+
+ The message to be written
+ Any arguments used in formatting the message
+
+
+
+ Method to write single line message with optional args, usually
+ written to precede the general failure message, at a givel
+ indentation level.
+
+ The indentation level of the message
+ The message to be written
+ Any arguments used in formatting the message
+
+
+
+ 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.
+
+ The constraint that failed
+
+
+
+ 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.
+
+ The expected value
+ The actual value causing the failure
+
+
+
+ Display Expected and Actual lines for given values, including
+ a tolerance value on the Expected line.
+
+ The expected value
+ The actual value causing the failure
+ The tolerance within which the test was made
+
+
+
+ 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.
+
+ The expected string value
+ The actual string value
+ The point at which the strings don't match or -1
+ If true, case is ignored in locating the point where the strings differ
+ If true, the strings should be clipped to fit the line
+
+
+
+ Writes the text for a connector.
+
+ The connector.
+
+
+
+ Writes the text for a predicate.
+
+ The predicate.
+
+
+
+ Writes the text for an expected value.
+
+ The expected value.
+
+
+
+ Writes the text for a modifier
+
+ The modifier.
+
+
+
+ Writes the text for an actual value.
+
+ The actual value.
+
+
+
+ Writes the text for a generalized value.
+
+ The value.
+
+
+
+ Writes the text for a collection value,
+ starting at a particular point, to a max length
+
+ The collection containing elements to write.
+ The starting point of the elements to write
+ The maximum number of elements to write
+
+
+
+ Abstract method to get the max line length
+
+
+
+
+ Static methods used in creating messages
+
+
+
+
+ Static string used when strings are clipped
+
+
+
+
+ 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.
+
+
+
+
+
+
+ Converts any control characters in a string
+ to their escaped representation.
+
+ The string to be converted
+ The converted string
+
+
+
+ Return the a string representation for a set of indices into an array
+
+ Array of indices for which a string is needed
+
+
+
+ Get an array of indices representing the point in a enumerable,
+ collection or array corresponding to a single int index into the
+ collection.
+
+ The collection to which the indices apply
+ Index in the collection
+ Array of indices
+
+
+
+ Clip a string to a given length, starting at a particular offset, returning the clipped
+ string with ellipses representing the removed parts
+
+ The string to be clipped
+ The maximum permitted length of the result string
+ The point at which to start clipping
+ The clipped string
+
+
+
+ Clip the expected and actual strings in a coordinated fashion,
+ so that they may be displayed together.
+
+
+
+
+
+
+
+
+ Shows the position two strings start to differ. Comparison
+ starts at the start index.
+
+ The expected string
+ The actual string
+ The index in the strings at which comparison should start
+ Boolean indicating whether case should be ignored
+ -1 if no mismatch found, or the index where mismatch found
+
+
+
+ The Numerics class contains common operations on numeric values.
+
+
+
+
+ Checks the type of the object, returning true if
+ the object is a numeric type.
+
+ The object to check
+ true if the object is a numeric type
+
+
+
+ Checks the type of the object, returning true if
+ the object is a floating point numeric type.
+
+ The object to check
+ true if the object is a floating point numeric type
+
+
+
+ Checks the type of the object, returning true if
+ the object is a fixed point numeric type.
+
+ The object to check
+ true if the object is a fixed point numeric type
+
+
+
+ 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.
+
+ The expected value
+ The actual value
+ A reference to the tolerance in effect
+ True if the values are equal
+
+
+
+ Compare two numeric values, performing the usual numeric conversions.
+
+ The expected value
+ The actual value
+ The relationship of the values to each other
+
+
+
+ NUnitComparer encapsulates NUnit's default behavior
+ in comparing two objects.
+
+
+
+
+ Compares two objects
+
+
+
+
+
+
+
+ Returns the default NUnitComparer.
+
+
+
+
+ Generic version of NUnitComparer
+
+
+
+
+
+ Compare two objects of the same type
+
+
+
+
+ NUnitEqualityComparer encapsulates NUnit's handling of
+ equality tests between objects.
+
+
+
+
+
+
+
+
+
+ Compares two objects for equality within a tolerance
+
+ The first object to compare
+ The second object to compare
+ The tolerance to use in the comparison
+
+
+
+
+ If true, all string comparisons will ignore case
+
+
+
+
+ If true, arrays will be treated as collections, allowing
+ those of different dimensions to be compared
+
+
+
+
+ Comparison objects used in comparisons for some constraints.
+
+
+
+
+ Compares two objects for equality within a tolerance.
+
+
+
+
+ Helper method to compare two arrays
+
+
+
+
+ Method to compare two DirectoryInfo objects
+
+ first directory to compare
+ second directory to compare
+ true if equivalent, false if not
+
+
+
+ Returns the default NUnitEqualityComparer
+
+
+
+
+ Gets and sets a flag indicating whether case should
+ be ignored in determining equality.
+
+
+
+
+ Gets and sets a flag indicating that arrays should be
+ compared as collections, without regard to their shape.
+
+
+
+
+ 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.
+
+
+
+
+ Gets the list of failure points for the last Match performed.
+
+
+
+
+ FailurePoint class represents one point of failure
+ in an equality test.
+
+
+
+
+ The location of the failure
+
+
+
+
+ The expected value
+
+
+
+
+ The actual value
+
+
+
+
+ Indicates whether the expected value is valid
+
+
+
+
+ Indicates whether the actual value is valid
+
+
+
+
+ PathConstraint serves as the abstract base of constraints
+ that operate on paths and provides several helper methods.
+
+
+
+
+ The expected path used in the constraint
+
+
+
+
+ The actual path being tested
+
+
+
+
+ Flag indicating whether a caseInsensitive comparison should be made
+
+
+
+
+ Construct a PathConstraint for a give expected path
+
+ The expected path
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Returns true if the expected path and actual path match
+
+
+
+
+ Returns the string representation of this constraint
+
+
+
+
+ Canonicalize the provided path
+
+
+ The path in standardized form
+
+
+
+ Test whether two paths are the same
+
+ The first path
+ The second path
+ Indicates whether case should be ignored
+
+
+
+
+ Test whether one path is under another path
+
+ The first path - supposed to be the parent path
+ The second path - supposed to be the child path
+ Indicates whether case should be ignored
+
+
+
+
+ Test whether one path is the same as or under another path
+
+ The first path - supposed to be the parent path
+ The second path - supposed to be the child path
+
+
+
+
+ Modifies the current instance to be case-insensitve
+ and returns it.
+
+
+
+
+ Modifies the current instance to be case-sensitve
+ and returns it.
+
+
+
+
+ Summary description for SamePathConstraint.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected path
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The expected path
+ The actual path
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ SubPathConstraint tests that the actual path is under the expected path
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected path
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The expected path
+ The actual path
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ SamePathOrUnderConstraint tests that one path is under another
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected path
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The expected path
+ The actual path
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ Predicate constraint wraps a Predicate in a constraint,
+ returning success if the predicate is true.
+
+
+
+
+ Construct a PredicateConstraint from a predicate
+
+
+
+
+ Determines whether the predicate succeeds when applied
+ to the actual value.
+
+
+
+
+ Writes the description to a MessageWriter
+
+
+
+
+ NotConstraint negates the effect of some other constraint
+
+
+
+
+ Initializes a new instance of the class.
+
+ The base constraint to be negated.
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for if the base constraint fails, false if it succeeds
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ Write the actual value for a failing constraint test to a MessageWriter.
+
+ The writer on which the actual value is displayed
+
+
+
+ AllItemsConstraint applies another constraint to each
+ item in a collection, succeeding if they all succeed.
+
+
+
+
+ Construct an AllItemsConstraint on top of an existing constraint
+
+
+
+
+
+ Apply the item constraint to each item in the collection,
+ failing if any item fails.
+
+
+
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+
+
+
+
+ SomeItemsConstraint applies another constraint to each
+ item in a collection, succeeding if any of them succeeds.
+
+
+
+
+ Construct a SomeItemsConstraint on top of an existing constraint
+
+
+
+
+
+ Apply the item constraint to each item in the collection,
+ succeeding if any item succeeds.
+
+
+
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+
+
+
+
+ NoItemConstraint applies another constraint to each
+ item in a collection, failing if any of them succeeds.
+
+
+
+
+ Construct a NoItemConstraint on top of an existing constraint
+
+
+
+
+
+ Apply the item constraint to each item in the collection,
+ failing if any item fails.
+
+
+
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+
+
+
+
+ ExactCoutConstraint applies another constraint to each
+ item in a collection, succeeding only if a specified
+ number of items succeed.
+
+
+
+
+ Construct an ExactCountConstraint on top of an existing constraint
+
+
+
+
+
+
+ Apply the item constraint to each item in the collection,
+ succeeding only if the expected number of items pass.
+
+
+
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+
+
+
+
+ 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.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The name of the property.
+
+
+
+ Test whether the property exists for a given object
+
+ The object to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ Write the actual value for a failing constraint test to a
+ MessageWriter.
+
+ The writer on which the actual value is displayed
+
+
+
+ Returns the string representation of the constraint.
+
+
+
+
+
+ PropertyConstraint extracts a named property and uses
+ its value as the actual value for a chained constraint.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The name.
+ The constraint to apply to the property.
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ 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.
+
+ The writer on which the actual value is displayed
+
+
+
+ Returns the string representation of the constraint.
+
+
+
+
+
+ RangeConstraint tests whethe two values are within a
+ specified range.
+
+
+
+
+ Initializes a new instance of the class.
+
+ From.
+ To.
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ 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.
+
+
+
+
+ Create a new instance of ResolvableConstraintExpression
+
+
+
+
+ Create a new instance of ResolvableConstraintExpression,
+ passing in a pre-populated ConstraintBuilder.
+
+
+
+
+ Resolve the current expression to a Constraint
+
+
+
+
+ This operator creates a constraint that is satisfied only if both
+ argument constraints are satisfied.
+
+
+
+
+ This operator creates a constraint that is satisfied only if both
+ argument constraints are satisfied.
+
+
+
+
+ This operator creates a constraint that is satisfied only if both
+ argument constraints are satisfied.
+
+
+
+
+ This operator creates a constraint that is satisfied if either
+ of the argument constraints is satisfied.
+
+
+
+
+ This operator creates a constraint that is satisfied if either
+ of the argument constraints is satisfied.
+
+
+
+
+ This operator creates a constraint that is satisfied if either
+ of the argument constraints is satisfied.
+
+
+
+
+ This operator creates a constraint that is satisfied if the
+ argument constraint is not satisfied.
+
+
+
+
+ Appends an And Operator to the expression
+
+
+
+
+ Appends an Or operator to the expression.
+
+
+
+
+ ReusableConstraint wraps a resolved constraint so that it
+ may be saved and reused as needed.
+
+
+
+
+ Construct a ReusableConstraint
+
+ The constraint or expression to be reused
+
+
+
+ Conversion operator from a normal constraint to a ReusableConstraint.
+
+ The original constraint to be wrapped as a ReusableConstraint
+
+
+
+
+ Returns the string representation of the constraint.
+
+ A string representing the constraint
+
+
+
+ Resolves the ReusableConstraint by returning the constraint
+ that it originally wrapped.
+
+ A resolved constraint
+
+
+
+ SameAsConstraint tests whether an object is identical to
+ the object passed to its constructor
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected object.
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ BinarySerializableConstraint tests whether
+ an object is serializable in binary format.
+
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ 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.
+
+ The writer on which the actual value is displayed
+
+
+
+ Returns the string representation
+
+
+
+
+ BinarySerializableConstraint tests whether
+ an object is serializable in binary format.
+
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ 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.
+
+ The writer on which the actual value is displayed
+
+
+
+ Returns the string representation of this constraint
+
+
+
+
+ StringConstraint is the abstract base for constraints
+ that operate on strings. It supports the IgnoreCase
+ modifier for string operations.
+
+
+
+
+ The expected value
+
+
+
+
+ Indicates whether tests should be case-insensitive
+
+
+
+
+ Constructs a StringConstraint given an expected value
+
+ The expected value
+
+
+
+ Modify the constraint to ignore case in matching.
+
+
+
+
+ EmptyStringConstraint tests whether a string is empty.
+
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ NullEmptyStringConstraint tests whether a string is either null or empty.
+
+
+
+
+ Constructs a new NullOrEmptyStringConstraint
+
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ SubstringConstraint can test whether a string contains
+ the expected substring.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected.
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ StartsWithConstraint can test whether a string starts
+ with an expected substring.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected string
+
+
+
+ Test whether the constraint is matched by the actual value.
+ This is a template method, which calls the IsMatch method
+ of the derived class.
+
+
+
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ EndsWithConstraint can test whether a string ends
+ with an expected substring.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expected string
+
+
+
+ Test whether the constraint is matched by the actual value.
+ This is a template method, which calls the IsMatch method
+ of the derived class.
+
+
+
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ RegexConstraint can test whether a string matches
+ the pattern provided.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The pattern.
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True for success, false for failure
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ ThrowsConstraint is used to test the exception thrown by
+ a delegate by applying a constraint to it.
+
+
+
+
+ Initializes a new instance of the class,
+ using a constraint to be applied to the exception.
+
+ A constraint to apply to the caught exception.
+
+
+
+ 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.
+
+ A delegate representing the code to be tested
+ True if an exception is thrown and the constraint succeeds, otherwise false
+
+
+
+ Converts an ActualValueDelegate to a TestDelegate
+ before calling the primary overload.
+
+
+
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ 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.
+
+ The writer on which the actual value is displayed
+
+
+
+ Returns the string representation of this constraint
+
+
+
+
+ Get the actual exception thrown - used by Assert.Throws.
+
+
+
+
+ ThrowsNothingConstraint tests that a delegate does not
+ throw an exception.
+
+
+
+
+ Test whether the constraint is satisfied by a given value
+
+ The value to be tested
+ True if no exception is thrown, otherwise false
+
+
+
+ Converts an ActualValueDelegate to a TestDelegate
+ before calling the primary overload.
+
+
+
+
+
+
+ Write the constraint description to a MessageWriter
+
+ The writer on which the description is displayed
+
+
+
+ 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.
+
+ The writer on which the actual value is displayed
+
+
+
+ Modes in which the tolerance value for a comparison can
+ be interpreted.
+
+
+
+
+ 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.
+
+
+
+
+ The tolerance is used as a numeric range within which
+ two compared values are considered to be equal.
+
+
+
+
+ Interprets the tolerance as the percentage by which
+ the two compared values my deviate from each other.
+
+
+
+
+ Compares two values based in their distance in
+ representable numbers.
+
+
+
+
+ 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.
+
+
+
+
+ Constructs a linear tolerance of a specdified amount
+
+
+
+
+ Constructs a tolerance given an amount and ToleranceMode
+
+
+
+
+ Tests that the current Tolerance is linear with a
+ numeric value, throwing an exception if it is not.
+
+
+
+
+ Returns an empty Tolerance object, equivalent to
+ specifying no tolerance. In most cases, it results
+ in an exact match but for floats and doubles a
+ default tolerance may be used.
+
+
+
+
+ Returns a zero Tolerance object, equivalent to
+ specifying an exact match.
+
+
+
+
+ Gets the ToleranceMode for the current Tolerance
+
+
+
+
+ Gets the value of the current Tolerance instance.
+
+
+
+
+ Returns a new tolerance, using the current amount as a percentage.
+
+
+
+
+ Returns a new tolerance, using the current amount in Ulps.
+
+
+
+
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of days.
+
+
+
+
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of hours.
+
+
+
+
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of minutes.
+
+
+
+
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of seconds.
+
+
+
+
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of milliseconds.
+
+
+
+
+ Returns a new tolerance with a TimeSpan as the amount, using
+ the current amount as a number of clock ticks.
+
+
+
+
+ Returns true if the current tolerance is empty.
+
+
+
+
+ TypeConstraint is the abstract base for constraints
+ that take a Type as their expected value.
+
+
+
+
+ The expected Type used by the constraint
+
+
+
+
+ Construct a TypeConstraint for a given Type
+
+
+
+
+
+ Write the actual value for a failing constraint test to a
+ MessageWriter. TypeConstraints override this method to write
+ the name of the type.
+
+ The writer on which the actual value is displayed
+
+
+
+ ExactTypeConstraint is used to test that an object
+ is of the exact type provided in the constructor
+
+
+
+
+ Construct an ExactTypeConstraint for a given Type
+
+ The expected Type.
+
+
+
+ Test that an object is of the exact type specified
+
+ The actual value.
+ True if the tested object is of the exact type provided, otherwise false.
+
+
+
+ Write the description of this constraint to a MessageWriter
+
+ The MessageWriter to use
+
+
+
+ ExceptionTypeConstraint is a special version of ExactTypeConstraint
+ used to provided detailed info about the exception thrown in
+ an error message.
+
+
+
+
+ Constructs an ExceptionTypeConstraint
+
+
+
+
+ Write the actual value for a failing constraint test to a
+ MessageWriter. Overriden to write additional information
+ in the case of an Exception.
+
+ The MessageWriter to use
+
+
+
+ InstanceOfTypeConstraint is used to test that an object
+ is of the same type provided or derived from it.
+
+
+
+
+ Construct an InstanceOfTypeConstraint for the type provided
+
+ The expected Type
+
+
+
+ Test whether an object is of the specified type or a derived type
+
+ The object to be tested
+ True if the object is of the provided type or derives from it, otherwise false.
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+ The MessageWriter to use
+
+
+
+ AssignableFromConstraint is used to test that an object
+ can be assigned from a given Type.
+
+
+
+
+ Construct an AssignableFromConstraint for the type provided
+
+
+
+
+
+ Test whether an object can be assigned from the specified type
+
+ The object to be tested
+ True if the object can be assigned a value of the expected Type, otherwise false.
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+ The MessageWriter to use
+
+
+
+ AssignableToConstraint is used to test that an object
+ can be assigned to a given Type.
+
+
+
+
+ Construct an AssignableToConstraint for the type provided
+
+
+
+
+
+ Test whether an object can be assigned to the specified type
+
+ The object to be tested
+ True if the object can be assigned a value of the expected Type, otherwise false.
+
+
+
+ Write a description of this constraint to a MessageWriter
+
+ The MessageWriter to use
+
+
+
+ Thrown when an assertion failed.
+
+
+
+
+ The error message that explains
+ the reason for the exception
+
+
+ The error message that explains
+ the reason for the exception
+ The exception that caused the
+ current exception
+
+
+
+ Serialization Constructor
+
+
+
+
+ Thrown when an assertion failed.
+
+
+
+
+
+
+ The error message that explains
+ the reason for the exception
+ The exception that caused the
+ current exception
+
+
+
+ Serialization Constructor
+
+
+
+
+ Thrown when a test executes inconclusively.
+
+
+
+
+ The error message that explains
+ the reason for the exception
+
+
+ The error message that explains
+ the reason for the exception
+ The exception that caused the
+ current exception
+
+
+
+ Serialization Constructor
+
+
+
+
+ Thrown when an assertion failed.
+
+
+
+
+
+
+ The error message that explains
+ the reason for the exception
+ The exception that caused the
+ current exception
+
+
+
+ Serialization Constructor
+
+
+
+
+
+
+
+
+
+
+ Compares two objects of a given Type for equality within a tolerance
+
+ The first object to compare
+ The second object to compare
+ The tolerance to use in the comparison
+
+
+
+
+ The different targets a test action attribute can be applied to
+
+
+
+
+ Default target, which is determined by where the action attribute is attached
+
+
+
+
+ Target a individual test case
+
+
+
+
+ Target a suite of test cases
+
+
+
+
+ Delegate used by tests that execute code and
+ capture any thrown exception.
+
+
+
+
+ The Assert class contains a collection of static methods that
+ implement the most common assertions used in NUnit.
+
+
+
+
+ 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.
+
+
+
+
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+
+
+
+
+
+
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+
+
+
+
+
+
+ Helper for Assert.AreEqual(double expected, double actual, ...)
+ allowing code generation to work consistently.
+
+ The expected value
+ The actual value
+ The maximum acceptable difference between the
+ the expected and the actual
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Throws a 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.
+
+ The message to initialize the with.
+ Arguments to be used in formatting the message
+
+
+
+ Throws a 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.
+
+ The message to initialize the with.
+
+
+
+ Throws a 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.
+
+
+
+
+ Throws an with the message and arguments
+ that are passed in. This is used by the other Assert functions.
+
+ The message to initialize the with.
+ Arguments to be used in formatting the message
+
+
+
+ Throws an with the message that is
+ passed in. This is used by the other Assert functions.
+
+ The message to initialize the with.
+
+
+
+ Throws an .
+ This is used by the other Assert functions.
+
+
+
+
+ Throws an with the message and arguments
+ that are passed in. This causes the test to be reported as ignored.
+
+ The message to initialize the with.
+ Arguments to be used in formatting the message
+
+
+
+ Throws an with the message that is
+ passed in. This causes the test to be reported as ignored.
+
+ The message to initialize the with.
+
+
+
+ Throws an .
+ This causes the test to be reported as ignored.
+
+
+
+
+ Throws an with the message and arguments
+ that are passed in. This causes the test to be reported as inconclusive.
+
+ The message to initialize the with.
+ Arguments to be used in formatting the message
+
+
+
+ Throws an with the message that is
+ passed in. This causes the test to be reported as inconclusive.
+
+ The message to initialize the with.
+
+
+
+ Throws an .
+ This causes the test to be reported as Inconclusive.
+
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint to be applied
+ The actual value to test
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint to be applied
+ The actual value to test
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint expression to be applied
+ The actual value to test
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint expression to be applied
+ An ActualValueDelegate returning the value to be tested
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint expression to be applied
+ An ActualValueDelegate returning the value to be tested
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ An ActualValueDelegate returning the value to be tested
+ A Constraint expression to be applied
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint to be applied
+ The actual value to test
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint to be applied
+ The actual value to test
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint to be applied
+ The actual value to test
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+ The message to display if the condition is false
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+ The message to display if the condition is false
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+
+
+
+ Asserts that the code represented by a delegate throws an exception
+ that satisfies the constraint provided.
+
+ A TestDelegate to be executed
+ A ThrowsConstraint used in the test
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ Used as a synonym for That in rare cases where a private setter
+ causes a Visual Basic compilation error.
+
+ A Constraint to be applied
+ The actual value to test
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ Used as a synonym for That in rare cases where a private setter
+ causes a Visual Basic compilation error.
+
+ A Constraint to be applied
+ The actual value to test
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+ Used as a synonym for That in rare cases where a private setter
+ causes a Visual Basic compilation error.
+
+
+ This method is provided for use by VB developers needing to test
+ the value of properties with private setters.
+
+ A Constraint expression to be applied
+ The actual value to test
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ A constraint to be satisfied by the exception
+ A TestSnippet delegate
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ A constraint to be satisfied by the exception
+ A TestSnippet delegate
+ The message that will be displayed on failure
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ A constraint to be satisfied by the exception
+ A TestSnippet delegate
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ The exception Type expected
+ A TestSnippet delegate
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ The exception Type expected
+ A TestSnippet delegate
+ The message that will be displayed on failure
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ The exception Type expected
+ A TestSnippet delegate
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ Type of the expected exception
+ A TestSnippet delegate
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ Type of the expected exception
+ A TestSnippet delegate
+ The message that will be displayed on failure
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ Type of the expected exception
+ A TestSnippet delegate
+
+
+
+ Verifies that a delegate throws an exception when called
+ and returns it.
+
+ A TestDelegate
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Verifies that a delegate throws an exception when called
+ and returns it.
+
+ A TestDelegate
+ The message that will be displayed on failure
+
+
+
+ Verifies that a delegate throws an exception when called
+ and returns it.
+
+ A TestDelegate
+
+
+
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+
+ The expected Exception Type
+ A TestDelegate
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+
+ The expected Exception Type
+ A TestDelegate
+ The message that will be displayed on failure
+
+
+
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+
+ The expected Exception Type
+ A TestDelegate
+
+
+
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+
+ The expected Exception Type
+ A TestDelegate
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+
+ The expected Exception Type
+ A TestDelegate
+ The message that will be displayed on failure
+
+
+
+ Verifies that a delegate throws an exception of a certain Type
+ or one derived from it when called and returns it.
+
+ The expected Exception Type
+ A TestDelegate
+
+
+
+ Verifies that a delegate does not throw an exception
+
+ A TestSnippet delegate
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Verifies that a delegate does not throw an exception.
+
+ A TestSnippet delegate
+ The message that will be displayed on failure
+
+
+
+ Verifies that a delegate does not throw an exception.
+
+ A TestSnippet delegate
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+ The message to display in case of failure
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+ The message to display in case of failure
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+
+
+
+ Asserts that a condition is false. If the condition is true the method throws
+ an .
+
+ The evaluated condition
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that a condition is false. If the condition is true the method throws
+ an .
+
+ The evaluated condition
+ The message to display in case of failure
+
+
+
+ Asserts that a condition is false. If the condition is true the method throws
+ an .
+
+ The evaluated condition
+
+
+
+ Asserts that a condition is false. If the condition is true the method throws
+ an .
+
+ The evaluated condition
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that a condition is false. If the condition is true the method throws
+ an .
+
+ The evaluated condition
+ The message to display in case of failure
+
+
+
+ Asserts that a condition is false. If the condition is true the method throws
+ an .
+
+ The evaluated condition
+
+
+
+ Verifies that the object that is passed in is not equal to null
+ If the object is null
then an
+ is thrown.
+
+ The object that is to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the object that is passed in is not equal to null
+ If the object is null
then an
+ is thrown.
+
+ The object that is to be tested
+ The message to display in case of failure
+
+
+
+ Verifies that the object that is passed in is not equal to null
+ If the object is null
then an
+ is thrown.
+
+ The object that is to be tested
+
+
+
+ Verifies that the object that is passed in is not equal to null
+ If the object is null
then an
+ is thrown.
+
+ The object that is to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the object that is passed in is not equal to null
+ If the object is null
then an
+ is thrown.
+
+ The object that is to be tested
+ The message to display in case of failure
+
+
+
+ Verifies that the object that is passed in is not equal to null
+ If the object is null
then an
+ is thrown.
+
+ The object that is to be tested
+
+
+
+ Verifies that the object that is passed in is equal to null
+ If the object is not null
then an
+ is thrown.
+
+ The object that is to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the object that is passed in is equal to null
+ If the object is not null
then an
+ is thrown.
+
+ The object that is to be tested
+ The message to display in case of failure
+
+
+
+ Verifies that the object that is passed in is equal to null
+ If the object is not null
then an
+ is thrown.
+
+ The object that is to be tested
+
+
+
+ Verifies that the object that is passed in is equal to null
+ If the object is not null
then an
+ is thrown.
+
+ The object that is to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the object that is passed in is equal to null
+ If the object is not null
then an
+ is thrown.
+
+ The object that is to be tested
+ The message to display in case of failure
+
+
+
+ Verifies that the object that is passed in is equal to null
+ If the object is not null
then an
+ is thrown.
+
+ The object that is to be tested
+
+
+
+ Verifies that the double that is passed in is an NaN
value.
+ If the object is not NaN
then an
+ is thrown.
+
+ The value that is to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the double that is passed in is an NaN
value.
+ If the object is not NaN
then an
+ is thrown.
+
+ The value that is to be tested
+ The message to display in case of failure
+
+
+
+ Verifies that the double that is passed in is an NaN
value.
+ If the object is not NaN
then an
+ is thrown.
+
+ The value that is to be tested
+
+
+
+ Verifies that the double that is passed in is an NaN
value.
+ If the object is not NaN
then an
+ is thrown.
+
+ The value that is to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the double that is passed in is an NaN
value.
+ If the object is not NaN
then an
+ is thrown.
+
+ The value that is to be tested
+ The message to display in case of failure
+
+
+
+ Verifies that the double that is passed in is an NaN
value.
+ If the object is not NaN
then an
+ is thrown.
+
+ The value that is to be tested
+
+
+
+ Assert that a string is empty - that is equal to string.Empty
+
+ The string to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Assert that a string is empty - that is equal to string.Empty
+
+ The string to be tested
+ The message to display in case of failure
+
+
+
+ Assert that a string is empty - that is equal to string.Empty
+
+ The string to be tested
+
+
+
+ Assert that an array, list or other collection is empty
+
+ An array, list or other collection implementing ICollection
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Assert that an array, list or other collection is empty
+
+ An array, list or other collection implementing ICollection
+ The message to display in case of failure
+
+
+
+ Assert that an array, list or other collection is empty
+
+ An array, list or other collection implementing ICollection
+
+
+
+ Assert that a string is not empty - that is not equal to string.Empty
+
+ The string to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Assert that a string is not empty - that is not equal to string.Empty
+
+ The string to be tested
+ The message to display in case of failure
+
+
+
+ Assert that a string is not empty - that is not equal to string.Empty
+
+ The string to be tested
+
+
+
+ Assert that an array, list or other collection is not empty
+
+ An array, list or other collection implementing ICollection
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Assert that an array, list or other collection is not empty
+
+ An array, list or other collection implementing ICollection
+ The message to display in case of failure
+
+
+
+ Assert that an array, list or other collection is not empty
+
+ An array, list or other collection implementing ICollection
+
+
+
+ Assert that a string is either null or equal to string.Empty
+
+ The string to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Assert that a string is either null or equal to string.Empty
+
+ The string to be tested
+ The message to display in case of failure
+
+
+
+ Assert that a string is either null or equal to string.Empty
+
+ The string to be tested
+
+
+
+ Assert that a string is not null or empty
+
+ The string to be tested
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Assert that a string is not null or empty
+
+ The string to be tested
+ The message to display in case of failure
+
+
+
+ Assert that a string is not null or empty
+
+ The string to be tested
+
+
+
+ Asserts that an object may be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object may be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+ The message to display in case of failure
+
+
+
+ Asserts that an object may be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+
+
+
+ Asserts that an object may be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object may be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+ The message to display in case of failure
+
+
+
+ Asserts that an object may be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+
+
+
+ Asserts that an object may not be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object may not be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+ The message to display in case of failure
+
+
+
+ Asserts that an object may not be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+
+
+
+ Asserts that an object may not be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object may not be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+ The message to display in case of failure
+
+
+
+ Asserts that an object may not be assigned a value of a given Type.
+
+ The expected Type.
+ The object under examination
+
+
+
+ Asserts that an object is an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object is an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+
+
+
+ Asserts that an object is an instance of a given type.
+
+ The expected Type
+ The object being examined
+
+
+
+ Asserts that an object is an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object is an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+
+
+
+ Asserts that an object is an instance of a given type.
+
+ The expected Type
+ The object being examined
+
+
+
+ Asserts that an object is an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object is an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+
+
+
+ Asserts that an object is an instance of a given type.
+
+ The expected Type
+ The object being examined
+
+
+
+ Asserts that an object is not an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object is not an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+
+
+
+ Asserts that an object is not an instance of a given type.
+
+ The expected Type
+ The object being examined
+
+
+
+ Asserts that an object is not an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object is not an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+
+
+
+ Asserts that an object is not an instance of a given type.
+
+ The expected Type
+ The object being examined
+
+
+
+ Asserts that an object is not an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object is not an instance of a given type.
+
+ The expected Type
+ The object being examined
+ The message to display in case of failure
+
+
+
+ Asserts that an object is not an instance of a given type.
+
+ The expected Type
+ The object being examined
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ 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 is
+ thrown.
+
+ The expected value
+ The actual value
+ The maximum acceptable difference between the
+ the expected and the actual
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ 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 is
+ thrown.
+
+ The expected value
+ The actual value
+ The maximum acceptable difference between the
+ the expected and the actual
+ The message to display in case of failure
+
+
+
+ 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 is
+ thrown.
+
+ The expected value
+ The actual value
+ The maximum acceptable difference between the
+ the expected and the actual
+
+
+
+ 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 is
+ thrown.
+
+ The expected value
+ The actual value
+ The maximum acceptable difference between the
+ the expected and the actual
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ 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 is
+ thrown.
+
+ The expected value
+ The actual value
+ The maximum acceptable difference between the
+ the expected and the actual
+ The message to display in case of failure
+
+
+
+ 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 is
+ thrown.
+
+ The expected value
+ The actual value
+ The maximum acceptable difference between the
+ the expected and the actual
+
+
+
+ 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 is thrown.
+
+ The value that is expected
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ 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 is thrown.
+
+ The value that is expected
+ The actual value
+ The message to display in case of failure
+
+
+
+ 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 is thrown.
+
+ The value that is expected
+ The actual value
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+ The message to display in case of failure
+
+
+
+ Verifies that two values are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ 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 is thrown.
+
+ The value that is expected
+ The actual value
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ 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 is thrown.
+
+ The value that is expected
+ The actual value
+ The message to display in case of failure
+
+
+
+ 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 is thrown.
+
+ The value that is expected
+ The actual value
+
+
+
+ Asserts that two objects refer to the same object. If they
+ are not the same an is thrown.
+
+ The expected object
+ The actual object
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that two objects refer to the same object. If they
+ are not the same an is thrown.
+
+ The expected object
+ The actual object
+ The message to display in case of failure
+
+
+
+ Asserts that two objects refer to the same object. If they
+ are not the same an is thrown.
+
+ The expected object
+ The actual object
+
+
+
+ Asserts that two objects do not refer to the same object. If they
+ are the same an is thrown.
+
+ The expected object
+ The actual object
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that two objects do not refer to the same object. If they
+ are the same an is thrown.
+
+ The expected object
+ The actual object
+ The message to display in case of failure
+
+
+
+ Asserts that two objects do not refer to the same object. If they
+ are the same an is thrown.
+
+ The expected object
+ The actual object
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is greater than or equal tothe second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be greater
+ The second value, expected to be less
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+ The message to display in case of failure
+
+
+
+ Verifies that the first value is less than or equal to the second
+ value. If it is not, then an
+ is thrown.
+
+ The first value, expected to be less
+ The second value, expected to be greater
+
+
+
+ Asserts that an object is contained in a list.
+
+ The expected object
+ The list to be examined
+ The message to display in case of failure
+ Array of objects to be used in formatting the message
+
+
+
+ Asserts that an object is contained in a list.
+
+ The expected object
+ The list to be examined
+ The message to display in case of failure
+
+
+
+ Asserts that an object is contained in a list.
+
+ The expected object
+ The list to be examined
+
+
+
+ Gets the number of assertions executed so far and
+ resets the counter to zero.
+
+
+
+
+ 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
+ , from which it inherits much of its
+ behavior, in certain mock object frameworks.
+
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure. Works
+ identically to Assert.That
+
+ A Constraint to be applied
+ The actual value to test
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure. Works
+ identically to Assert.That.
+
+ A Constraint to be applied
+ The actual value to test
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure. Works
+ identically to Assert.That
+
+ A Constraint to be applied
+ The actual value to test
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint expression to be applied
+ An ActualValueDelegate returning the value to be tested
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint expression to be applied
+ An ActualValueDelegate returning the value to be tested
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ An ActualValueDelegate returning the value to be tested
+ A Constraint expression to be applied
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint to be applied
+ The actual value to test
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint to be applied
+ The actual value to test
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ A Constraint to be applied
+ The actual value to test
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an . Works Identically to Assert.That.
+
+ The evaluated condition
+ The message to display if the condition is false
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an . Works Identically to Assert.That.
+
+ The evaluated condition
+ The message to display if the condition is false
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an . Works Identically Assert.That.
+
+ The evaluated condition
+
+
+
+ Asserts that the code represented by a delegate throws an exception
+ that satisfies the constraint provided.
+
+ A TestDelegate to be executed
+ A ThrowsConstraint used in the test
+
+
+
+ Returns a ListMapper based on a collection.
+
+ The original collection
+
+
+
+
+ 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.
+
+
+
+
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+
+
+
+
+
+
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+
+
+
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+
+ A Constraint expression to be applied
+ The actual value to test
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+
+ A Constraint expression to be applied
+ The actual value to test
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+
+ A Constraint expression to be applied
+ The actual value to test
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+
+ A Constraint expression to be applied
+ An ActualValueDelegate returning the value to be tested
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+
+ A Constraint expression to be applied
+ An ActualValueDelegate returning the value to be tested
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+
+ An ActualValueDelegate returning the value to be tested
+ A Constraint expression to be applied
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+
+ A Constraint expression to be applied
+ The actual value to test
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+
+ A Constraint expression to be applied
+ The actual value to test
+ The message that will be displayed on failure
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an InconclusiveException on failure.
+
+ A Constraint expression to be applied
+ The actual value to test
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+ The message to display if the condition is false
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an .
+
+ The evaluated condition
+ The message to display if the condition is false
+
+
+
+ Asserts that a condition is true. If the condition is false the
+ method throws an .
+
+ The evaluated condition
+
+
+
+ Asserts that the code represented by a delegate throws an exception
+ that satisfies the constraint provided.
+
+ A TestDelegate to be executed
+ A ThrowsConstraint used in the test
+
+
+
+ A set of Assert methods operationg on one or more collections
+
+
+
+
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+
+
+
+
+
+
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+
+
+
+
+
+
+ Asserts that all items contained in collection are of the type specified by expectedType.
+
+ IEnumerable containing objects to be considered
+ System.Type that all objects in collection must be instances of
+
+
+
+ Asserts that all items contained in collection are of the type specified by expectedType.
+
+ IEnumerable containing objects to be considered
+ System.Type that all objects in collection must be instances of
+ The message that will be displayed on failure
+
+
+
+ Asserts that all items contained in collection are of the type specified by expectedType.
+
+ IEnumerable containing objects to be considered
+ System.Type that all objects in collection must be instances of
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that all items contained in collection are not equal to null.
+
+ IEnumerable containing objects to be considered
+
+
+
+ Asserts that all items contained in collection are not equal to null.
+
+ IEnumerable containing objects to be considered
+ The message that will be displayed on failure
+
+
+
+ Asserts that all items contained in collection are not equal to null.
+
+ IEnumerable of objects to be considered
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Ensures that every object contained in collection exists within the collection
+ once and only once.
+
+ IEnumerable of objects to be considered
+
+
+
+ Ensures that every object contained in collection exists within the collection
+ once and only once.
+
+ IEnumerable of objects to be considered
+ The message that will be displayed on failure
+
+
+
+ Ensures that every object contained in collection exists within the collection
+ once and only once.
+
+ IEnumerable of objects to be considered
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ 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.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+
+
+
+ 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.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The IComparer to use in comparing objects from each IEnumerable
+
+
+
+ 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.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The message that will be displayed on failure
+
+
+
+ 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.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The IComparer to use in comparing objects from each IEnumerable
+ The message that will be displayed on failure
+
+
+
+ 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.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ 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.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The IComparer to use in comparing objects from each IEnumerable
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+
+
+
+ Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The message that will be displayed on failure
+
+
+
+ Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that expected and actual are not exactly equal.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+
+
+
+ Asserts that expected and actual are not exactly equal.
+ If comparer is not null then it will be used to compare the objects.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The IComparer to use in comparing objects from each IEnumerable
+
+
+
+ Asserts that expected and actual are not exactly equal.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The message that will be displayed on failure
+
+
+
+ Asserts that expected and actual are not exactly equal.
+ If comparer is not null then it will be used to compare the objects.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The IComparer to use in comparing objects from each IEnumerable
+ The message that will be displayed on failure
+
+
+
+ Asserts that expected and actual are not exactly equal.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that expected and actual are not exactly equal.
+ If comparer is not null then it will be used to compare the objects.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The IComparer to use in comparing objects from each IEnumerable
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that expected and actual are not equivalent.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+
+
+
+ Asserts that expected and actual are not equivalent.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The message that will be displayed on failure
+
+
+
+ Asserts that expected and actual are not equivalent.
+
+ The first IEnumerable of objects to be considered
+ The second IEnumerable of objects to be considered
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that collection contains actual as an item.
+
+ IEnumerable of objects to be considered
+ Object to be found within collection
+
+
+
+ Asserts that collection contains actual as an item.
+
+ IEnumerable of objects to be considered
+ Object to be found within collection
+ The message that will be displayed on failure
+
+
+
+ Asserts that collection contains actual as an item.
+
+ IEnumerable of objects to be considered
+ Object to be found within collection
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that collection does not contain actual as an item.
+
+ IEnumerable of objects to be considered
+ Object that cannot exist within collection
+
+
+
+ Asserts that collection does not contain actual as an item.
+
+ IEnumerable of objects to be considered
+ Object that cannot exist within collection
+ The message that will be displayed on failure
+
+
+
+ Asserts that collection does not contain actual as an item.
+
+ IEnumerable of objects to be considered
+ Object that cannot exist within collection
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that superset is not a subject of subset.
+
+ The IEnumerable superset to be considered
+ The IEnumerable subset to be considered
+
+
+
+ Asserts that superset is not a subject of subset.
+
+ The IEnumerable superset to be considered
+ The IEnumerable subset to be considered
+ The message that will be displayed on failure
+
+
+
+ Asserts that superset is not a subject of subset.
+
+ The IEnumerable superset to be considered
+ The IEnumerable subset to be considered
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that superset is a subset of subset.
+
+ The IEnumerable superset to be considered
+ The IEnumerable subset to be considered
+
+
+
+ Asserts that superset is a subset of subset.
+
+ The IEnumerable superset to be considered
+ The IEnumerable subset to be considered
+ The message that will be displayed on failure
+
+
+
+ Asserts that superset is a subset of subset.
+
+ The IEnumerable superset to be considered
+ The IEnumerable subset to be considered
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Assert that an array, list or other collection is empty
+
+ An array, list or other collection implementing IEnumerable
+ The message to be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Assert that an array, list or other collection is empty
+
+ An array, list or other collection implementing IEnumerable
+ The message to be displayed on failure
+
+
+
+ Assert that an array,list or other collection is empty
+
+ An array, list or other collection implementing IEnumerable
+
+
+
+ Assert that an array, list or other collection is empty
+
+ An array, list or other collection implementing IEnumerable
+ The message to be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Assert that an array, list or other collection is empty
+
+ An array, list or other collection implementing IEnumerable
+ The message to be displayed on failure
+
+
+
+ Assert that an array,list or other collection is empty
+
+ An array, list or other collection implementing IEnumerable
+
+
+
+ Assert that an array, list or other collection is ordered
+
+ An array, list or other collection implementing IEnumerable
+ The message to be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Assert that an array, list or other collection is ordered
+
+ An array, list or other collection implementing IEnumerable
+ The message to be displayed on failure
+
+
+
+ Assert that an array, list or other collection is ordered
+
+ An array, list or other collection implementing IEnumerable
+
+
+
+ Assert that an array, list or other collection is ordered
+
+ An array, list or other collection implementing IEnumerable
+ A custom comparer to perform the comparisons
+ The message to be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Assert that an array, list or other collection is ordered
+
+ An array, list or other collection implementing IEnumerable
+ A custom comparer to perform the comparisons
+ The message to be displayed on failure
+
+
+
+ Assert that an array, list or other collection is ordered
+
+ An array, list or other collection implementing IEnumerable
+ A custom comparer to perform the comparisons
+
+
+
+ Static helper class used in the constraint-based syntax
+
+
+
+
+ Creates a new SubstringConstraint
+
+ The value of the substring
+ A SubstringConstraint
+
+
+
+ Creates a new CollectionContainsConstraint.
+
+ The item that should be found.
+ A new CollectionContainsConstraint
+
+
+
+ Summary description for DirectoryAssert
+
+
+
+
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+
+
+
+
+
+
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+
+
+
+
+
+
+ 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.
+
+
+
+
+ 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 is thrown.
+
+ A directory containing the value that is expected
+ A directory containing the actual value
+ The message to display if directories are not equal
+ Arguments to be used in formatting the message
+
+
+
+ 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 is thrown.
+
+ A directory containing the value that is expected
+ A directory containing the actual value
+ The message to display if directories are not equal
+
+
+
+ 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 is thrown.
+
+ A directory containing the value that is expected
+ A directory containing the actual value
+
+
+
+ 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 is thrown.
+
+ A directory path string containing the value that is expected
+ A directory path string containing the actual value
+ The message to display if directories are not equal
+ Arguments to be used in formatting the message
+
+
+
+ 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 is thrown.
+
+ A directory path string containing the value that is expected
+ A directory path string containing the actual value
+ The message to display if directories are not equal
+
+
+
+ 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 is thrown.
+
+ A directory path string containing the value that is expected
+ A directory path string containing the actual value
+
+
+
+ Asserts that two directories are not equal. If they are equal
+ an is thrown.
+
+ A directory containing the value that is expected
+ A directory containing the actual value
+ The message to display if directories are not equal
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that two directories are not equal. If they are equal
+ an is thrown.
+
+ A directory containing the value that is expected
+ A directory containing the actual value
+ The message to display if directories are not equal
+
+
+
+ Asserts that two directories are not equal. If they are equal
+ an is thrown.
+
+ A directory containing the value that is expected
+ A directory containing the actual value
+
+
+
+ Asserts that two directories are not equal. If they are equal
+ an is thrown.
+
+ A directory path string containing the value that is expected
+ A directory path string containing the actual value
+ The message to display if directories are equal
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that two directories are not equal. If they are equal
+ an is thrown.
+
+ A directory path string containing the value that is expected
+ A directory path string containing the actual value
+ The message to display if directories are equal
+
+
+
+ Asserts that two directories are not equal. If they are equal
+ an is thrown.
+
+ A directory path string containing the value that is expected
+ A directory path string containing the actual value
+
+
+
+ Asserts that the directory is empty. If it is not empty
+ an is thrown.
+
+ A directory to search
+ The message to display if directories are not equal
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that the directory is empty. If it is not empty
+ an is thrown.
+
+ A directory to search
+ The message to display if directories are not equal
+
+
+
+ Asserts that the directory is empty. If it is not empty
+ an is thrown.
+
+ A directory to search
+
+
+
+ Asserts that the directory is empty. If it is not empty
+ an is thrown.
+
+ A directory to search
+ The message to display if directories are not equal
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that the directory is empty. If it is not empty
+ an is thrown.
+
+ A directory to search
+ The message to display if directories are not equal
+
+
+
+ Asserts that the directory is empty. If it is not empty
+ an is thrown.
+
+ A directory to search
+
+
+
+ Asserts that the directory is not empty. If it is empty
+ an is thrown.
+
+ A directory to search
+ The message to display if directories are not equal
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that the directory is not empty. If it is empty
+ an is thrown.
+
+ A directory to search
+ The message to display if directories are not equal
+
+
+
+ Asserts that the directory is not empty. If it is empty
+ an is thrown.
+
+ A directory to search
+
+
+
+ Asserts that the directory is not empty. If it is empty
+ an is thrown.
+
+ A directory to search
+ The message to display if directories are not equal
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that the directory is not empty. If it is empty
+ an is thrown.
+
+ A directory to search
+ The message to display if directories are not equal
+
+
+
+ Asserts that the directory is not empty. If it is empty
+ an is thrown.
+
+ A directory to search
+
+
+
+ Asserts that path contains actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+ The message to display if directory is not within the path
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that path contains actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+ The message to display if directory is not within the path
+
+
+
+ Asserts that path contains actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+
+
+
+ Asserts that path contains actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+ The message to display if directory is not within the path
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that path contains actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+ The message to display if directory is not within the path
+
+
+
+ Asserts that path contains actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+
+
+
+ Asserts that path does not contain actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+ The message to display if directory is not within the path
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that path does not contain actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+ The message to display if directory is not within the path
+
+
+
+ Asserts that path does not contain actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+
+
+
+ Asserts that path does not contain actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+ The message to display if directory is not within the path
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that path does not contain actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+ The message to display if directory is not within the path
+
+
+
+ Asserts that path does not contain actual as a subdirectory or
+ an is thrown.
+
+ A directory to search
+ sub-directory asserted to exist under directory
+
+
+
+ Summary description for FileAssert.
+
+
+
+
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+
+
+
+
+
+
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+
+
+
+
+
+
+ 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.
+
+
+
+
+ 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 is thrown.
+
+ The expected Stream
+ The actual Stream
+ The message to display if Streams are not equal
+ Arguments to be used in formatting the message
+
+
+
+ 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 is thrown.
+
+ The expected Stream
+ The actual Stream
+ The message to display if objects are not equal
+
+
+
+ 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 is thrown.
+
+ The expected Stream
+ The actual Stream
+
+
+
+ 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 is thrown.
+
+ A file containing the value that is expected
+ A file containing the actual value
+ The message to display if Streams are not equal
+ Arguments to be used in formatting the message
+
+
+
+ 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 is thrown.
+
+ A file containing the value that is expected
+ A file containing the actual value
+ The message to display if objects are not equal
+
+
+
+ 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 is thrown.
+
+ A file containing the value that is expected
+ A file containing the actual value
+
+
+
+ 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 is thrown.
+
+ The path to a file containing the value that is expected
+ The path to a file containing the actual value
+ The message to display if Streams are not equal
+ Arguments to be used in formatting the message
+
+
+
+ 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 is thrown.
+
+ The path to a file containing the value that is expected
+ The path to a file containing the actual value
+ The message to display if objects are not equal
+
+
+
+ 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 is thrown.
+
+ The path to a file containing the value that is expected
+ The path to a file containing the actual value
+
+
+
+ Asserts that two Streams are not equal. If they are equal
+ an is thrown.
+
+ The expected Stream
+ The actual Stream
+ The message to be displayed when the two Stream are the same.
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that two Streams are not equal. If they are equal
+ an is thrown.
+
+ The expected Stream
+ The actual Stream
+ The message to be displayed when the Streams are the same.
+
+
+
+ Asserts that two Streams are not equal. If they are equal
+ an is thrown.
+
+ The expected Stream
+ The actual Stream
+
+
+
+ Asserts that two files are not equal. If they are equal
+ an is thrown.
+
+ A file containing the value that is expected
+ A file containing the actual value
+ The message to display if Streams are not equal
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that two files are not equal. If they are equal
+ an is thrown.
+
+ A file containing the value that is expected
+ A file containing the actual value
+ The message to display if objects are not equal
+
+
+
+ Asserts that two files are not equal. If they are equal
+ an is thrown.
+
+ A file containing the value that is expected
+ A file containing the actual value
+
+
+
+ Asserts that two files are not equal. If they are equal
+ an is thrown.
+
+ The path to a file containing the value that is expected
+ The path to a file containing the actual value
+ The message to display if Streams are not equal
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that two files are not equal. If they are equal
+ an is thrown.
+
+ The path to a file containing the value that is expected
+ The path to a file containing the actual value
+ The message to display if objects are not equal
+
+
+
+ Asserts that two files are not equal. If they are equal
+ an is thrown.
+
+ The path to a file containing the value that is expected
+ The path to a file containing the actual value
+
+
+
+ GlobalSettings is a place for setting default values used
+ by the framework in performing asserts.
+
+
+
+
+ Default tolerance for floating point equality
+
+
+
+
+ Helper class with properties and methods that supply
+ a number of constraints used in Asserts.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding only if a specified number of them succeed.
+
+
+
+
+ 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.
+
+
+
+
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+
+
+
+
+ Returns a new AttributeConstraint checking for the
+ presence of a particular attribute on an object.
+
+
+
+
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+
+
+
+
+ Returns a ConstraintExpression that negates any
+ following constraint.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if at least one of them succeeds.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them fail.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Length property of the object being tested.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Count property of the object being tested.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the Message property of the object being tested.
+
+
+
+
+ Returns a new ConstraintExpression, which will apply the following
+ constraint to the InnerException property of the object being tested.
+
+
+
+
+ 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.
+
+
+
+
+ Method to handle an expected exception
+
+ The exception to be handled
+
+
+
+ Helper class with properties and methods that supply
+ a number of constraints used in Asserts.
+
+
+
+
+ Returns a constraint that tests two items for equality
+
+
+
+
+ Returns a constraint that tests that two references are the same object
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is greater than the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is greater than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is less than the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the
+ actual value is less than or equal to the suppled argument
+
+
+
+
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual
+ value is of the exact type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is of the type supplied as an argument or a derived type.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is assignable from the type supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is a collection containing the same elements as the
+ collection supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the actual value
+ is a subset of the collection supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+
+
+
+
+ Returns a constraint that tests whether the path provided
+ is the same as an expected path after canonicalization.
+
+
+
+
+ Returns a constraint that tests whether the path provided
+ is the same path or under an expected path after canonicalization.
+
+
+
+
+ Returns a constraint that tests whether the path provided
+ is the same path or under an expected path after canonicalization.
+
+
+
+
+ Returns a constraint that tests whether the actual value falls
+ within a specified range.
+
+
+
+
+ Returns a ConstraintExpression that negates any
+ following constraint.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+
+
+
+
+ Returns a constraint that tests for null
+
+
+
+
+ Returns a constraint that tests for True
+
+
+
+
+ Returns a constraint that tests for False
+
+
+
+
+ Returns a constraint that tests for a positive value
+
+
+
+
+ Returns a constraint that tests for a negative value
+
+
+
+
+ Returns a constraint that tests for NaN
+
+
+
+
+ Returns a constraint that tests for empty
+
+
+
+
+ Returns a constraint that tests whether a collection
+ contains all unique items.
+
+
+
+
+ Returns a constraint that tests whether an object graph is serializable in binary format.
+
+
+
+
+ Returns a constraint that tests whether an object graph is serializable in xml format.
+
+
+
+
+ Returns a constraint that tests whether a collection is ordered
+
+
+
+
+ The Iz class is a synonym for Is intended for use in VB,
+ which regards Is as a keyword.
+
+
+
+
+ The List class is a helper class with properties and methods
+ that supply a number of constraints used with lists and collections.
+
+
+
+
+ List.Map returns a ListMapper, which can be used to map
+ the original collection to another collection.
+
+
+
+
+
+
+ ListMapper is used to transform a collection used as an actual argument
+ producing another collection to be used in the assertion.
+
+
+
+
+ Construct a ListMapper based on a collection
+
+ The collection to be transformed
+
+
+
+ Produces a collection containing all the values of a property
+
+ The collection of property values
+
+
+
+
+ Randomizer returns a set of random values in a repeatable
+ way, to allow re-running of tests if necessary.
+
+
+
+
+ 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.
+
+
+
+
+ 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.
+
+
+
+
+ Construct a randomizer using a random seed
+
+
+
+
+ Construct a randomizer using a specified seed
+
+
+
+
+ Return an array of random doubles between 0.0 and 1.0.
+
+
+
+
+
+
+ Return an array of random doubles with values in a specified range.
+
+
+
+
+ Return an array of random ints with values in a specified range.
+
+
+
+
+ Get a random seed for use in creating a randomizer.
+
+
+
+
+ The SpecialValue enum is used to represent TestCase arguments
+ that cannot be used as arguments to an Attribute.
+
+
+
+
+ Null represents a null value, which cannot be used as an
+ argument to an attriute under .NET 1.x
+
+
+
+
+ Basic Asserts on strings.
+
+
+
+
+ The Equals method throws an AssertionException. This is done
+ to make sure there is no mistake by calling this function.
+
+
+
+
+
+
+ override the default ReferenceEquals to throw an AssertionException. This
+ implementation makes sure there is no mistake in calling this function
+ as part of Assert.
+
+
+
+
+
+
+ Asserts that a string is found within another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that a string is found within another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+
+
+
+ Asserts that a string is found within another string.
+
+ The expected string
+ The string to be examined
+
+
+
+ Asserts that a string is not found within another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that a string is found within another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+
+
+
+ Asserts that a string is found within another string.
+
+ The expected string
+ The string to be examined
+
+
+
+ Asserts that a string starts with another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that a string starts with another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+
+
+
+ Asserts that a string starts with another string.
+
+ The expected string
+ The string to be examined
+
+
+
+ Asserts that a string does not start with another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that a string does not start with another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+
+
+
+ Asserts that a string does not start with another string.
+
+ The expected string
+ The string to be examined
+
+
+
+ Asserts that a string ends with another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that a string ends with another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+
+
+
+ Asserts that a string ends with another string.
+
+ The expected string
+ The string to be examined
+
+
+
+ Asserts that a string does not end with another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that a string does not end with another string.
+
+ The expected string
+ The string to be examined
+ The message to display in case of failure
+
+
+
+ Asserts that a string does not end with another string.
+
+ The expected string
+ The string to be examined
+
+
+
+ Asserts that two strings are equal, without regard to case.
+
+ The expected string
+ The actual string
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that two strings are equal, without regard to case.
+
+ The expected string
+ The actual string
+ The message to display in case of failure
+
+
+
+ Asserts that two strings are equal, without regard to case.
+
+ The expected string
+ The actual string
+
+
+
+ Asserts that two strings are not equal, without regard to case.
+
+ The expected string
+ The actual string
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that two strings are Notequal, without regard to case.
+
+ The expected string
+ The actual string
+ The message to display in case of failure
+
+
+
+ Asserts that two strings are not equal, without regard to case.
+
+ The expected string
+ The actual string
+
+
+
+ Asserts that a string matches an expected regular expression pattern.
+
+ The regex pattern to be matched
+ The actual string
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that a string matches an expected regular expression pattern.
+
+ The regex pattern to be matched
+ The actual string
+ The message to display in case of failure
+
+
+
+ Asserts that a string matches an expected regular expression pattern.
+
+ The regex pattern to be matched
+ The actual string
+
+
+
+ Asserts that a string does not match an expected regular expression pattern.
+
+ The regex pattern to be used
+ The actual string
+ The message to display in case of failure
+ Arguments used in formatting the message
+
+
+
+ Asserts that a string does not match an expected regular expression pattern.
+
+ The regex pattern to be used
+ The actual string
+ The message to display in case of failure
+
+
+
+ Asserts that a string does not match an expected regular expression pattern.
+
+ The regex pattern to be used
+ The actual string
+
+
+
+ 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.
+
+
+
+
+ The argument list to be provided to the test
+
+
+
+
+ The expected result to be returned
+
+
+
+
+ Set to true if this has an expected result
+
+
+
+
+ The expected exception Type
+
+
+
+
+ The FullName of the expected exception
+
+
+
+
+ The name to be used for the test
+
+
+
+
+ The description of the test
+
+
+
+
+ A dictionary of properties, used to add information
+ to tests without requiring the class to change.
+
+
+
+
+ If true, indicates that the test case is to be ignored
+
+
+
+
+ If true, indicates that the test case is marked explicit
+
+
+
+
+ The reason for ignoring a test case
+
+
+
+
+ Initializes a new instance of the class.
+
+ The arguments.
+
+
+
+ Initializes a new instance of the class.
+
+ The argument.
+
+
+
+ Initializes a new instance of the class.
+
+ The first argument.
+ The second argument.
+
+
+
+ Initializes a new instance of the class.
+
+ The first argument.
+ The second argument.
+ The third argument.
+
+
+
+ Sets the expected result for the test
+
+ The expected result
+ A modified TestCaseData
+
+
+
+ Sets the expected exception type for the test
+
+ Type of the expected exception.
+ The modified TestCaseData instance
+
+
+
+ Sets the expected exception type for the test
+
+ FullName of the expected exception.
+ The modified TestCaseData instance
+
+
+
+ Sets the name of the test case
+
+ The modified TestCaseData instance
+
+
+
+ Sets the description for the test case
+ being constructed.
+
+ The description.
+ The modified TestCaseData instance.
+
+
+
+ Applies a category to the test
+
+
+
+
+
+
+ Applies a named property to the test
+
+
+
+
+
+
+
+ Applies a named property to the test
+
+
+
+
+
+
+
+ Applies a named property to the test
+
+
+
+
+
+
+
+ Ignores this TestCase.
+
+
+
+
+
+ Ignores this TestCase, specifying the reason.
+
+ The reason.
+
+
+
+
+ Marks this TestCase as Explicit
+
+
+
+
+
+ Marks this TestCase as Explicit, specifying the reason.
+
+ The reason.
+
+
+
+
+ Gets the argument list to be provided to the test
+
+
+
+
+ Gets the expected result
+
+
+
+
+ Returns true if the result has been set
+
+
+
+
+ Gets the expected exception Type
+
+
+
+
+ Gets the FullName of the expected exception
+
+
+
+
+ Gets the name to be used for the test
+
+
+
+
+ Gets the description of the test
+
+
+
+
+ Gets a value indicating whether this is ignored.
+
+ true if ignored; otherwise, false.
+
+
+
+ Gets a value indicating whether this is explicit.
+
+ true if explicit; otherwise, false.
+
+
+
+ Gets the ignore reason.
+
+ The ignore reason.
+
+
+
+ Gets a list of categories associated with this test.
+
+
+
+
+ Gets the property dictionary for this test
+
+
+
+
+ Provide the context information of the current test
+
+
+
+
+ Constructs a TestContext using the provided context dictionary
+
+ A context dictionary
+
+
+
+ Get the current test context. This is created
+ as needed. The user may save the context for
+ use within a test, but it should not be used
+ outside the test for which it is created.
+
+
+
+
+ Gets a TestAdapter representing the currently executing test in this context.
+
+
+
+
+ Gets a ResultAdapter representing the current result for the test
+ executing in this context.
+
+
+
+
+ Gets the directory containing the current test assembly.
+
+
+
+
+ Gets the directory to be used for outputing files created
+ by this test run.
+
+
+
+
+ TestAdapter adapts a Test for consumption by
+ the user test code.
+
+
+
+
+ Constructs a TestAdapter for this context
+
+ The context dictionary
+
+
+
+ The name of the test.
+
+
+
+
+ The FullName of the test
+
+
+
+
+ The properties of the test.
+
+
+
+
+ ResultAdapter adapts a TestResult for consumption by
+ the user test code.
+
+
+
+
+ Construct a ResultAdapter for a context
+
+ The context holding the result
+
+
+
+ The TestState of current test. This maps to the ResultState
+ used in nunit.core and is subject to change in the future.
+
+
+
+
+ The TestStatus of current test. This enum will be used
+ in future versions of NUnit and so is to be preferred
+ to the TestState value.
+
+
+
+
+ Provides details about a test
+
+
+
+
+ Creates an instance of TestDetails
+
+ The fixture that the test is a member of, if available.
+ The method that implements the test, if available.
+ The full name of the test.
+ A string representing the type of test, e.g. "Test Case".
+ Indicates if the test represents a suite of tests.
+
+
+
+ The fixture that the test is a member of, if available.
+
+
+
+
+ The method that implements the test, if available.
+
+
+
+
+ The full name of the test.
+
+
+
+
+ A string representing the type of test, e.g. "Test Case".
+
+
+
+
+ Indicates if the test represents a suite of tests.
+
+
+
+
+ The ResultState enum indicates the result of running a test
+
+
+
+
+ The result is inconclusive
+
+
+
+
+ The test was not runnable.
+
+
+
+
+ The test has been skipped.
+
+
+
+
+ The test has been ignored.
+
+
+
+
+ The test succeeded
+
+
+
+
+ The test failed
+
+
+
+
+ The test encountered an unexpected exception
+
+
+
+
+ The test was cancelled by the user
+
+
+
+
+ The TestStatus enum indicates the result of running a test
+
+
+
+
+ The test was inconclusive
+
+
+
+
+ The test has skipped
+
+
+
+
+ The test succeeded
+
+
+
+
+ The test failed
+
+
+
+
+ Helper class with static methods used to supply constraints
+ that operate on strings.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that fails if the actual
+ value contains the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value starts with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that fails if the actual
+ value starts with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value ends with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that fails if the actual
+ value ends with the substring supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value matches the Regex pattern supplied as an argument.
+
+
+
+
+ Returns a constraint that fails if the actual
+ value matches the pattern supplied as an argument.
+
+
+
+
+ Returns a ConstraintExpression, which will apply
+ the following constraint to all members of a collection,
+ succeeding if all of them succeed.
+
+
+
+
+ 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.
+
+
+
+
+ Prefix used for the expected value line of a message
+
+
+
+
+ Prefix used for the actual value line of a message
+
+
+
+
+ Length of a message prefix
+
+
+
+
+ Construct a TextMessageWriter
+
+
+
+
+ Construct a TextMessageWriter, specifying a user message
+ and optional formatting arguments.
+
+
+
+
+
+
+ Method to write single line message with optional args, usually
+ written to precede the general failure message, at a givel
+ indentation level.
+
+ The indentation level of the message
+ The message to be written
+ Any arguments used in formatting the message
+
+
+
+ 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.
+
+ The constraint that failed
+
+
+
+ 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.
+
+ The expected value
+ The actual value causing the failure
+
+
+
+ Display Expected and Actual lines for given values, including
+ a tolerance value on the expected line.
+
+ The expected value
+ The actual value causing the failure
+ The tolerance within which the test was made
+
+
+
+ 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.
+
+ The expected string value
+ The actual string value
+ The point at which the strings don't match or -1
+ If true, case is ignored in string comparisons
+ If true, clip the strings to fit the max line length
+
+
+
+ Writes the text for a connector.
+
+ The connector.
+
+
+
+ Writes the text for a predicate.
+
+ The predicate.
+
+
+
+ Write the text for a modifier.
+
+ The modifier.
+
+
+
+ Writes the text for an expected value.
+
+ The expected value.
+
+
+
+ Writes the text for an actual value.
+
+ The actual value.
+
+
+
+ Writes the text for a generalized value.
+
+ The value.
+
+
+
+ Writes the text for a collection value,
+ starting at a particular point, to a max length
+
+ The collection containing elements to write.
+ The starting point of the elements to write
+ The maximum number of elements to write
+
+
+
+ Write the generic 'Expected' line for a constraint
+
+ The constraint that failed
+
+
+
+ Write the generic 'Expected' line for a given value
+
+ The expected value
+
+
+
+ Write the generic 'Expected' line for a given value
+ and tolerance.
+
+ The expected value
+ The tolerance within which the test was made
+
+
+
+ Write the generic 'Actual' line for a constraint
+
+ The constraint for which the actual value is to be written
+
+
+
+ Write the generic 'Actual' line for a given value
+
+ The actual value causing a failure
+
+
+
+ Gets or sets the maximum line length for this writer
+
+
+
+
+ Helper class with properties and methods that supply
+ constraints that operate on exceptions.
+
+
+
+
+ Creates a constraint specifying the exact type of exception expected
+
+
+
+
+ Creates a constraint specifying the exact type of exception expected
+
+
+
+
+ Creates a constraint specifying the type of exception expected
+
+
+
+
+ Creates a constraint specifying the type of exception expected
+
+
+
+
+ Creates a constraint specifying an expected exception
+
+
+
+
+ Creates a constraint specifying an exception with a given InnerException
+
+
+
+
+ Creates a constraint specifying an expected TargetInvocationException
+
+
+
+
+ Creates a constraint specifying an expected TargetInvocationException
+
+
+
+
+ Creates a constraint specifying an expected TargetInvocationException
+
+
+
+
+ Creates a constraint specifying that no exception is thrown
+
+
+
+
diff --git a/packages/NUnit.2.6.2/license.txt b/packages/NUnit.2.6.2/license.txt
new file mode 100644
index 0000000..530a6e0
--- /dev/null
+++ b/packages/NUnit.2.6.2/license.txt
@@ -0,0 +1,15 @@
+Copyright © 2002-2012 Charlie Poole
+Copyright © 2002-2004 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov
+Copyright © 2000-2002 Philip A. Craig
+
+This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment (see the following) in the product documentation is required.
+
+Portions Copyright © 2002-2012 Charlie Poole or Copyright © 2002-2004 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov or Copyright © 2000-2002 Philip A. Craig
+
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source distribution.
diff --git a/packages/RhinoMocks.3.6.1/RhinoMocks.3.6.1.nupkg b/packages/RhinoMocks.3.6.1/RhinoMocks.3.6.1.nupkg
new file mode 100644
index 0000000..2d13fde
Binary files /dev/null and b/packages/RhinoMocks.3.6.1/RhinoMocks.3.6.1.nupkg differ
diff --git a/packages/RhinoMocks.3.6.1/RhinoMocks.3.6.1.nuspec b/packages/RhinoMocks.3.6.1/RhinoMocks.3.6.1.nuspec
new file mode 100644
index 0000000..5232ed3
--- /dev/null
+++ b/packages/RhinoMocks.3.6.1/RhinoMocks.3.6.1.nuspec
@@ -0,0 +1,24 @@
+
+
+
+ RhinoMocks
+ 3.6.1
+ RhinoMocks
+ ayende
+ ayende
+ http://hibernatingrhinos.com/open-source/rhino-mocks
+ http://hibernatingrhinos.com/open-source/rhino-mocks
+ false
+ Rhino Mocks is using Castle Dynamic Proxy (http://www.castleproject.org/dynamicproxy/index.html) to handle proxying the types it needs to mock.
+The Dynamic Proxy project has been invaluable resource and made creating Rhino Mocks possible.
+ Rhino Mocks is using Castle Dynamic Proxy (http://www.castleproject.org/dynamicproxy/index.html) to handle proxying the types it needs to mock.
+The Dynamic Proxy project has been invaluable resource a
+
+
+
+ tdd mocking mocks unittest unittesting
+
+
+
+
+
\ No newline at end of file
diff --git a/packages/RhinoMocks.3.6.1/lib/net/Rhino.Mocks.dll b/packages/RhinoMocks.3.6.1/lib/net/Rhino.Mocks.dll
new file mode 100644
index 0000000..c6f4f53
Binary files /dev/null and b/packages/RhinoMocks.3.6.1/lib/net/Rhino.Mocks.dll differ
diff --git a/packages/RhinoMocks.3.6.1/lib/net/Rhino.Mocks.xml b/packages/RhinoMocks.3.6.1/lib/net/Rhino.Mocks.xml
new file mode 100644
index 0000000..b1f7638
--- /dev/null
+++ b/packages/RhinoMocks.3.6.1/lib/net/Rhino.Mocks.xml
@@ -0,0 +1,5624 @@
+
+
+
+ Rhino.Mocks
+
+
+
+
+ Defines constraints and return values for arguments of a mock.
+ Only use Arg inside a method call on a mock that is recording.
+ Example:
+ ExpectCall(
+ mock.foo(
+ Arg<int>.Is.GreaterThan(2),
+ Arg<string>.Is.Anything
+ ));
+ Use Arg.Text for string specific constraints
+ Use Arg<ListClass>.List for list specific constraints
+
+
+
+
+
+ Register the predicate as a constraint for the current call.
+
+ The predicate.
+ default(T)
+
+ Allow you to use code to create constraints
+
+ demo.AssertWasCalled(x => x.Bar(Arg{string}.Matches(a => a.StartsWith("b") && a.Contains("ba"))));
+
+
+
+
+
+ Define a complex constraint for this argument by passing several constraints
+ combined with operators. (Use Is in simple cases.)
+ Example: Arg<string>.Matches(Is.Equal("Hello") || Text.EndsWith("u"));
+
+ Constraints using Is, Text and List
+ Dummy to satisfy the compiler
+
+
+
+ Define a Ref argument.
+
+ Constraints for this argument
+ value returned by the mock
+
+
+
+
+ Define a out parameter. Use it together with the keyword out and use the
+ Dummy field available by the return value.
+ Example: mock.foo( out Arg<string>.Out("hello").Dummy );
+
+
+
+
+
+
+ Define a simple constraint for this argument. (Use Matches in simple cases.)
+ Example:
+ Arg<int>.Is.Anthing
+ Arg<string>.Is.Equal("hello")
+
+
+
+
+ Define Constraints on list arguments.
+
+
+
+
+ Use the Arg class (without generic) to define Text constraints
+
+
+
+
+ Evaluate an equal constraint for .
+
+ The object the parameter should equal to
+
+
+
+ Define constraints on text arguments.
+
+
+
+
+ Used to manage the static state of the Arg<T> class"/>
+
+
+
+
+ Resets the static state
+
+
+
+
+ Returns return values for the out and ref parameters
+ Note: the array returned has the size of the number of out and ref
+ argument definitions
+
+
+
+
+
+ Returns the constraints for all arguments.
+ Out arguments have an Is.Anything constraint and are also in the list.
+
+
+
+
+
+ What should BackToRecord clear
+
+
+
+
+ Retain all expectations and behaviors and return to mock
+
+
+
+
+ All expectations
+
+
+
+
+ Event subscribers for this instance
+
+
+
+
+ Methods that should be forwarded to the base class implementation
+
+
+
+
+ Properties that should behave like properties
+
+
+
+
+ Remove all the behavior of the object
+
+
+
+
+ Interface for constraints
+
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ And operator for constraints
+
+
+
+
+ Not operator for constraints
+
+
+
+
+ Or operator for constraints
+
+
+
+
+ Allow overriding of || or &&
+
+
+
+
+
+
+ Allow overriding of || or &&
+
+
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constrain that the public field has a specified value
+
+
+
+
+ Constrain that the public field matches another constraint.
+
+
+
+
+ Creates a new instance.
+
+ Name of the public field.
+ Constraint to place on the public field value.
+
+
+
+ Creates a new instance, specifying a disambiguating
+ for the public field.
+
+ The type that declares the public field, used to disambiguate between public fields.
+ Name of the public field.
+ Constraint to place on the public field value.
+
+
+
+ Determines if the object passes the constraint.
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Creates a new instance.
+
+ Name of the public field.
+ Expected value.
+
+
+
+ Creates a new instance, specifying a disambiguating
+ for the public field.
+
+ The type that declares the public field, used to disambiguate between public fields.
+ Name of the public field.
+ Expected value.
+
+
+
+ Constrain that the property has a specified value
+
+
+
+
+ Constrain that the property matches another constraint.
+
+
+
+
+ Creates a new instance.
+
+ Name of the property.
+ Constraint to place on the property value.
+
+
+
+ Creates a new instance, specifying a disambiguating
+ for the property.
+
+ The type that declares the property, used to disambiguate between properties.
+ Name of the property.
+ Constraint to place on the property value.
+
+
+
+ Determines if the object passes the constraint.
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Creates a new instance.
+
+ Name of the property.
+ Expected value.
+
+
+
+ Creates a new instance, specifying a disambiguating
+ for the property.
+
+ The type that declares the property, used to disambiguate between properties.
+ Name of the property.
+ Expected value.
+
+
+
+ Constrain that the parameter must be of the specified type
+
+
+
+
+ Creates a new instance.
+
+ Type.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that determines whether an object is the same object as another.
+
+
+
+
+ Creates a new instance.
+
+ Obj.
+
+
+
+ Determines if the object passes the constraints.
+
+
+
+
+ Gets the message for this constraint.
+
+
+
+
+ Evaluate a parameter using constraints
+
+
+
+
+ Create new instance
+
+
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ A constraint based on lambda expression, we are using Expression{T}
+ because we want to be able to get good error reporting on that.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The expr.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constrain that the list contains the same items as the parameter list
+
+
+
+
+ Creates a new instance.
+
+ In list.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constrain that the parameter is one of the items in the list
+
+
+
+
+ Creates a new instance.
+
+ In list.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constrain that the object is inside the parameter list
+
+
+
+
+ Creates a new instance.
+
+ In list.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Applies another AbstractConstraint to the collection count.
+
+
+
+
+ Creates a new instance.
+
+ The constraint that should be applied to the collection count.
+
+
+
+ Determines if the parameter conforms to this constraint.
+
+
+
+
+ Gets the message for this constraint.
+
+
+
+
+ Applies another AbstractConstraint to a specific list element.
+
+
+
+
+ Creates a new instance.
+
+ The zero-based index of the list element.
+ The constraint that should be applied to the list element.
+
+
+
+ Determines if the parameter conforms to this constraint.
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Applies another AbstractConstraint to a specific generic keyed list element.
+
+
+
+
+ Creates a new instance.
+
+ The key of the list element.
+ The constraint that should be applied to the list element.
+
+
+
+ Determines if the parameter conforms to this constraint.
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constrains that all elements are in the parameter list
+
+
+
+
+ Initializes a new instance of the class.
+
+ The these.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Combines two constraints, constraint pass if either is fine.
+
+
+
+
+ Creates a new instance.
+
+ C1.
+ C2.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Negate a constraint
+
+
+
+
+ Creates a new instance.
+
+ C1.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Combines two constraints
+
+
+
+
+
+ Creates a new instance.
+
+ C1.
+ C2.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constrain the argument to validate according to regex pattern
+
+
+
+
+ Creates a new instance.
+
+ Pattern.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that evaluate whatever an argument contains the specified string.
+
+
+
+
+ Creates a new instance.
+
+ Inner string.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that evaluate whatever an argument ends with the specified string
+
+
+
+
+ Creates a new instance.
+
+ End.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that evaluate whatever an argument start with the specified string
+
+
+
+
+ Creates a new instance.
+
+ Start.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that evaluate whatever an object equals another
+
+
+
+
+ Creates a new instance.
+
+ Obj.
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that always returns true
+
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Constraint that evaluate whatever a comparable is greater than another
+
+
+
+
+ Creates a new instance.
+
+
+
+
+ Determines if the object pass the constraints
+
+
+
+
+ Gets the message for this constraint
+
+
+
+
+
+ Initializes a new constraint object.
+
+ The expected object, The actual object is passed in as a parameter to the method
+
+
+
+ Evaluate this constraint.
+
+ The actual object that was passed in the method call to the mock.
+ True when the constraint is met, else false.
+
+
+
+ Checks if the properties of the object
+ are the same as the properies of the object.
+
+ The expected object
+ The actual object
+ True when both objects have the same values, else False.
+
+
+
+
+
+
+
+
+ This is the real heart of the beast.
+
+
+
+ Used by CheckReferenceType to check all properties of the reference type.
+
+ The expected object
+ The actual object
+ True when both objects have the same values, else False.
+
+
+
+ Used by CheckReferenceType to check all fields of the reference type.
+
+ The expected object
+ The actual object
+ True when both objects have the same values, else False.
+
+
+
+ Checks the items of both collections
+
+ The expected collection
+
+ True if both collections contain the same items in the same order.
+
+
+
+ Builds a propertyname from the Stack _properties like 'Order.Product.Price'
+ to be used in the error message.
+
+ A nested property name.
+
+
+
+ Rhino.Mocks uses this property to generate an error message.
+
+
+ A message telling the tester why the constraint failed.
+
+
+
+
+ Provides access to the constraintes defined in the class to be used in context
+ with the syntax.
+
+ The type of the argument
+
+
+
+ Evaluate a greater than constraint for .
+
+ The object the parameter should be greater than
+
+
+
+ Evaluate a less than constraint for .
+
+ The object the parameter should be less than
+
+
+
+ Evaluate a less than or equal constraint for .
+
+ The object the parameter should be less than or equal to
+
+
+
+ Evaluate a greater than or equal constraint for .
+
+ The object the parameter should be greater than or equal to
+
+
+
+ Evaluate an equal constraint for .
+
+ The object the parameter should equal to
+
+
+
+ Converts the object type to a better match if this is a primitive type.
+
+ The obj.
+
+
+
+
+ Converts the object type to match.
+
+
+ Because of implicit conversions and the way ArgConstraints this method is needed to check
+ object type and potentially change the object type for a better "match" so that obj1.Equals(obj2)
+ will return the proper "answer"
+
+ The obj.
+
+
+
+
+ Evaluate a not equal constraint for .
+
+ The object the parameter should not equal to
+
+
+
+ Evaluate a same as constraint.
+
+ The object the parameter should the same as.
+
+
+
+ Evaluate a not same as constraint.
+
+ The object the parameter should not be the same as.
+
+
+
+ Throws NotSupportedException. Don't use Equals to define constraints. Use Equal instead.
+
+
+
+
+
+
+ Serves as a hash function for a particular type.
+
+
+ A hash code for the current .
+
+
+
+
+ A constraints that accept anything
+
+
+
+
+
+ A constraint that accept only nulls
+
+
+
+
+
+ A constraint that accept only non null values
+
+
+
+
+
+ A constraint that accept only value of the specified type.
+ The check is performed on the type that has been defined
+ as the argument type.
+
+
+
+
+ Provides access to the constraints defined in the class to be used in context
+ with the syntax.
+
+
+
+
+ Determines whether the specified object is in the parameter.
+ The parameter must be IEnumerable.
+
+ Obj.
+
+
+
+
+ Determines whatever the parameter is in the collection.
+
+
+
+
+ Determines that the parameter collection is identical to the specified collection
+
+
+
+
+ Determines that the parameter collection has the specified number of elements.
+
+ The constraint that should be applied to the collection count.
+
+
+
+ Determines that an element of the parameter collections conforms to another AbstractConstraint.
+
+ The zero-based index of the list element.
+ The constraint which should be applied to the list element.
+
+
+
+ Determines that all elements of the specified collection are in the the parameter collection
+
+ The collection to compare against
+ The constraint which should be applied to the list parameter.
+
+
+
+ Throws NotSupportedException. Don't use Equals to define constraints. Use Equal instead.
+
+
+
+
+
+
+ Serves as a hash function for a particular type.
+
+
+ A hash code for the current .
+
+
+
+
+ Provides a dummy field to pass as out or ref argument.
+
+
+
+
+
+ Dummy field to satisfy the compiler. Used for out and ref arguments.
+
+
+
+
+ Central location for constraints for object's public fields
+
+
+
+
+ Constrains the parameter to have a public field with the specified value
+
+ Name of the public field.
+ Expected value.
+
+
+
+
+ Constrains the parameter to have a public field with the specified value.
+
+ The type that declares the public field, used to disambiguate between public fields.
+ Name of the public field.
+ Expected value.
+
+
+
+
+ Constrains the parameter to have a public field satisfying a specified constraint.
+
+ Name of the public field.
+ Constraint for the public field.
+
+
+
+ Constrains the parameter to have a public field satisfying a specified constraint.
+
+ The type that declares the public field, used to disambiguate between public fields.
+ Name of the public field.
+ Constraint for the public field.
+
+
+
+ Determines whether the parameter has the specified public field and that it is null.
+
+ Name of the public field.
+
+
+
+
+ Determines whether the parameter has the specified public field and that it is null.
+
+ The type that declares the public field, used to disambiguate between public fields.
+ Name of the public field.
+
+
+
+
+ Determines whether the parameter has the specified public field and that it is not null.
+
+ Name of the public field.
+
+
+
+
+ Determines whether the parameter has the specified public field and that it is not null.
+
+ The type that declares the public field, used to disambiguate between public fields.
+ Name of the public field.
+
+
+
+
+ Central location for constraints
+
+
+
+
+ Evaluate a greater than constraint for .
+
+ The object the parameter should be greater than
+
+
+
+ Evaluate a less than constraint for .
+
+ The object the parameter should be less than
+
+
+
+ Evaluate a less than or equal constraint for .
+
+ The object the parameter should be less than or equal to
+
+
+
+ Evaluate a greater than or equal constraint for .
+
+ The object the parameter should be greater than or equal to
+
+
+
+ Evaluate an equal constraint for .
+
+ The object the parameter should equal to
+
+
+
+ Evaluate a not equal constraint for .
+
+ The object the parameter should not equal to
+
+
+
+ Evaluate a same as constraint.
+
+ The object the parameter should the same as.
+
+
+
+ Evaluate a not same as constraint.
+
+ The object the parameter should not be the same as.
+
+
+
+ A constraints that accept anything
+
+
+
+
+
+ A constraint that accept only nulls
+
+
+
+
+
+ A constraint that accept only non null values
+
+
+
+
+
+ A constraint that accept only value of the specified type
+
+
+
+
+ A constraint that accept only value of the specified type
+
+
+
+
+ Evaluate a parameter using a predicate
+
+ The predicate to use
+
+
+
+ Central location for constraints about lists and collections
+
+
+
+
+ Determines whether the specified obj is in the parameter.
+ The parameter must be IEnumerable.
+
+ Obj.
+
+
+
+
+ Determines whatever the parameter is in the collection.
+
+
+
+
+ Determines that the parameter collection is identical to the specified collection
+
+
+
+
+ Determines that the parameter collection has the specified number of elements.
+
+ The constraint that should be applied to the collection count.
+
+
+
+ Determines that an element of the parameter collections conforms to another AbstractConstraint.
+
+ The zero-based index of the list element.
+ The constraint which should be applied to the list element.
+
+
+
+ Determines that an element of the parameter collections conforms to another AbstractConstraint.
+
+ The key of the element.
+ The constraint which should be applied to the element.
+
+
+
+ Determines that all elements of the specified collection are in the the parameter collection
+
+ The collection to compare against
+ The constraint which should be applied to the list parameter.
+
+
+
+ Central location for constraints for object's properties
+
+
+
+
+ Constrains the parameter to have property with the specified value
+
+ Name of the property.
+ Expected value.
+
+
+
+
+ Constrains the parameter to have property with the specified value.
+
+ The type that declares the property, used to disambiguate between properties.
+ Name of the property.
+ Expected value.
+
+
+
+
+ Constrains the parameter to have a property satisfying a specified constraint.
+
+ Name of the property.
+ Constraint for the property.
+
+
+
+ Constrains the parameter to have a property satisfying a specified constraint.
+
+ The type that declares the property, used to disambiguate between properties.
+ Name of the property.
+ Constraint for the property.
+
+
+
+ Determines whether the parameter has the specified property and that it is null.
+
+ Name of the property.
+
+
+
+
+ Determines whether the parameter has the specified property and that it is null.
+
+ The type that declares the property, used to disambiguate between properties.
+ Name of the property.
+
+
+
+
+ Determines whether the parameter has the specified property and that it is not null.
+
+ Name of the property.
+
+
+
+
+ Determines whether the parameter has the specified property and that it is not null.
+
+ The type that declares the property, used to disambiguate between properties.
+ Name of the property.
+
+
+
+
+ constraints the parameter to have the exact same property values as the expected object.
+
+ An object, of the same type as the parameter, whose properties are set with the expected values.
+ An instance of the constraint that will do the actual check.
+
+ The parameter's public property values and public field values will be matched against the expected object's
+ public property values and public field values. The first mismatch will be reported and no further matching is done.
+ The matching is recursive for any property or field that has properties or fields of it's own.
+ Collections are supported through IEnumerable, which means the constraint will check if the actual and expected
+ collection contain the same values in the same order, where the values contained by the collection can have properties
+ and fields of their own that will be checked as well because of the recursive nature of this constraint.
+
+
+
+
+ Central location for all text related constraints
+
+
+
+
+ Constrain the argument to starts with the specified string
+
+
+
+
+ Constrain the argument to end with the specified string
+
+
+
+
+ Constrain the argument to contain the specified string
+
+
+
+
+ Constrain the argument to validate according to regex pattern
+
+
+
+
+ Provides access to the constraintes defined in the class to be used in context
+ with the syntax.
+
+
+
+
+ Constrain the argument to starts with the specified string
+
+
+
+
+
+ Constrain the argument to end with the specified string
+
+
+
+
+ Constrain the argument to contain the specified string
+
+
+
+
+ Constrain the argument to validate according to regex pattern
+
+
+
+
+ Throws NotSupportedException. Don't use Equals to define constraints. Use Equal instead.
+
+
+
+
+
+
+ Serves as a hash function for a particular type.
+
+
+ A hash code for the current .
+
+
+
+
+ This class defines a lot of method signatures, which we will use
+ to allow compatability on net-2.0
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ dummy
+
+
+
+
+ Allows expectations to be set on methods that should never be called.
+ For methods with void return value, you need to use LastCall or
+ DoNotExpect.Call() with a delegate.
+
+
+
+
+ Sets LastCall.Repeat.Never() on /any/ proxy on /any/ repository on the current thread.
+ This method if not safe for multi threading scenarios.
+
+
+
+
+ Accepts a delegate that will execute inside the method which
+ LastCall.Repeat.Never() will be applied to.
+ It is expected to be used with anonymous delegates / lambda expressions and only one
+ method should be called.
+
+
+ IService mockSrv = mocks.CreateMock(typeof(IService)) as IService;
+ DoNotExpect.Call(delegate{ mockSrv.Stop(); });
+ ...
+
+
+
+
+ An expectaton violation was detected.
+
+
+
+
+ Creates a new instance.
+
+ Message.
+
+
+
+ Serialization constructor
+
+
+
+
+ Signals that an object was call on a mock repository which doesn't
+ belong to this mock repository or not a mock
+
+
+
+
+ Creates a new instance.
+
+ Message.
+
+
+
+ Serialization constructor
+
+
+
+
+ Allows to set expectation on methods that has return values.
+ For methods with void return value, you need to use LastCall
+
+
+
+
+ The method options for the last call on /any/ proxy on /any/ repository on the current thread.
+ This method if not safe for multi threading scenarios, use .
+
+
+
+
+ Accepts a delegate that will execute inside the method, and then return the resulting
+ instance.
+ It is expected to be used with anonymous delegates / lambda expressions and only one
+ method should be called.
+
+
+ IService mockSrv = mocks.CreateMock(typeof(IService)) as IService;
+ Expect.Call(delegate{ mockSrv.Start(); }).Throw(new NetworkException());
+ ...
+
+
+
+
+ Get the method options for the last method call on the mockInstance.
+
+
+
+
+ A delegate that can be used to get better syntax on Expect.Call(delegate { foo.DoSomething(); });
+
+
+
+
+ Abstract class that holds common information for
+ expectations.
+
+
+
+
+ Interface to validate that a method call is correct.
+
+
+
+
+ Validate the arguments for the method.
+ This method can be called numerous times, so be careful about side effects
+
+ The arguments with which the method was called
+
+
+
+ Add an actual method call to this expectation
+
+
+
+
+ Returns the return value or throw the exception and setup any output / ref parameters
+ that has been set.
+
+
+
+
+ Builds the verification failure message.
+
+
+
+
+
+ Gets the error message.
+
+
+
+
+
+ Range of expected calls
+
+
+
+
+ Number of call actually made for this method
+
+
+
+
+ If this expectation is still waiting for calls.
+
+
+
+
+ The return value for a method matching this expectation
+
+
+
+
+ Gets or sets the exception to throw on a method matching this expectation.
+
+
+
+
+ Gets a value indicating whether this instance's action is staisfied.
+ A staisfied instance means that there are no more requirements from
+ this method. A method with non void return value must register either
+ a return value or an exception to throw.
+
+
+
+
+ Gets the method this expectation is for.
+
+
+
+
+ Gets or sets what special condtions there are for this method
+ repeating.
+
+
+
+
+ Gets a value indicating whether this expectation was satisfied
+
+
+
+
+ Specify whatever this expectation has a return value set
+ You can't check ReturnValue for this because a valid return value include null.
+
+
+
+
+ An action to execute when the method is matched.
+
+
+
+
+ Set the out / ref parameters for the method call.
+ The indexing is zero based and ignores any non out/ref parameter.
+ It is possible not to pass all the parameters. This method can be called only once.
+
+
+
+
+ Documentation Message
+
+
+
+
+ Gets the invocation for this expectation
+
+ The invocation.
+
+
+
+ Occurs when the exceptation is match on a method call
+
+
+
+
+ Allow to set the return value in the future, if it was already set.
+
+
+
+
+ Number of actuall calls made that passed this expectation
+
+
+
+
+ Range of expected calls that should pass this expectation.
+
+
+
+
+ The return value for a method matching this expectation
+
+
+
+
+ The exception to throw on a method matching this expectation.
+
+
+
+
+ The method this expectation is for.
+
+
+
+
+ The return value for this method was set
+
+
+
+
+ Whether this method will repeat
+ unlimited number of times.
+
+
+
+
+ A delegate that will be run when the
+ expectation is matched.
+
+
+
+
+ The arguments that matched this expectation.
+
+
+
+
+ Documentation message
+
+
+
+
+ The method originalInvocation
+
+
+
+
+ Get the hash code
+
+
+
+
+ Add an actual actualMethodCall call to this expectation
+
+
+
+
+ Builds the verification failure message.
+
+
+
+
+
+ Returns the return value or throw the exception and setup output / ref parameters
+
+
+
+
+ Validate the arguments for the method on the child methods
+
+ The arguments with which the method was called
+
+
+
+ Creates a new instance.
+
+ The originalInvocation for this method, required because it contains the generic type infromation
+ Number of method calls for this expectations
+
+
+
+ Creates a new instance.
+
+ Expectation.
+
+
+
+ Validate the arguments for the method on the child methods
+
+ The arguments with which the method was called
+
+
+
+ Determines if this object equal to obj
+
+
+
+
+ The error message for these arguments
+
+
+
+
+ Asserts that the delegate has the same parameters as the expectation's method call
+
+
+
+
+ Setter for the outpur / ref parameters for this expecataion.
+ Can only be set once.
+
+
+
+
+ Specify whether this expectation has a return value set
+ You can't check ReturnValue for this because a valid return value include null.
+
+
+
+
+ Gets the method this expectation is for.
+
+
+
+
+ Gets the originalInvocation for this expectation
+
+ The originalInvocation.
+
+
+
+ Gets or sets what special condtions there are for this method
+
+
+
+
+ Range of expected calls
+
+
+
+
+ Number of call actually made for this method
+
+
+
+
+ If this expectation is still waiting for calls.
+
+
+
+
+ Gets a value indicating whether this expectation was satisfied
+
+
+
+
+ The return value for a method matching this expectation
+
+
+
+
+ An action to execute when the method is matched.
+
+
+
+
+ Gets or sets the exception to throw on a method matching this expectation.
+
+
+
+
+ Gets a value indicating whether this instance's action is staisfied.
+ A staisfied instance means that there are no more requirements from
+ this method. A method with non void return value must register either
+ a return value or an exception to throw or an action to execute.
+
+
+
+
+ Documentation message
+
+
+
+
+ Occurs when the exceptation is match on a method call
+
+
+
+
+ Allow to set the return value in the future, if it was already set.
+
+
+
+
+ Gets the error message.
+
+
+
+
+
+ Expectation that matches any arguments for the method.
+
+
+
+
+ Creates a new instance.
+
+ Invocation for this expectation
+ Number of method calls for this expectations
+
+
+
+ Creates a new instance.
+
+ Expectation.
+
+
+
+ Validate the arguments for the method.
+
+ The arguments with which the method was called
+
+
+
+ Determines if the object equal to expectation
+
+
+
+
+ Get the hash code
+
+
+
+
+ Gets the error message.
+
+
+
+
+
+ Summary description for ArgsEqualExpectation.
+
+
+
+
+ Creates a new instance.
+
+ Expected args.
+ The invocation for this expectation
+ Number of method calls for this expectations
+
+
+
+ Validate the arguments for the method.
+
+ The arguments with which the method was called
+
+
+
+ Determines if the object equal to expectation
+
+
+
+
+ Get the hash code
+
+
+
+
+ Gets the error message.
+
+
+
+
+
+ Get the expected args.
+
+
+
+
+ Call a specified callback to verify the expectation
+
+
+
+
+ Creates a new instance.
+
+ Expectation.
+ Callback.
+
+
+
+ Creates a new instance.
+
+ Invocation for this expectation
+ Callback.
+ Number of method calls for this expectations
+
+
+
+ Validate the arguments for the method on the child methods
+
+ The arguments with which the method was called
+
+
+
+ Determines if the object equal to expectation
+
+
+
+
+ Get the hash code
+
+
+
+
+ Gets the error message.
+
+
+
+
+
+ Expect the method's arguments to match the contraints
+
+
+
+
+ Creates a new instance.
+
+ Invocation for this expectation
+ Constraints.
+ Number of method calls for this expectations
+
+
+
+ Creates a new instance.
+
+ Expectation.
+ Constraints.
+
+
+
+ Validate the arguments for the method.
+
+ The arguments with which the method was called
+
+
+
+ Determines if the object equal to expectation
+
+
+
+
+ Get the hash code
+
+
+
+
+ Gets the error message.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Summary for AndSpecification
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Summary description for FollowsEventNamingStandard
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Summary descritpion for NamedEventExistsOnDeclaringType
+
+
+
+
+
+
+
+
+ Doesn't log anything, just makes happy noises
+
+
+
+
+ Log expectations - allows to see what is going on inside Rhino Mocks
+
+
+
+
+ Logs the expectation as is was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the expectation as it was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the unexpected method call.
+
+ The invocation.
+ The message.
+
+
+
+ Logs the expectation as is was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the expectation as it was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the unexpected method call.
+
+ The invocation.
+ The message.
+
+
+
+ Operation on a remoting proxy
+
+
+ It is not possible to directly communicate to a real proxy via transparent proxy.
+ Transparent proxy impersonates a user type and only methods of that user type are callable.
+ The only methods that are guaranteed to exist on any transparent proxy are methods defined
+ in Object: namely ToString(), GetHashCode(), and Equals()).
+
+ These three methods are the only way to tell the real proxy to do something.
+ Equals() is the most suitable of all, since it accepts an arbitrary object parameter.
+ The RemotingProxy code is built so that if it is compared to an IRemotingProxyOperation,
+ transparentProxy.Equals(operation) will call operation.Process(realProxy).
+ This way we can retrieve a real proxy from transparent proxy and perform
+ arbitrary operation on it.
+
+
+
+
+ Generates remoting proxies and provides utility functions
+
+
+
+
+ Create the proxy using remoting
+
+
+
+
+ Check whether an object is a transparent proxy with a RemotingProxy behind it
+
+ Object to check
+ true if the object is a transparent proxy with a RemotingProxy instance behind it, false otherwise
+ We use Equals() method to communicate with the real proxy behind the object.
+ See IRemotingProxyOperation for more details
+
+
+
+ Retrieve a mocked object from a transparent proxy
+
+ Transparent proxy with a RemotingProxy instance behind it
+ Mocked object associated with the proxy
+ We use Equals() method to communicate with the real proxy behind the object.
+ See IRemotingProxyOperation for more details
+
+
+
+ Implementation of IInvocation based on remoting proxy
+
+ Some methods are marked NotSupported since they either don't make sense
+ for remoting proxies, or they are never called by Rhino Mocks
+
+
+
+ Rudimetry implementation that simply logs methods calls as text.
+
+
+
+
+ Initializes a new instance of the class.
+
+ The writer.
+
+
+
+ Logs the expectation as it was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the expectation as it was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the unexpected method call.
+
+ The invocation.
+ The message.
+
+
+
+ Behave like a stub, all properties and events acts normally, methods calls
+ return default values by default (but can use expectations to set them up), etc.
+
+
+
+
+ Records all the expectations for a mock
+
+
+
+
+ Different actions on this mock
+
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Verify that this mock expectations have passed.
+
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Set the exception to throw when Verify is called.
+ This is used to report exception that may have happened but where caught in the code.
+ This way, they are reported anyway when Verify() is called.
+
+
+
+
+ This method is called to indicate that a property behavior call.
+ This is done so we generate good error message in the common case of people using
+ Stubbed properties with Return().
+
+
+
+
+ Gets the matching verify state for this state
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Set the exception to throw when Verify is called.
+ This is used to report exception that may have happened but where caught in the code.
+ This way, they are reported anyway when Verify() is called.
+
+
+
+
+ This method is called to indicate that a property behavior call.
+ This is done so we generate good error message in the common case of people using
+ Stubbed properties with Return().
+
+
+
+
+ Creates a new instance.
+
+ Repository.
+ The proxy that generates the method calls
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Verify that this mock expectations have passed.
+
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Asserts the previous method is closed (had an expectation set on it so we can replay it correctly)
+
+
+
+
+ Get the default call count range expectation
+
+
+
+
+
+ Gets the last expectation.
+
+
+
+
+ Gets the total method calls count.
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Gets the matching verify state for this state
+
+
+
+
+ Initializes a new instance of the class.
+
+ The proxy that generates the method calls
+ Repository.
+
+
+
+ We don't care much about expectations here, so we will remove the expectation if
+ it is not closed.
+
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+
+ Get the default call count range expectation
+
+
+
+
+
+ Validate expectations on recorded methods, but in general completely ignoring them.
+ Similar to except that it would return a
+ when BackToRecord is called.
+
+
+
+
+ Validate all expectations on a mock
+
+
+
+
+ The repository for this state
+
+
+
+
+ The proxy object for this state
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Creates a new instance.
+
+ The previous state for this method
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Add a method call for this state' mock.
+ This allows derived method to cleanly get a the setupresult behavior while adding
+ their own.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Set the exception to throw when Verify is called.
+ This is used to report exception that may have happened but where caught in the code.
+ This way, they are reported anyway when Verify() is called.
+
+
+
+
+ not relevant
+
+
+
+
+ Verify that this mock expectations have passed.
+
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Gets the matching verify state for this state
+
+
+
+
+ Initializes a new instance of the class.
+
+ The previous state for this method
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Gets a mock state that matches the original mock state of the object.
+
+
+
+
+ Write rhino mocks log info to the trace
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ Initializes a new instance of the class.
+
+ if set to true [log recorded].
+ if set to true [log replayed].
+ if set to true [log unexpected].
+
+
+
+ Logs the expectation as is was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the expectation as it was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the unexpected method call.
+
+ The invocation.
+ The message.
+
+
+
+ Writes log information as stack traces about rhino mocks activity
+
+
+
+
+ Allows to redirect output to a different location.
+
+
+
+
+ Logs the expectation as is was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the expectation as it was recorded
+
+ The invocation.
+ The expectation.
+
+
+
+ Logs the unexpected method call.
+
+ The invocation.
+ The message.
+
+
+
+ Marker interface used to indicate that this is a partial mock.
+
+
+
+
+ Options for CallOriginalMethod
+
+
+
+
+ No expectation is created, the method will be called directly
+
+
+
+
+ Normal expectation is created, but when the method is later called, it will also call the original method
+
+
+
+
+ This is a data structure that is used by
+ to pass
+ the current method to the relevant delegate
+
+
+
+
+ Initializes a new instance of the class.
+
+ The invocation.
+
+
+
+ Gets the args for this method invocation
+
+
+
+
+ Get the method that was caused this invocation
+
+
+
+
+ Gets or sets the return value for this method invocation
+
+ The return value.
+
+
+
+ Adds optional new usage:
+ using(mockRepository.Record()) {
+ Expect.Call(mock.Method()).Return(retVal);
+ }
+ using(mockRepository.Playback()) {
+ // Execute code
+ }
+ N.B. mockRepository.ReplayAll() and mockRepository.VerifyAll()
+ calls are taken care of by Record/Playback
+
+
+ Creates proxied instances of types.
+
+
+
+ Generates a stub without needing a
+ Arguments for 's constructor
+ The of stub to create.
+ The stub
+
+
+
+ Generates a stub without needing a
+ The of stub.
+ Arguments for the 's constructor.
+ The stub
+
+
+
+ Generate a mock object without needing a
+ type of mock object to create.
+ Arguments for 's constructor
+ the mock object
+
+
+
+ Generate a multi-mock object without needing a
+ The typeof object to generate a mock for.
+ A second interface to generate a multi-mock for.
+ Arguments for 's constructor
+ the multi-mock object
+
+
+
+ Generate a multi-mock object without without needing a
+ The typeof object to generate a mock for.
+ An interface to generate a multi-mock for.
+ A second interface to generate a multi-mock for.
+ Arguments for 's constructor
+ the multi-mock object
+
+
+
+ Creates a multi-mock without without needing a
+ The type of mock to create, this can be a class
+ Any extra interfaces to add to the multi-mock, these can only be interfaces.
+ Arguments for 's constructor
+ the multi-mock object
+
+
+
+ Creates a strict mock without without needing a
+ Any arguments required for the 's constructor
+ The type of mock object to create.
+ The mock object with strict replay semantics
+
+
+
+ Creates a strict multi-mock without needing a
+ Any arguments required for the 's constructor
+ The type of mock object to create, this can be a class.
+ An interface to generate a multi-mock for, this must be an interface!
+ The multi-mock object with strict replay semantics
+
+
+
+ Creates a strict multi-mock without needing a
+ Any arguments required for the 's constructor
+ The type of mock object to create, this can be a class.
+ An interface to generate a multi-mock for, this must be an interface!
+ A second interface to generate a multi-mock for, this must be an interface!
+ The multi-mock object with strict replay semantics
+
+
+
+ Creates a strict multi-mock without needing a
+ The type of mock object to create, this can be a class
+ Any extra interfaces to generate a multi-mock for, these must be interaces!
+ Any arguments for the 's constructor
+ The strict multi-mock object
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Generate a mock object with dynamic replay semantics and remoting without needing the mock repository
+
+
+
+
+ Generate a mock object with strict replay semantics and remoting without needing the mock repository
+
+
+
+ Helper method to create a mock object without a repository instance and put the object back into replay mode.
+ The type of mock object to create
+ A delegate that uses a mock repository instance to create the underlying mock
+ The mock object in the replay mode.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This is a map of types to ProxyGenerators.
+
+
+
+
+ This is used to record the last repository that has a method called on it.
+
+
+
+
+ this is used to get to the last proxy on this repository.
+
+
+
+
+ For mock delegates, maps the proxy instance from intercepted invocations
+ back to the delegate that was originally returned to client code, if any.
+
+
+
+
+ All the proxies in the mock repositories
+
+
+
+
+ This is here because we can't put it in any of the recorders, since repeatable methods
+ have no orderring, and if we try to handle them using the usual manner, we would get into
+ wierd situations where repeatable method that was defined in an orderring block doesn't
+ exists until we enter this block.
+
+
+
+
+ Creates a new instance.
+
+
+
+
+ Move the repository to ordered mode
+
+
+
+
+ Move the repository to un-ordered mode
+
+
+
+
+ Creates a mock for the specified type.
+
+ Type.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a strict mock for the specified type.
+
+ Type.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a remoting mock for the specified type.
+
+ Type.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a strict remoting mock for the specified type.
+
+ Type.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a remoting mock for the specified type.
+
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+
+ Creates a strict remoting mock for the specified type.
+
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+
+ Creates a mock from several types, with strict semantics.
+ Only may be a class.
+
+
+
+
+ Creates a strict mock from several types, with strict semantics.
+ Only may be a class.
+
+
+
+
+ Creates a mock from several types, with strict semantics.
+ Only may be a class.
+
+ The main type to mock.
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class.
+
+
+
+ Creates a strict mock from several types, with strict semantics.
+ Only may be a class.
+
+ The main type to mock.
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class.
+
+
+
+ Creates a mock from several types, with dynamic semantics.
+ Only may be a class.
+
+ The main type to mock.
+ Extra interface types to mock.
+
+
+
+ Creates a mock from several types, with dynamic semantics.
+ Only may be a class.
+
+ The main type to mock.
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class.
+
+
+ Creates a dynamic mock for the specified type.
+ Type.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+ Creates a dynamic mock for the specified type.
+ Type.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+ Creates a dynamic mock for the specified type.
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a mock object that defaults to calling the class methods if no expectation is set on the method.
+ Type.
+ Arguments for the class' constructor.
+
+
+ Creates a mock object that defaults to calling the class methods.
+ Type.
+ Extra interface types to mock.
+
+
+ Creates a mock object that defaults to calling the class methods.
+ Type.
+ Extra interface types to mock.
+ Arguments for the class' constructor.
+
+
+ Creates a mock object using remoting proxies
+ Type to mock - must be MarshalByRefObject
+ Mock object
+ Proxy mock can mock non-virtual methods, but not static methods
+ Creates the mock state for this proxy
+
+
+
+ Cause the mock state to change to replay, any further call is compared to the
+ ones that were called in the record state.
+
+ This method *cannot* be called from inside an ordering.
+ the object to move to replay state
+
+
+
+ Cause the mock state to change to replay, any further call is compared to the
+ ones that were called in the record state.
+
+ the object to move to replay state
+
+
+
+ Move the mocked object back to record state.You can (and it's recommended) to run {Verify()} before you use this method.
+ Will delete all current expectations!
+
+
+
+ Move the mocked object back to record state.
+ Optionally, can delete all current expectations, but allows more granularity about how
+ it would behave with regard to the object state.
+
+
+
+
+ Verify that all the expectations for this object were fulfilled.
+
+ the object to verify the expectations for
+
+
+
+ Get the method options for the last call on
+ mockedInstance.
+
+ The mock object
+ Method options for the last call
+
+
+
+ Maps an invocation proxy back to the mock object instance that was originally
+ returned to client code which might have been a delegate to this proxy.
+
+ The mock object proxy from the intercepted invocation
+ The mock object
+
+
+ This is provided to allow advance extention functionality, where Rhino Mocks standard functionality is not enough.
+ The type to mock
+ Delegate that create the first state of the mocked object (usualy the record state).
+ Additional types to be implemented, this can be only interfaces
+ optional arguments for the constructor
+
+
+
+
+ Method: GetMockedObject
+ Get an IProxy from a mocked object instance, or throws if the
+ object is not a mock object.
+
+
+
+
+ Method: GetMockedObjectOrNull
+ Get an IProxy from a mocked object instance, or null if the
+ object is not a mock object.
+
+
+
+ Pops the recorder.
+
+
+ Pushes the recorder.
+ New recorder.
+
+
+
+ All the mock objects in this repository will be moved
+ to record state.
+
+
+
+
+ All the mock objects in this repository will be moved
+ to record state.
+
+
+
+
+ Replay all the mocks from this repository
+
+
+
+
+ Verify all the mocks from this repository
+
+
+
+
+ Gets the proxy generator for a specific type. Having a single ProxyGenerator
+ with multiple types linearly degrades the performance so this implementation
+ keeps one ProxyGenerator per type.
+
+
+
+ Set the exception to be thrown when verified is called.
+
+
+
+ Creates a mock for the spesified type with strict mocking semantics.
+ Strict semantics means that any call that wasn't explicitly recorded is considered an error and would cause an exception to be thrown.
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a mock for the spesified type with strict mocking semantics.
+ Strict semantics means that any call that wasn't explicitly recorded is considered an error and would cause an exception to be thrown.
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a dynamic mock for the specified type.
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Creates a mock object from several types.
+
+
+
+
+ Creates a strict mock object from several types.
+
+
+
+
+ Create a mock object from several types with dynamic semantics.
+
+
+
+
+ Create a mock object from several types with partial semantics.
+
+
+
+
+ Create a mock object from several types with strict semantics.
+
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Create a strict mock object from several types with strict semantics.
+
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Create a mock object from several types with dynamic semantics.
+
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Create a mock object from several types with partial semantics.
+
+ Extra interface types to mock.
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Create a mock object with from a class that defaults to calling the class methods
+
+ Arguments for the class' constructor, if mocking a concrete class
+
+
+
+ Create a stub object, one that has properties and events ready for use, and
+ can have methods called on it. It requires an explicit step in order to create
+ an expectation for a stub.
+
+ The arguments for constructor.
+
+
+
+ Create a stub object, one that has properties and events ready for use, and
+ can have methods called on it. It requires an explicit step in order to create
+ an expectation for a stub.
+
+ The type.
+ The arguments for constructor.
+ The stub
+
+
+
+ Returns true if the passed mock is currently in replay mode.
+
+ The mock to test.
+ True if the mock is in replay mode, false otherwise.
+
+
+
+ Determines whether the specified proxy is a stub.
+
+ The proxy.
+
+
+
+ Register a call on a prperty behavior
+
+
+
+
+
+ Gets the recorder.
+
+
+
+
+
+ Gets the replayer for this repository.
+
+
+
+
+
+ Gets the last proxy which had a method call.
+
+
+
+
+ Delegate: CreateMockState
+ This is used internally to cleanly handle the creation of different
+ RecordMockStates.
+
+
+
+
+ A set of extension methods that adds Arrange Act Assert mode to Rhino Mocks
+
+
+
+
+ Create an expectation on this mock for this action to occur
+
+
+ The mock.
+ The action.
+
+
+
+
+ Reset all expectations on this mock object
+
+
+ The mock.
+
+
+
+ Reset the selected expectation on this mock object
+
+
+ The mock.
+ The options to reset the expectations on this mock.
+
+
+
+ Cause the mock state to change to replay, any further call is compared to the
+ ones that were called in the record state.
+
+ the mocked object to move to replay state
+
+
+
+ Gets the mock repository for this specificied mock object
+
+
+ The mock.
+
+
+
+
+ Create an expectation on this mock for this action to occur
+
+
+
+ The mock.
+ The action.
+
+
+
+
+ Tell the mock object to perform a certain action when a matching
+ method is called.
+ Does not create an expectation for this method.
+
+
+ The mock.
+ The action.
+
+
+
+
+ Tell the mock object to perform a certain action when a matching
+ method is called.
+ Does not create an expectation for this method.
+
+
+
+ The mock.
+ The action.
+
+
+
+
+ Gets the arguments for calls made on this mock object and the method that was called
+ in the action.
+
+
+ The mock.
+ The action.
+
+
+ Here we will get all the arguments for all the calls made to DoSomething(int)
+
+ var argsForCalls = foo54.GetArgumentsForCallsMadeOn(x => x.DoSomething(0))
+
+
+
+
+
+ Gets the arguments for calls made on this mock object and the method that was called
+ in the action and matches the given constraints
+
+
+ The mock.
+ The action.
+ The setup constraints.
+
+
+ Here we will get all the arguments for all the calls made to DoSomething(int)
+
+ var argsForCalls = foo54.GetArgumentsForCallsMadeOn(x => x.DoSomething(0))
+
+
+
+
+
+ Asserts that a particular method was called on this mock object
+
+
+ The mock.
+ The action.
+
+
+
+ Asserts that a particular method was called on this mock object that match
+ a particular constraint set.
+
+
+ The mock.
+ The action.
+ The setup constraints.
+
+
+
+ Asserts that a particular method was called on this mock object that match
+ a particular constraint set.
+
+
+ The mock.
+ The action.
+
+
+
+ Asserts that a particular method was called on this mock object that match
+ a particular constraint set.
+
+
+ The mock.
+ The action.
+ The setup constraints.
+
+
+
+ Asserts that a particular method was NOT called on this mock object
+
+
+ The mock.
+ The action.
+
+
+
+ Asserts that a particular method was NOT called on this mock object that match
+ a particular constraint set.
+
+
+ The mock.
+ The action.
+ The setup constraints.
+
+
+
+ Asserts that a particular method was NOT called on this mock object
+
+
+ The mock.
+ The action.
+
+
+
+ Asserts that a particular method was NOT called on this mock object
+
+
+ The mock.
+ The action.
+ The setup constraints.
+
+
+
+ Finds the approprite implementation type of this item.
+ This is the class or an interface outside of the rhino mocks.
+
+ The mocked obj.
+
+
+
+
+ Verifies all expectations on this mock object
+
+ The mock object.
+
+
+
+ Gets the event raiser for the event that was called in the action passed
+
+ The type of the event source.
+ The mock object.
+ The event subscription.
+
+
+
+
+ Raise the specified event using the passed arguments.
+ The even is extracted from the passed labmda
+
+ The type of the event source.
+ The mock object.
+ The event subscription.
+ The sender.
+ The instance containing the event data.
+
+
+
+ Raise the specified event using the passed arguments.
+ The even is extracted from the passed labmda
+
+ The type of the event source.
+ The mock object.
+ The event subscription.
+ The args.
+
+
+ TODO: Make this better! It currently breaks down when mocking classes or
+ ABC's that call other virtual methods which are getting intercepted too. I wish
+ we could just walk Expression{Action{Action{T}} to assert only a single
+ method is being made.
+
+ The workaround is to not call foo.AssertWasCalled .. rather foo.VerifyAllExpectations()
+ The type of mock object
+ The mock repository
+ The actual mock object to assert expectations on.
+
+
+
+ Fake type that disallow creating it.
+ Should have been System.Type, but we can't use it.
+
+
+
+
+ Utility class for dealing with messing generics scenarios.
+
+
+
+
+ There are issues with trying to get this to work correctly with open generic types, since this is an edge case,
+ I am letting the runtime handle it.
+
+
+
+
+ Gets the real type, including de-constructing and constructing the type of generic
+ methods parameters.
+
+ The type.
+ The invocation.
+
+
+
+
+ Because we need to support complex types here (simple generics were handled above) we
+ need to be aware of the following scenarios:
+ List[T] and List[Foo[T]]
+
+
+
+
+ ExpectationsList
+
+
+
+
+ Dictionary
+
+
+
+
+ Dictionary class
+
+
+
+
+ Create a new instance of ProxyStateDictionary
+
+
+
+
+ Allows to call a method and immediately get it's options.
+
+
+
+
+ Interface to allow calling a method and immediately get it's options.
+
+
+
+
+ Get the method options for the call
+
+ The method call should go here, the return value is ignored
+
+
+
+ Creates a new instance.
+
+
+
+
+ Get the method options for the call
+
+ The method call should go here, the return value is ignored
+
+
+
+ Allows to call a method and immediately get it's options.
+ Set the expected number for the call to Any()
+
+
+
+
+ Creates a new instance.
+
+ Proxy.
+ Mocked instance.
+
+
+
+ Get the method options for the call
+
+ The method call should go here, the return value is ignored
+
+
+
+ This class is reponsible for taking a delegate and creating a wrapper
+ interface around it, so it can be mocked.
+
+
+
+
+ The scope for all the delegate interfaces create by this mock repository.
+
+
+
+
+ Gets a type with an "Invoke" method suitable for use as a target of the
+ specified delegate type.
+
+
+
+
+
+
+ Raise events for all subscribers for an event
+
+
+
+
+ Raise events for all subscribers for an event
+
+
+
+
+ Raise the event
+
+
+
+
+ The most common form for the event handler signature
+
+
+
+
+ Create an event raiser for the specified event on this instance.
+
+
+
+
+ Creates a new instance of EventRaiser
+
+
+
+
+ Raise the event
+
+
+
+
+ The most common signature for events
+ Here to allow intellisense to make better guesses about how
+ it should suggest parameters.
+
+
+
+
+ Allows to define what would happen when a method
+ is called.
+
+
+
+
+ Allows to define what would happen when a method
+ is called.
+
+
+
+
+ Set the return value for the method.
+
+ The object the method will return
+ IRepeat that defines how many times the method will return this value
+
+
+
+ Allow to override this return value in the future
+
+ IRepeat that defines how many times the method will return this value
+
+
+
+ Throws the specified exception when the method is called.
+
+ Exception to throw
+
+
+
+ Ignores the arguments for this method. Any argument will be matched
+ againt this method.
+
+
+
+
+ Add constraints for the method's arguments.
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched
+ and allow to optionally modify the invocation as needed
+
+
+
+
+ Call the original method on the class, bypassing the mocking layers.
+
+
+
+
+
+ Call the original method on the class, optionally bypassing the mocking layers.
+
+
+
+
+
+ Use the property as a simple property, getting/setting the values without
+ causing mock expectations.
+
+
+
+
+ Expect last (property) call as property setting, ignore the argument given
+
+
+
+
+
+ Expect last (property) call as property setting with a given argument.
+
+
+
+
+
+
+ Get an event raiser for the last subscribed event.
+
+
+
+
+ Set the parameter values for out and ref parameters.
+ This is done using zero based indexing, and _ignoring_ any non out/ref parameter.
+
+
+
+
+ Documentation message for the expectation
+
+ Message
+
+
+
+ Better syntax to define repeats.
+
+
+
+
+ Allows to specify the number of time for method calls
+
+
+
+
+ Repeat the method twice.
+
+
+
+
+ Repeat the method once.
+
+
+
+
+ Repeat the method at least once, then repeat as many time as it would like.
+
+
+
+
+ Repeat the method any number of times.
+ This has special affects in that this method would now ignore orderring.
+
+
+
+
+ Set the range to repeat an action.
+
+ Min.
+ Max.
+
+
+
+ Set the amount of times to repeat an action.
+
+
+
+
+ This method must not appear in the replay state.
+ This has special affects in that this method would now ignore orderring.
+
+
+
+
+ Creates a new instance.
+
+ the repository for this expectation
+ the recorder for this proxy
+ the proxy for this expectation
+ Expectation.
+
+
+
+ Add constraints for the method's arguments.
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Set the return value for the method.
+
+ The object the method will return
+ IRepeat that defines how many times the method will return this value
+
+
+
+ Set the return value for the method, but allow to override this return value in the future
+
+ IRepeat that defines how many times the method will return this value
+
+
+
+ Throws the specified exception when the method is called.
+
+ Exception to throw
+
+
+
+ Ignores the arguments for this method. Any argument will be matched
+ againt this method.
+
+
+
+
+ Call the original method on the class, bypassing the mocking layers.
+
+
+
+
+
+ Call the original method on the class, optionally bypassing the mocking layers
+
+
+
+
+
+ Use the property as a simple property, getting/setting the values without
+ causing mock expectations.
+
+
+
+
+ Expect last (property) call as property setting, ignore the argument given
+
+
+
+
+
+ Expect last (property) call as property setting with a given argument.
+
+
+
+
+
+
+ Gets the event raiser for the last event
+
+
+
+
+ Set the parameter values for out and ref parameters.
+ This is done using zero based indexing, and _ignoring_ any non out/ref parameter.
+
+
+
+
+ Repeat the method twice.
+
+
+
+
+ Repeat the method once.
+
+
+
+
+ Repeat the method at least once, then repeat as many time as it would like.
+
+
+
+
+ This method must not appear in the replay state.
+
+
+
+
+ Documentation message for the expectation
+
+ Message
+
+
+
+ Repeat the method any number of times.
+
+
+
+
+ Set the range to repeat an action.
+
+ Min.
+ Max.
+
+
+
+ Set the amount of times to repeat an action.
+
+
+
+
+ Better syntax to define repeats.
+
+
+
+
+ This class will provide hash code for hashtables without needing
+ to call the GetHashCode() on the object, which may very well be mocked.
+ This class has no state so it is a singelton to avoid creating a lot of objects
+ that does the exact same thing. See flyweight patterns.
+
+
+
+
+ Get the hash code for a proxy object without calling GetHashCode()
+ on the object.
+
+
+
+
+ Compares two instances of mocked objects
+
+
+
+
+ Compare two mocked objects
+
+
+
+
+ The next hash code value for a mock object.
+ This is safe for multi threading.
+
+
+
+
+ The sole instance of
+
+
+
+
+ This is a dummy type that is used merely to give DynamicProxy the proxy instance that
+ it needs to create IProxy's types.
+
+
+
+
+ Interface to find the repository of a mocked object
+
+
+
+
+ Return true if it should call the original method on the object
+ instead of pass it to the message chain.
+
+ The method to call
+
+
+
+ Register a method to be called on the object directly
+
+
+
+
+ Register a property on the object that will behave as a simple property
+
+
+
+
+ Check if the method was registered as a property method.
+
+
+
+
+ Do get/set on the property, according to need.
+
+
+
+
+ Do add/remove on the event
+
+
+
+
+ Get the subscribers of a spesific event
+
+
+
+
+ Gets the declaring type of the method, taking into acccount the possible generic
+ parameters that it was created with.
+
+
+
+
+ Clears the state of the object, remove original calls, property behavior, subscribed events, etc.
+
+
+
+
+ Get all the method calls arguments that were made against this object with the specificed
+ method.
+
+
+ Only method calls in replay mode are counted
+
+
+
+
+ Records the method call
+
+
+
+
+ Mocks that are tied to this mock lifestyle
+
+
+
+
+ The unique hash code of this mock, which is not related
+ to the value of the GetHashCode() call on the object.
+
+
+
+
+ Gets the repository.
+
+
+
+
+ Gets the implemented types by this mocked object
+
+ The implemented.
+
+
+
+ Gets or sets the constructor arguments.
+
+ The constructor arguments.
+
+
+
+ The mocked instance that this is representing
+
+
+
+
+ Create a new instance of
+
+
+
+
+ Return true if it should call the original method on the object
+ instead of pass it to the message chain.
+
+ The method to call
+
+
+
+ Register a method to be called on the object directly
+
+
+
+
+ Register a property on the object that will behave as a simple property
+ Return true if there is already a value for the property
+
+
+
+
+ Check if the method was registered as a property method.
+
+
+
+
+ Do get/set on the property, according to need.
+
+
+
+
+ Do add/remove on the event
+
+
+
+
+ Get the subscribers of a spesific event
+
+
+
+
+ Gets the declaring type of the method, taking into acccount the possible generic
+ parameters that it was created with.
+
+
+
+
+ Get all the method calls arguments that were made against this object with the specificed
+ method.
+
+
+
+
+ Only method calls in replay mode are counted
+
+
+
+
+ Records the method call
+
+
+
+
+
+
+ Clears the state of the object, remove original calls, property behavior, subscribed events, etc.
+
+
+
+
+ Mocks that are tied to this mock lifestyle
+
+
+
+
+ The unique hash code of this proxy, which is not related
+ to the value of the GetHashCode() call on the object.
+
+
+
+
+ Gets the repository.
+
+
+
+
+ Gets or sets the constructor arguments.
+
+ The constructor arguments.
+
+
+
+ The mocked instance that this is representing
+
+
+
+
+ Gets the implemented types by this mocked object
+
+ The implemented.
+
+
+
+ Range for expected method calls
+
+
+
+
+ Creates a new instance.
+
+ Min.
+ Max.
+
+
+
+ Return the string representation of this range.
+
+
+
+
+ Gets or sets the min.
+
+
+
+
+
+ Gets or sets the max.
+
+
+
+
+
+ Records all the expectations for a mock and
+ return a ReplayDynamicMockState when Replay()
+ is called.
+
+
+
+
+ Creates a new instance.
+
+ Repository.
+ The proxy that generates the method calls
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Get the default call count range expectation
+
+
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Records all the expectations for a mock and
+ return a ReplayPartialMockState when Replay()
+ is called.
+
+
+
+
+ Creates a new instance.
+
+ Repository.
+ The proxy that generates the method calls
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Gets a mock state that matches the original mock state of the object.
+
+
+
+
+ Options for special repeat option
+
+
+
+
+ This method can be called only as many times as the IMethodOptions.Expect allows.
+
+
+
+
+ This method should never be called
+
+
+
+
+ This method can be call any number of times
+
+
+
+
+ This method will call the original method
+
+
+
+
+ This method will call the original method, bypassing the mocking layer
+
+
+
+
+ This method will simulate simple property behavior
+
+
+
+
+ Validate all expectations on a mock and ignores calls to
+ any method that was not setup properly.
+
+
+
+
+ Creates a new instance.
+
+ The previous state for this method
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Validate all expectations on a mock and ignores calls to
+ any method that was not setup properly.
+
+
+
+
+ Creates a new instance.
+
+ The previous state for this method
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Summary description for RhinoInterceptor.
+
+
+
+
+ Creates a new instance.
+
+
+
+
+ Intercept a method call and direct it to the repository.
+
+
+
+
+ Validate arguments for methods
+
+
+
+
+ Validate that the passed argument is not null.
+
+ The object to validate
+ The name of the argument
+
+ If the obj is null, an ArgumentNullException with the passed name
+ is thrown.
+
+
+
+
+ Validate that the arguments are equal.
+
+ Expected args.
+ Actual Args.
+
+
+
+ Validate that the two arguments are equals, including validation for
+ when the arguments are collections, in which case it will validate their values.
+
+
+
+
+ This method is safe for use even if any of the objects is a mocked object
+ that override equals.
+
+
+
+
+ Throw an object already verified when accessed
+
+
+
+
+ Create a new instance of VerifiedMockState
+
+ The previous mock state, used to get the initial record state
+
+
+
+ Add a method call for this state' mock.
+
+ The invocation for this method
+ The method that was called
+ The arguments this method was called with
+
+
+
+ Verify that this mock expectations have passed.
+
+
+
+
+ Verify that we can move to replay state and move
+ to the reply state.
+
+
+
+
+ Gets a mock state that match the original mock state of the object.
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Set the exception to throw when Verify is called.
+ This is used to report exception that may have happened but where caught in the code.
+ This way, they are reported anyway when Verify() is called.
+
+
+
+
+ not relevant
+
+
+
+
+ Gets the matching verify state for this state
+
+
+
+
+ Get the options for the last method call
+
+
+
+
+ Records the actions on all the mocks created by a repository.
+
+
+
+
+ Records the specified call with the specified args on the mocked object.
+
+
+
+
+ Get the expectation for this method on this object with this arguments
+
+
+
+
+ This check the methods that were setup using the SetupResult.For()
+ or LastCall.Repeat.Any() and that bypass the whole expectation model.
+
+
+
+
+ Gets the all expectations for a mocked object and method combination,
+ regardless of the expected arguments / callbacks / contraints.
+
+ Mocked object.
+ Method.
+ List of all relevant expectation
+
+
+
+ Gets the all expectations for proxy.
+
+ Mocked object.
+ List of all relevant expectation
+
+
+
+ Removes all the repeatable expectations for proxy.
+
+ Mocked object.
+
+
+
+ Replaces the old expectation with the new expectation for the specified proxy/method pair.
+ This replace ALL expectations that equal to old expectations.
+
+ Proxy.
+ Method.
+ Old expectation.
+ New expectation.
+
+
+
+ Adds the recorder and turn it into the active recorder.
+
+ Recorder.
+
+
+
+ Moves to previous recorder.
+
+
+
+
+ Gets the recorded expectation or null.
+
+
+
+
+ Gets the next expected calls string.
+
+
+
+
+ Moves to parent recorder.
+
+
+
+
+ Set the expectation so it can repeat any number of times.
+
+
+
+
+ Removes the expectation from the recorder
+
+
+
+
+ Clear the replayer to call (and all its chain of replayers)
+ This also removes it from the list of expectations, so it will never be considered again
+
+
+
+
+ Get the expectation for this method on this object with this arguments
+
+
+
+
+ Gets a value indicating whether this instance has expectations that weren't satisfied yet.
+
+
+ true if this instance has expectations; otherwise, false.
+
+
+
+
+ Allows to set various options for the last method call on
+ a specified object.
+ If the method has a return value, it's recommended to use Expect
+
+
+
+
+ Allows to get an interface to work on the last call.
+
+ The mocked object
+ Interface that allows to set options for the last method call on this object
+
+
+
+ Set the return value for the method.
+
+ The object the method will return
+ IRepeat that defines how many times the method will return this value
+
+
+
+ Set the return value for the method. This overload is needed for LastCall.Return(null)
+
+ The object the method will return
+ IRepeat that defines how many times the method will return this value
+
+
+
+ Throws the specified exception when the method is called.
+
+ Exception to throw
+
+
+
+ Ignores the arguments for this method. Any argument will be matched
+ againt this method.
+
+
+
+
+ Add constraints for the method's arguments.
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Set a callback method for the last call
+
+
+
+
+ Call the original method on the class, bypassing the mocking layers, for the last call.
+
+
+
+
+ Call the original method on the class, optionally bypassing the mocking layers, for the last call.
+
+
+
+
+ Set a delegate to be called when the expectation is matched.
+ The delegate return value will be returned from the expectation.
+
+
+
+
+ Gets an interface that will raise the last event when called.
+
+
+
+
+ Set the parameter values for out and ref parameters.
+ This is done using zero based indexing, and _ignoring_ any non out/ref parameter.
+
+
+
+
+ Documentation message for the expectation
+
+ Message
+
+
+
+ Use the property as a simple property, getting/setting the values without
+ causing mock expectations.
+
+
+
+
+ Better syntax to define repeats.
+
+
+
+
+ Base class for method recorders, handle delegating to inner recorder if needed.
+
+
+
+
+ List of the expected actions on for this recorder
+ The legal values are:
+ * Expectations
+ * Method Recorders
+
+
+
+
+ The current recorder.
+
+
+
+
+ The current replayer;
+
+
+
+
+ The parent recorder of this one, may be null.
+
+
+
+
+ This contains a list of all the replayers that should be ignored
+ for a spesific method call. A replayer gets into this list by calling
+ ClearReplayerToCall() on its parent. This list is Clear()ed on each new invocation.
+
+
+
+
+ All the repeatable methods calls.
+
+
+
+
+ Counts the recursion depth of the current expectation search stack
+
+
+
+
+ Creates a new instance.
+
+
+
+
+ Creates a new instance.
+
+ Parent recorder.
+ Repeatable methods
+
+
+
+ Records the specified call with the specified args on the mocked object.
+
+
+
+
+ Get the expectation for this method on this object with this arguments
+
+
+
+
+ Gets the all expectations for a mocked object and method combination,
+ regardless of the expected arguments / callbacks / contraints.
+
+ Mocked object.
+ Method.
+ List of all relevant expectation
+
+
+
+ Gets the all expectations for proxy.
+
+ Mocked object.
+ List of all relevant expectation
+
+
+
+ Replaces the old expectation with the new expectation for the specified proxy/method pair.
+ This replace ALL expectations that equal to old expectations.
+
+ Proxy.
+ Method.
+ Old expectation.
+ New expectation.
+
+
+
+ Remove the all repeatable expectations for proxy.
+
+ Mocked object.
+
+
+
+ Set the expectation so it can repeat any number of times.
+
+
+
+
+ Removes the expectation from the recorder
+
+
+
+
+ Adds the recorder and turn it into the active recorder.
+
+ Recorder.
+
+
+
+ Moves to previous recorder.
+
+
+
+
+ Moves to parent recorder.
+
+
+
+
+ Gets the recorded expectation or null.
+
+
+
+
+ Clear the replayer to call (and all its chain of replayers).
+ This also removes it from the list of expectations, so it will never be considered again
+
+
+
+
+ Get the expectation for this method on this object with this arguments
+
+
+
+
+ Gets the next expected calls string.
+
+
+
+
+ Handles the real getting of the recorded expectation or null.
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Should this replayer be considered valid for this call?
+
+
+
+
+ This check the methods that were setup using the SetupResult.For()
+ or LastCall.Repeat.Any() and that bypass the whole expectation model.
+
+
+
+
+ Gets a value indicating whether this instance has expectations that weren't satisfied yet.
+
+
+ true if this instance has expectations; otherwise, false.
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Ordered collection of methods, methods must arrive in specified order
+ in order to pass.
+
+
+
+
+ Unordered collection of method records, any expectation that exist
+ will be matched.
+
+
+
+
+ The parent recorder we have redirected to.
+ Useful for certain edge cases in orderring.
+ See: FieldProblem_Entropy for the details.
+
+
+
+
+ Creates a new instance.
+
+ Parent recorder.
+ Repeatable methods
+
+
+
+ Creates a new instance.
+
+
+
+
+ Records the specified call with the specified args on the mocked object.
+
+ Mocked object.
+ Method.
+ Expectation.
+
+
+
+ Get the expectation for this method on this object with this arguments
+
+ Invocation for this method
+ Mocked object.
+ Method.
+ Args.
+ True is the call was recorded, false otherwise
+
+
+
+ Gets the all expectations for a mocked object and method combination,
+ regardless of the expected arguments / callbacks / contraints.
+
+ Mocked object.
+ Method.
+ List of all relevant expectation
+
+
+
+ Gets the all expectations for proxy.
+
+ Mocked object.
+ List of all relevant expectation
+
+
+
+ Replaces the old expectation with the new expectation for the specified proxy/method pair.
+ This replace ALL expectations that equal to old expectations.
+
+ Proxy.
+ Method.
+ Old expectation.
+ New expectation.
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Handles the real getting of the recorded expectation or null.
+
+
+
+
+ Handle the real execution of this method for the derived class
+
+
+
+
+ Gets the next expected calls string.
+
+
+
+
+ Create an exception for an unexpected method call.
+
+
+
+
+ Gets a value indicating whether this instance has expectations that weren't satisfied yet.
+
+
+ true if this instance has expectations; otherwise, false.
+
+
+
+
+ Creates a new instance.
+
+ Parent recorder.
+ Repetable methods
+
+
+
+ Creates a new instance.
+
+
+
+
+ Handles the real getting of the recorded expectation or null.
+
+
+
+
+ Get the expectation for this method on this object with this arguments
+
+
+
+
+ Gets the next expected calls string.
+
+
+
+
+ Hold an expectation for a method call on an object
+
+
+
+
+ Creates a new instance.
+
+ Proxy.
+ Method.
+ Expectation.
+
+
+
+ Determines if the object equal to this instance
+
+ Obj.
+
+
+
+
+ Gets the hash code.
+
+
+
+
+
+ Gets the proxy.
+
+
+
+
+
+ Gets the method.
+
+
+
+
+
+ Gets the expectation.
+
+
+
+
+
+ Holds a pair of mocked object and a method
+ and allows to compare them against each other.
+ This allows us to have a distinction between mockOne.MyMethod() and
+ mockTwo.MyMethod()...
+
+
+
+
+ Creates a new instance.
+
+ Proxy.
+ Method.
+
+
+
+ Determines whatever obj equals to this instance.
+ ProxyMethodPairs are equal when they point to the same /instance/ of
+ an object, and to the same method.
+
+ Obj.
+
+
+
+
+ Gets the hash code.
+
+
+
+
+
+ Gets the proxy.
+
+
+
+
+
+ Gets the method.
+
+
+
+
+
+ Change the recorder from ordered to unordered and vice versa
+
+
+
+
+ Creates a new instance.
+
+
+
+
+ Disposes this instance.
+
+
+
+
+ Accessor for the current mocker
+
+
+
+
+ The current mocker
+
+
+
+
+ Used for [assembly: InternalsVisibleTo(RhinoMocks.StrongName)]
+ Used for [assembly: InternalsVisibleTo(RhinoMocks.NormalName)]
+
+
+
+
+ Strong name for the Dynamic Proxy assemblies. Used for InternalsVisibleTo specification.
+
+
+
+
+ Normal name for dynamic proxy assemblies. Used for InternalsVisibleTo specification.
+
+
+
+
+ Logs all method calls for methods
+
+
+
+
+ Setup method calls to repeat any number of times.
+
+
+
+
+ Get the method options and set the last method call to repeat
+ any number of times.
+ This also means that the method would transcend ordering
+
+
+
+
+ Get the method options for the last method call on the mockInstance and set it
+ to repeat any number of times.
+ This also means that the method would transcend ordering
+
+
+
+
+ Utility class for working with method calls.
+
+
+
+
+ Return the string representation of a method call and its arguments.
+
+ The method
+ The method arguments
+ Invocation of the method, used to get the generics arguments
+ Delegate to format the parameter
+ The string representation of this method call
+
+
+
+ Return the string representation of a method call and its arguments.
+
+ The invocation of the method, used to get the generic parameters
+ The method
+ The method arguments
+ The string representation of this method call
+
+
+
+ Delegate to format the argument for the string representation of
+ the method call.
+
+
+
+
+ Utility to get the default value for a type
+
+
+
+
+ The default value for a type.
+ Null for reference types and void
+ 0 for value types.
+ First element for enums
+ Note that we need to get the value even for opened generic types, such as those from
+ generic methods.
+
+ Type.
+ The invocation.
+ the default value
+
+
+
+ Allows easier access to MockRepository, works closely with Mocker.Current to
+ allow access to a context where the mock repository is automatially verified at
+ the end of the code block.
+
+
+
+
+ Initialize a code block where Mocker.Current is initialized.
+ At the end of the code block, all the expectation will be verified.
+ This overload will create a new MockRepository.
+
+ The code that will be executed under the mock context
+
+
+
+ Initialize a code block where Mocker.Current is initialized.
+ At the end of the code block, all the expectation will be verified.
+ This overload will create a new MockRepository.
+
+ The mock repository to use, at the end of the code block, VerifyAll() will be called on the repository.
+ The code that will be executed under the mock context
+
+
+
+ Create a FluentMocker
+
+ The mock repository to use.
+
+
+
+ A method with no arguments and no return value that will be called under the mock context.
+
+
+
+
+ FluentMocker implements some kind of fluent interface attempt
+ for saying "With the Mocks [mocks], Expecting (in same order) [things] verify [that]."
+
+
+
+
+ Interface to verify previously defined expectations
+
+
+
+
+ Verifies if a piece of code
+
+
+
+
+ Defines unordered expectations
+
+ A delegate describing the expectations
+ an IMockVerifier
+
+
+
+ Defines ordered expectations
+
+ A delegate describing the expectations
+ an IMockVerifier
+
+
+
+ Verifies previously defined expectations
+
+
+
+
+ This delegate is compatible with the System.Func{T,R} signature
+ We have to define our own to get compatability with 2.0
+
+
+
+
+ This attribute is here so we can get better Pex integration
+ Using this means that Pex will not try to inspect the work of
+ the actual proxies being generated by Rhino Mocks
+
+
+
+
diff --git a/packages/repositories.config b/packages/repositories.config
new file mode 100644
index 0000000..e94d4e2
--- /dev/null
+++ b/packages/repositories.config
@@ -0,0 +1,4 @@
+
+
+
+
\ No newline at end of file