diff --git a/.dev.yml.un~ b/.dev.yml.un~
index cdddd3a9..e9e9be23 100644
Binary files a/.dev.yml.un~ and b/.dev.yml.un~ differ
diff --git a/.vs/Oak/v14/.suo b/.vs/Oak/v14/.suo
new file mode 100644
index 00000000..c31d73d4
Binary files /dev/null and b/.vs/Oak/v14/.suo differ
diff --git a/.vs/config/applicationhost.config b/.vs/config/applicationhost.config
new file mode 100644
index 00000000..27348eaa
--- /dev/null
+++ b/.vs/config/applicationhost.config
@@ -0,0 +1,1038 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/Oak.Tests/App.config b/Oak.Tests/App.config
index 8f5ea057..27a3deb2 100644
--- a/Oak.Tests/App.config
+++ b/Oak.Tests/App.config
@@ -1,7 +1,16 @@
-
+
-
-
+
+
-
+
+
+
+
+
+
+
+
+
+
diff --git a/Oak.Tests/Oak.Tests.csproj b/Oak.Tests/Oak.Tests.csproj
index d5dc9a04..627e02c7 100644
--- a/Oak.Tests/Oak.Tests.csproj
+++ b/Oak.Tests/Oak.Tests.csproj
@@ -5,7 +5,7 @@
Debug
AnyCPU
{2C3A50A4-A924-43C8-8CC8-C518BE561C0E}
- Library
+ Exe
Properties
Oak.Tests
Oak.Tests
@@ -29,6 +29,9 @@
prompt
4
+
+ Oak.Tests.Program
+
..\packages\FluentNHibernate.1.4.0.0\lib\net35\FluentNHibernate.dll
@@ -44,8 +47,12 @@
..\packages\NHibernate.3.3.3.4001\lib\Net35\NHibernate.dll
- False
..\packages\nspec.0.9.68\lib\NSpec.dll
+ True
+
+
+ ..\packages\NUnit.2.6.4\lib\nunit.framework.dll
+ True
@@ -270,6 +277,7 @@
+
diff --git a/Oak.Tests/Program.cs b/Oak.Tests/Program.cs
new file mode 100644
index 00000000..91e0f6e7
--- /dev/null
+++ b/Oak.Tests/Program.cs
@@ -0,0 +1,25 @@
+using System.Linq;
+using System.Reflection;
+using NSpec;
+using NSpec.Domain;
+using NSpec.Domain.Formatters;
+using System.IO;
+using System;
+using System.Diagnostics;
+
+
+namespace Oak.Tests
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ var ri = new RunnerInvocation(Assembly.GetExecutingAssembly().Location, "", false);
+ ri.Run();
+
+ Console.WriteLine("Done.");
+ Console.ReadLine();
+
+ }
+ }
+}
diff --git a/Oak.Tests/packages.config b/Oak.Tests/packages.config
index 9cac041d..43625167 100644
--- a/Oak.Tests/packages.config
+++ b/Oak.Tests/packages.config
@@ -8,4 +8,5 @@
+
\ No newline at end of file
diff --git a/Sample Apps/BorrowedGames/.sass-cache/46a5b4cb4d74bf5e5f4ca6898f1299ca71fdcd27/screen.scssc b/Sample Apps/BorrowedGames/.sass-cache/46a5b4cb4d74bf5e5f4ca6898f1299ca71fdcd27/screen.scssc
new file mode 100644
index 00000000..fbef5b8a
Binary files /dev/null and b/Sample Apps/BorrowedGames/.sass-cache/46a5b4cb4d74bf5e5f4ca6898f1299ca71fdcd27/screen.scssc differ
diff --git a/Sample Apps/BorrowedGames/BorrowedGames.Tests/Controllers/describe_FriendsController.cs b/Sample Apps/BorrowedGames/BorrowedGames.Tests/Controllers/describe_FriendsController.cs
index 69aac0e2..a5cabe6b 100644
--- a/Sample Apps/BorrowedGames/BorrowedGames.Tests/Controllers/describe_FriendsController.cs
+++ b/Sample Apps/BorrowedGames/BorrowedGames.Tests/Controllers/describe_FriendsController.cs
@@ -19,6 +19,7 @@ void before_each()
SetCurrentUser(controller, GivenUser("user@example.com", "@me"));
}
+
[Tag("describe_User")]
void when_following_someone()
{
diff --git a/Sample Apps/BorrowedGames/BorrowedGames.v12.suo b/Sample Apps/BorrowedGames/BorrowedGames.v12.suo
index 950ad002..c7985bfc 100644
Binary files a/Sample Apps/BorrowedGames/BorrowedGames.v12.suo and b/Sample Apps/BorrowedGames/BorrowedGames.v12.suo differ
diff --git a/Sample Apps/BorrowedGames/Gemfile.lock b/Sample Apps/BorrowedGames/Gemfile.lock
new file mode 100644
index 00000000..6b5516a4
--- /dev/null
+++ b/Sample Apps/BorrowedGames/Gemfile.lock
@@ -0,0 +1,36 @@
+GEM
+ remote: http://rubygems.org/
+ specs:
+ chunky_png (1.3.4)
+ coffee-script (2.4.1)
+ coffee-script-source
+ execjs
+ coffee-script-source (1.9.1.1)
+ compass (1.0.3)
+ chunky_png (~> 1.2)
+ compass-core (~> 1.0.2)
+ compass-import-once (~> 1.0.5)
+ rb-fsevent (>= 0.9.3)
+ rb-inotify (>= 0.9)
+ sass (>= 3.3.13, < 3.5)
+ compass-core (1.0.3)
+ multi_json (~> 1.0)
+ sass (>= 3.3.0, < 3.5)
+ compass-import-once (1.0.5)
+ sass (>= 3.2, < 3.5)
+ execjs (2.5.2)
+ ffi (1.9.8-x64-mingw32)
+ multi_json (1.11.0)
+ rb-fsevent (0.9.4)
+ rb-inotify (0.9.5)
+ ffi (>= 0.5.0)
+ sass (3.4.13)
+ watchr (0.7)
+
+PLATFORMS
+ x64-mingw32
+
+DEPENDENCIES
+ coffee-script
+ compass
+ watchr
diff --git a/Sample Apps/BorrowedGames/sidekickapp.exe b/Sample Apps/BorrowedGames/sidekickapp.exe
index 2d0c862f..8a1da67d 100644
Binary files a/Sample Apps/BorrowedGames/sidekickapp.exe and b/Sample Apps/BorrowedGames/sidekickapp.exe differ
diff --git a/Sample Apps/BorrowedGames/stacktrace.txt b/Sample Apps/BorrowedGames/stacktrace.txt
new file mode 100644
index 00000000..139597f9
--- /dev/null
+++ b/Sample Apps/BorrowedGames/stacktrace.txt
@@ -0,0 +1,2 @@
+
+
diff --git a/Sample Apps/DynamicBlog/DynamicBlog/Controllers/.HomeController.cs.un~ b/Sample Apps/DynamicBlog/DynamicBlog/Controllers/.HomeController.cs.un~
new file mode 100644
index 00000000..11e05c42
Binary files /dev/null and b/Sample Apps/DynamicBlog/DynamicBlog/Controllers/.HomeController.cs.un~ differ
diff --git a/Sample Apps/DynamicBlog/sidekickapp.exe b/Sample Apps/DynamicBlog/sidekickapp.exe
index 4feb5afd..16d9d925 100644
Binary files a/Sample Apps/DynamicBlog/sidekickapp.exe and b/Sample Apps/DynamicBlog/sidekickapp.exe differ
diff --git a/dev.yml b/dev.yml
index 0b03cbd1..51bde102 100644
--- a/dev.yml
+++ b/dev.yml
@@ -1,5 +1,5 @@
solution_name: Oak.sln
-test_dll: ./Oak.Tests/bin/debug/Oak.Tests.dll
+test_dll: ./Oak.Tests/bin/debug/Oak.Tests.exe
test_runner: ./packages/nspec.0.9.68/tools/NSpecRunner.exe
database_name: Oak
database_server: (local)
diff --git a/packages/NUnit.2.6.4/NUnit.2.6.4.nupkg b/packages/NUnit.2.6.4/NUnit.2.6.4.nupkg
new file mode 100644
index 00000000..379b15bf
Binary files /dev/null and b/packages/NUnit.2.6.4/NUnit.2.6.4.nupkg differ
diff --git a/packages/NUnit.2.6.4/lib/nunit.framework.dll b/packages/NUnit.2.6.4/lib/nunit.framework.dll
new file mode 100644
index 00000000..ed6550bb
Binary files /dev/null and b/packages/NUnit.2.6.4/lib/nunit.framework.dll differ
diff --git a/packages/NUnit.2.6.4/lib/nunit.framework.xml b/packages/NUnit.2.6.4/lib/nunit.framework.xml
new file mode 100644
index 00000000..450552c1
--- /dev/null
+++ b/packages/NUnit.2.6.4/lib/nunit.framework.xml
@@ -0,0 +1,10984 @@
+
+
+
+ nunit.framework
+
+
+
+
+ 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.
+
+
+
+
+
+
+ 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.
+
+ The actual value to test
+ A Constraint to be applied
+
+
+
+ Apply a constraint to an actual value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ The actual value to test
+ A Constraint to be applied
+ 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.
+
+ The actual value to test
+ A Constraint expression to be applied
+ 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
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+ 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.
+
+ The actual value to test
+ A Constraint to be applied
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ The actual value to test
+ A Constraint to be applied
+ 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.
+
+ The actual value to test
+ A Constraint to be applied
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ 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.
+
+ The actual value to test
+ A Constraint to be applied
+
+
+
+ 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.
+
+ The actual value to test
+ A Constraint to be applied
+ 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.
+
+ The actual value to test
+ A Constraint expression to be applied
+ 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 TestDelegate
+ 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 TestDelegate
+ 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 TestDelegate
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ The exception Type expected
+ A TestDelegate
+ 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 TestDelegate
+ The message that will be displayed on failure
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ The exception Type expected
+ A TestDelegate
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ Type of the expected exception
+ A TestDelegate
+ 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 TestDelegate
+ The message that will be displayed on failure
+
+
+
+ Verifies that a delegate throws a particular exception when called.
+
+ Type of the expected exception
+ A TestDelegate
+
+
+
+ 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 TestDelegate
+ 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 TestDelegate
+ The message that will be displayed on failure
+
+
+
+ Verifies that a delegate does not throw an exception.
+
+ A TestDelegate
+
+
+
+ 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 two ints 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 ints 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 ints are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two longs 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 longs 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 longs are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two unsigned ints 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 unsigned ints 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 unsigned ints are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two unsigned longs 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 unsigned longs 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 unsigned longs are equal. If they are not, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two decimals 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 decimals 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 decimals 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 ints 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 ints 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 ints are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two longs 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 longs 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 longs are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two unsigned ints 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 unsigned ints 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 unsigned ints are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two unsigned longs 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 unsigned longs 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 unsigned longs are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two decimals 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 decimals 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 decimals are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two floats 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 floats 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 floats are not equal. If they are equal, then an
+ is thrown.
+
+ The expected value
+ The actual value
+
+
+
+ Verifies that two doubles 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 doubles 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 doubles 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 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 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
+
+
+
+ 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
+
+
+
+ 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.
+
+
+
+
+ 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 regular expression supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value matches the regular expression 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
+
+
+
+
+ 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.
+
+ The actual value to test
+ A Constraint to be applied
+
+
+
+ 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.
+
+ The actual value to test
+ A Constraint to be applied
+ The message to be displayed in case of 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.
+
+ The actual value to test
+ A Constraint to be applied
+ The message to be displayed in case of failure
+ Arguments to use in formatting the message
+
+
+
+ Asserts that a condition is true. If the condition is false the method throws
+ an . Works Identically to
+ .
+
+ 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
+ .
+
+ 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 to .
+
+ The evaluated condition
+
+
+
+ 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.
+
+ The actual value to test
+ A Constraint to be applied
+
+
+
+ Apply a constraint to a referenced value, succeeding if the constraint
+ is satisfied and throwing an assertion exception on failure.
+
+ The actual value to test
+ A Constraint to be applied
+ 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.
+
+ The actual value to test
+ A Constraint to be applied
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+ 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 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
+
+
+
+ Waits for pending asynchronous operations to complete, if appropriate,
+ and returns a proper result of the invocation by unwrapping task results
+
+ The raw result of the method invocation
+ The unwrapped result, if necessary
+
+
+
+ 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 the superset does not contain the subset
+
+ The IEnumerable subset to be considered
+ The IEnumerable superset to be considered
+
+
+
+ Asserts that the superset does not contain the subset
+
+ The IEnumerable subset to be considered
+ The IEnumerable superset to be considered
+ The message that will be displayed on failure
+
+
+
+ Asserts that the superset does not contain the subset
+
+ The IEnumerable subset to be considered
+ The IEnumerable superset to be considered
+ The message that will be displayed on failure
+ Arguments to be used in formatting the message
+
+
+
+ Asserts that the superset contains the subset.
+
+ The IEnumerable subset to be considered
+ The IEnumerable superset to be considered
+
+
+
+ Asserts that the superset contains the subset.
+
+ The IEnumerable subset to be considered
+ The IEnumerable superset to be considered
+ The message that will be displayed on failure
+
+
+
+ Asserts that the superset contains the subset.
+
+ The IEnumerable subset to be considered
+ The IEnumerable superset 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
+
+
+
+ Helper class with properties and methods that supply
+ a number of constraints used in Asserts.
+
+
+
+
+ Returns a new CollectionContainsConstraint checking for the
+ presence of a particular object in the collection.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value contains the substring supplied as an argument.
+
+
+
+
+ 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
+
+
+
+
+ Class used to guard against unexpected argument values
+ by throwing an appropriate exception.
+
+
+
+
+ Throws an exception if an argument is null
+
+ The value to be tested
+ The name of the argument
+
+
+
+ Throws an exception if a string argument is null or empty
+
+ The value to be tested
+ The name of the argument
+
+
+
+ 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 regular expression 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 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 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.
+
+
+
+ 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 attribute 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.
+
+
+
+
+ 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
+
+
+
+
+ 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
+
+
+
+
+ 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
+
+
+
+ Method called before each test
+
+ Info about the test to be run
+
+
+
+ Method called after each test
+
+ Info about the test that was just run
+
+
+
+ Gets or sets the ActionTargets for this 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.
+
+
+
+
+ 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
+
+
+
+
+ AllItemsConstraint applies another constraint to each
+ item in a collection, succeeding if they all succeed.
+
+
+
+
+ Abstract base class used for prefixes
+
+
+
+
+ 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
+ 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.
+
+
+
+
+ The base constraint
+
+
+
+
+ Construct given a base constraint
+
+
+
+
+
+ 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
+
+
+
+
+
+ AndConstraint succeeds only if both members succeed.
+
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+ AssignableFromConstraint is used to test that an object
+ can be assigned from a given Type.
+
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+ 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.
+
+
+
+
+ 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.
+
+
+
+
+ AttributeExistsConstraint tests for the presence of a
+ specified attribute on a Type.
+
+
+
+
+ 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
+
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+
+ 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
+
+
+
+
+
+
+ CollectionContainsConstraint is used to test whether a collection
+ contains an expected object as a member.
+
+
+
+
+ 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 EqualityAdapter.
+ NOTE: For internal use only.
+
+ The EqualityAdapter 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.
+
+
+
+ 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.
+
+
+
+
+ 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
+
+
+
+
+
+ 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
+
+
+
+
+ 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
+
+
+
+
+
+ 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 regular expression supplied as an argument.
+
+
+
+
+ Returns a constraint that succeeds if the actual
+ value matches the regular expression 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
+
+
+
+
+ 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.
+
+
+
+
+ EmptyCollectionConstraint tests whether a collection is empty.
+
+
+
+
+ Check that the collection is empty
+
+
+
+
+
+
+ Write the constraint description to a MessageWriter
+
+
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+ EndsWithConstraint can test whether a string ends
+ with an expected substring.
+
+
+
+
+ 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
+
+
+
+ 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 a given string
+
+ The string to be tested
+ True for success, false for failure
+
+
+
+ Modify the constraint to ignore case in matching.
+
+
+
+
+ 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
+
+
+
+ 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.
+
+
+
+
+ EqualityAdapterList represents a list of EqualityAdapters
+ in a common class across platforms.
+
+
+
+
+ ExactCountConstraint 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
+
+
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+
+ FailurePointList represents a set of FailurePoints
+ in a cross-platform way.
+
+
+
+
+ FalseConstraint tests that the actual value is false
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+
+
+ 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
+
+
+
+
+
+ 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
+
+
+
+ NullConstraint tests that the actual value is null
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ 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
+
+
+
+ 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.
+
+
+
+
+ List of points at which a failure occured.
+
+
+
+
+ RecursionDetector used to check for recursion when
+ evaluating self-referencing enumerables.
+
+
+
+
+ Compares two objects for equality within a tolerance, setting
+ the tolerance to the actual tolerance used if an empty
+ tolerance is supplied.
+
+
+
+
+ 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 the list of external comparers to be used to
+ test for equality. They are applied to members of
+ collections, in place of NUnit's own logic.
+
+
+
+
+ Gets the list of failure points for the last Match performed.
+ The list consists of objects to be interpreted by the caller.
+ This generally means that the caller may only make use of
+ objects it has placed on the list at a particular depthy.
+
+
+
+
+ RecursionDetector detects when a comparison
+ between two enumerables has reached a point
+ where the same objects that were previously
+ compared are again being compared. This allows
+ the caller to stop the comparison if desired.
+
+
+
+
+ Check whether two objects have previously
+ been compared, returning true if they have.
+ The two objects are remembered, so that a
+ second call will always return true.
+
+
+
+
+ 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
+
+
+
+ PathConstraint serves as the abstract base of constraints
+ that operate on paths and provides several helper methods.
+
+
+
+
+ The expected path used in the constraint
+
+
+
+
+ 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
+
+
+
+
+ Transform the provided path to its canonical form so that it
+ may be more easily be compared with other paths.
+
+ The original path
+ The path in canonical form
+
+
+
+ Test whether one path in canonical form is under another.
+
+ The first path - supposed to be the parent path
+ The second path - supposed to be the child path
+ Indicates whether case should be ignored
+
+
+
+
+ Modifies the current instance to be case-insensitve
+ and returns it.
+
+
+
+
+ Modifies the current instance to be case-sensitve
+ and returns it.
+
+
+
+
+ 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
+
+
+
+
+ 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.
+
+
+
+
+
+ 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.
+
+
+
+
+
+ RangeConstraint tests whether 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
+
+
+
+ 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
+
+
+
+ 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 constraint expression after
+ resolving it so that it can be reused consistently.
+
+
+
+
+ Construct a ReusableConstraint from a constraint expression
+
+ The expression to be resolved and reused
+
+
+
+ Converts a constraint to a ReusableConstraint
+
+ The constraint to be converted
+ 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
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+ 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
+
+
+
+ Test whether the constraint is satisfied by a given delegate
+
+ Delegate returning the value to be tested
+ True if no exception is thrown, otherwise false
+
+
+
+ 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. Overridden in ThrowsNothingConstraint to write
+ information about the exception that was actually caught.
+
+ The writer on which the actual value is displayed
+
+
+
+ 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.
+
+
+
+
+ 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.
+
+
+
+
+ TrueConstraint tests that the actual value is true
+
+
+
+
+ Initializes a new instance of the class.
+
+
+
+
+ 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
+
+
+
+
+
+ XmlSerializableConstraint tests whether
+ an object is serializable in XML 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
+
+
+
+
+ Represents a constraint that succeeds if all the
+ members of a collection match a base constraint.
+
+
+
+
+ Abstract base for operators that indicate how to
+ apply a constraint to items in a collection.
+
+
+
+
+ PrefixOperator takes a single constraint and modifies
+ it's action in some way.
+
+
+
+
+ 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.
+
+
+
+
+ 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.
+
+
+
+
+
+
+ Constructs a CollectionOperator
+
+
+
+
+ Returns a constraint that will apply the argument
+ to the members of a collection, succeeding if
+ they all succeed.
+
+
+
+
+ Operator that requires both it's arguments to succeed
+
+
+
+
+ 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
+
+
+
+
+ Construct an AndOperator
+
+
+
+
+ Apply the operator to produce an AndConstraint
+
+
+
+
+ Operator that tests for the presence of a particular attribute
+ on a type and optionally applies further tests to the attribute.
+
+
+
+
+ Abstract base class for operators that are able to reduce to a
+ constraint whether or not another syntactic element follows.
+
+
+
+
+ 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.
+
+
+
+
+ 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 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.
+
+
+
+
+ Negates the test of the constraint it wraps.
+
+
+
+
+ Constructs a new NotOperator
+
+
+
+
+ Returns a NotConstraint applied to its argument.
+
+
+
+
+ Operator that requires at least one of it's arguments to succeed
+
+
+
+
+ Construct an OrOperator
+
+
+
+
+ Apply the operator to produce an OrConstraint
+
+
+
+
+ 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
+
+
+
+
+ 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.
+
+
+
+
+ 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.
+
+
+
+
+ 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
+
+
+
+
+ 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
+
+
+
+
diff --git a/packages/NUnit.2.6.4/license.txt b/packages/NUnit.2.6.4/license.txt
new file mode 100644
index 00000000..def2bb81
--- /dev/null
+++ b/packages/NUnit.2.6.4/license.txt
@@ -0,0 +1,15 @@
+Copyright © 2002-2014 Charlie Poole
+Copyright © 2002-2004 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov
+Copyright © 2000-2002 Philip A. Craig
+
+This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment (see the following) in the product documentation is required.
+
+Portions Copyright © 2002-2014 Charlie Poole or Copyright © 2002-2004 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov or Copyright © 2000-2002 Philip A. Craig
+
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source distribution.
diff --git a/packages/nspec.0.9.68/nspec.0.9.68.nuspec b/packages/nspec.0.9.68/nspec.0.9.68.nuspec
deleted file mode 100644
index 6db847f0..00000000
--- a/packages/nspec.0.9.68/nspec.0.9.68.nuspec
+++ /dev/null
@@ -1,16 +0,0 @@
-
-
-
- nspec
- 0.9.68
- Matt Florence, Amir Rajan
- Matt Florence, Amir Rajan
- https://github.com/mattflo/NSpec/blob/master/license.txt
- http://www.nspec.org/
- http://nspec.org/images/logo.png
- false
- NSpec is a BDD (Behavior Driven Development) framework for .NET of the xSpec (Context/Specification) flavor. NSpec is intended to drive development by specifying behavior within a declared context. NSpec is heavily inspired by RSpec and build upon the NUnit assertion library.
- en-US
- testing bdd tdd
-
-
\ No newline at end of file