From 4871e73491331610f8c55642073bcaaaa17d706f Mon Sep 17 00:00:00 2001 From: Marcus Cuda Date: Thu, 9 Dec 2010 16:30:19 +0200 Subject: [PATCH] added NUnit project --- lib/NUnit-2.5.8/license.txt | 15 + lib/NUnit-2.5.8/nunit.framework.dll | Bin 0 -> 135168 bytes lib/NUnit-2.5.8/nunit.framework.xml | 10272 ++++++++++++++++ lib/NUnit-2.5.8/nunit.mocks.dll | Bin 0 -> 20480 bytes lib/NUnit-2.5.8/pnunit.framework.dll | Bin 0 -> 6656 bytes src/MathNet.Numerics.sln | 7 + src/NUnitTests/AssertHelpers.cs | 281 + .../Double/LinearAlgebraProviderTests.cs | 439 + src/NUnitTests/NUnitTests.csproj | 65 + src/NUnitTests/Properties/AssemblyInfo.cs | 36 + 10 files changed, 11115 insertions(+) create mode 100644 lib/NUnit-2.5.8/license.txt create mode 100644 lib/NUnit-2.5.8/nunit.framework.dll create mode 100644 lib/NUnit-2.5.8/nunit.framework.xml create mode 100644 lib/NUnit-2.5.8/nunit.mocks.dll create mode 100644 lib/NUnit-2.5.8/pnunit.framework.dll create mode 100644 src/NUnitTests/AssertHelpers.cs create mode 100644 src/NUnitTests/LinearAlgebraProviderTests/Double/LinearAlgebraProviderTests.cs create mode 100644 src/NUnitTests/NUnitTests.csproj create mode 100644 src/NUnitTests/Properties/AssemblyInfo.cs diff --git a/lib/NUnit-2.5.8/license.txt b/lib/NUnit-2.5.8/license.txt new file mode 100644 index 00000000..66a5ebf2 --- /dev/null +++ b/lib/NUnit-2.5.8/license.txt @@ -0,0 +1,15 @@ +Copyright © 2002-2008 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-2008 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/lib/NUnit-2.5.8/nunit.framework.dll b/lib/NUnit-2.5.8/nunit.framework.dll new file mode 100644 index 0000000000000000000000000000000000000000..96e31f9e8bb052433f0b6578e383aa00d9b74c6e GIT binary patch literal 135168 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 npuM%? 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%0D38Q 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

Keo;%LHXf-Pzo<6S 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 literal 0 HcmV?d00001 diff --git a/lib/NUnit-2.5.8/nunit.framework.xml b/lib/NUnit-2.5.8/nunit.framework.xml new file mode 100644 index 00000000..f3a9e8f5 --- /dev/null +++ b/lib/NUnit-2.5.8/nunit.framework.xml @@ -0,0 +1,10272 @@ + + + + nunit.framework + + + +

+ Attribute used to apply a category to a test + + + + + The name of the category + + + + + Construct attribute for a given category based on + a name. The name may not contain the characters ',', + '+', '-' or '!'. However, this is not checked in the + constructor since it would cause an error to arise at + as the test was loaded without giving a clear indication + of where the problem is located. The error is handled + in NUnitFramework.cs by marking the test as not + runnable. + + The name of the category + + + + Protected constructor uses the Type name as the name + of the category. + + + + + The name of the category + + + + + Used to mark a field for use as a datapoint when executing a theory + within the same fixture that requires an argument of the field's Type. + + + + + Used to mark an array as containing a set of datapoints to be used + executing a theory within the same fixture that requires an argument + of the Type of the array elements. + + + + + Attribute used to provide descriptive text about a + test case or fixture. + + + + + Construct the attribute + + Text describing the test + + + + Gets the test description + + + + + Enumeration indicating how the expected message parameter is to be used + + + + Expect an exact match + + + Expect a message containing the parameter string + + + Match the regular expression provided as a parameter + + + Expect a message that starts with the parameter string + + + + ExpectedExceptionAttribute + + + + + + Constructor for a non-specific exception + + + + + Constructor for a given type of exception + + The type of the expected exception + + + + Constructor for a given exception name + + The full name of the expected exception + + + + Gets or sets the expected exception type + + + + + Gets or sets the full Type name of the expected exception + + + + + Gets or sets the expected message text + + + + + Gets or sets the user message displayed in case of failure + + + + + Gets or sets the type of match to be performed on the expected message + + + + + Gets the name of a method to be used as an exception handler + + + + + ExplicitAttribute marks a test or test fixture so that it will + only be run if explicitly executed from the gui or command line + or if it is included by use of a filter. The test will not be + run simply because an enclosing suite is run. + + + + + Default constructor + + + + + Constructor with a reason + + The reason test is marked explicit + + + + The reason test is marked explicit + + + + + Attribute used to mark a test that is to be ignored. + Ignored tests result in a warning message when the + tests are run. + + + + + Constructs the attribute without giving a reason + for ignoring the test. + + + + + Constructs the attribute giving a reason for ignoring the test + + The reason for ignoring the test + + + + The reason for ignoring a test + + + + + Abstract base for Attributes that are used to include tests + in the test run based on environmental settings. + + + + + Constructor with no included items specified, for use + with named property syntax. + + + + + Constructor taking one or more included items + + Comma-delimited list of included items + + + + Name of the item that is needed in order for + a test to run. Multiple itemss may be given, + separated by a comma. + + + + + Name of the item to be excluded. Multiple items + may be given, separated by a comma. + + + + + The reason for including or excluding the test + + + + + PlatformAttribute is used to mark a test fixture or an + individual method as applying to a particular platform only. + + + + + Constructor with no platforms specified, for use + with named property syntax. + + + + + Constructor taking one or more platforms + + Comma-deliminted list of platforms + + + + CultureAttribute is used to mark a test fixture or an + individual method as applying to a particular Culture only. + + + + + Constructor with no cultures specified, for use + with named property syntax. + + + + + Constructor taking one or more cultures + + Comma-deliminted list of cultures + + + + Marks a test to use a combinatorial join of any argument data + provided. NUnit will create a test case for every combination of + the arguments provided. This can result in a large number of test + cases and so should be used judiciously. This is the default join + type, so the attribute need not be used except as documentation. + + + + + PropertyAttribute is used to attach information to a test as a name/value pair.. + + + + + Construct a PropertyAttribute with a name and string value + + The name of the property + The property value + + + + Construct a PropertyAttribute with a name and int value + + The name of the property + The property value + + + + Construct a PropertyAttribute with a name and double value + + The name of the property + The property value + + + + Constructor for derived classes that set the + property dictionary directly. + + + + + Constructor for use by derived classes that use the + name of the type as the property name. Derived classes + must ensure that the Type of the property value is + a standard type supported by the BCL. Any custom + types will cause a serialization Exception when + in the client. + + + + + Gets the property dictionary for this attribute + + + + + Default constructor + + + + + Marks a test to use pairwise join of any argument data provided. + NUnit will attempt too excercise every pair of argument values at + least once, using as small a number of test cases as it can. With + only two arguments, this is the same as a combinatorial join. + + + + + Default constructor + + + + + Marks a test to use a sequential join of any argument data + provided. NUnit will use arguements for each parameter in + sequence, generating test cases up to the largest number + of argument values provided and using null for any arguments + for which it runs out of values. Normally, this should be + used with the same number of arguments for each parameter. + + + + + Default constructor + + + + + Summary description for MaxTimeAttribute. + + + + + Construct a MaxTimeAttribute, given a time in milliseconds. + + The maximum elapsed time in milliseconds + + + + RandomAttribute is used to supply a set of random values + to a single parameter of a parameterized test. + + + + + ValuesAttribute is used to provide literal arguments for + an individual parameter of a test. + + + + + Abstract base class for attributes that apply to parameters + and supply data for the parameter. + + + + + Gets the data to be provided to the specified parameter + + + + + The collection of data to be returned. Must + be set by any derived attribute classes. + We use an object[] so that the individual + elements may have their type changed in GetData + if necessary. + + + + + Construct with one argument + + + + + + Construct with two arguments + + + + + + + Construct with three arguments + + + + + + + + Construct with an array of arguments + + + + + + Get the collection of values to be used as arguments + + + + + Construct a set of doubles from 0.0 to 1.0, + specifying only the count. + + + + + + Construct a set of doubles from min to max + + + + + + + + Construct a set of ints from min to max + + + + + + + + Get the collection of values to be used as arguments + + + + + RangeAttribute is used to supply a range of values to an + individual parameter of a parameterized test. + + + + + Construct a range of ints using default step of 1 + + + + + + + Construct a range of ints specifying the step size + + + + + + + + Construct a range of longs + + + + + + + + Construct a range of doubles + + + + + + + + Construct a range of floats + + + + + + + + RepeatAttribute may be applied to test case in order + to run it multiple times. + + + + + Construct a RepeatAttribute + + The number of times to run the test + + + + RequiredAddinAttribute may be used to indicate the names of any addins + that must be present in order to run some or all of the tests in an + assembly. If the addin is not loaded, the entire assembly is marked + as NotRunnable. + + + + + Initializes a new instance of the class. + + The required addin. + + + + Gets the name of required addin. + + The required addin name. + + + + Summary description for SetCultureAttribute. + + + + + Construct given the name of a culture + + + + + + Summary description for SetUICultureAttribute. + + + + + Construct given the name of a culture + + + + + + 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. + + + + + SetUpFixtureAttribute is used to identify a SetUpFixture + + + + + Attribute used to mark a static (shared in VB) property + that returns a list of tests. + + + + + Attribute used to identify a method that is called + immediately after each test is run. The method is + guaranteed to be called, even if an exception is thrown. + + + + + Adding this attribute to a method within a + class makes the method callable from the NUnit test runner. There is a property + called Description which is optional which you can provide a more detailed test + description. This class cannot be inherited. + + + + [TestFixture] + public class Fixture + { + [Test] + public void MethodToTest() + {} + + [Test(Description = "more detailed description")] + publc void TestDescriptionMethod() + {} + } + + + + + + Descriptive text for this test + + + + + TestCaseAttribute is used to mark parameterized test cases + and provide them with their arguments. + + + + + The ITestCaseData interface is implemented by a class + that is able to return complete testcases for use by + a parameterized test method. + + NOTE: This interface is used in both the framework + and the core, even though that results in two different + types. However, sharing the source code guarantees that + the various implementations will be compatible and that + the core is able to reflect successfully over the + framework implementations of ITestCaseData. + + + + + Gets the argument list to be provided to the test + + + + + Gets the expected result + + + + + 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 the ignore reason. + + The ignore reason. + + + + Construct a TestCaseAttribute with a list of arguments. + This constructor is not CLS-Compliant + + + + + + Construct a TestCaseAttribute with a single argument + + + + + + Construct a TestCaseAttribute with a two arguments + + + + + + + Construct a TestCaseAttribute with a three arguments + + + + + + + + Gets the list of arguments to a test case + + + + + Gets or sets the expected result. + + The result. + + + + 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 the ignore reason. + + The ignore reason. + + + + FactoryAttribute indicates the source to be used to + provide test cases for a test method. + + + + + Construct with the name of the factory - for use with languages + that don't support params arrays. + + An array of the names of the factories that will provide data + + + + 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 + + + + + [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 + + + + + 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() + {} + } + + + + + + WUsed on a method, marks the test with a timeout value in milliseconds. + The test will be run in a separate thread and is cancelled if the timeout + is exceeded. Used on a method or assembly, sets the default timeout + for all contained test methods. + + + + + Construct a TimeoutAttribute given a time in milliseconds + + The timeout value in milliseconds + + + + Marks a test that must run in the STA, causing it + to run in a separate thread if necessary. + + On methods, you may also use STAThreadAttribute + to serve the same purpose. + + + + + Construct a RequiresSTAAttribute + + + + + Marks a test that must run in the MTA, causing it + to run in a separate thread if necessary. + + On methods, you may also use MTAThreadAttribute + to serve the same purpose. + + + + + Construct a RequiresMTAAttribute + + + + + Marks a test that must run on a separate thread. + + + + + Construct a RequiresThreadAttribute + + + + + Construct a RequiresThreadAttribute, specifying the apartment + + + + + ValueSourceAttribute indicates the source to be used to + provide data for one parameter of a test method. + + + + + Construct with the name of the factory - for use with languages + that don't support params arrays. + + The name of the data source to be used + + + + Construct with a Type and name - for use with languages + that don't support params arrays. + + The Type that will provide data + The name of the method, property or field that will provide data + + + + The name of a the method, property or fiend to be used as a source + + + + + A Type to be used as a source + + + + + AttributeExistsConstraint tests for the presence of a + specified attribute on a Type. + + + + + The Constraint class is the base of all built-in constraints + within NUnit. It provides the operator overloads used to combine + constraints. + + + + + The IConstraintExpression interface is implemented by all + complete and resolvable constraints and expressions. + + + + + Return the top-level constraint for this expression + + + + + + Static UnsetObject used to detect derived constraints + failing to set the actual value. + + + + + The actual value being tested against a constraint + + + + + The display name of this Constraint for use by ToString() + + + + + Argument fields used by ToString(); + + + + + The builder holding this constraint + + + + + Construct a constraint with no arguments + + + + + Construct a constraint with one argument + + + + + Construct a constraint with two arguments + + + + + Sets the ConstraintBuilder holding this constraint + + + + + Write the failure message to the MessageWriter provided + as an argument. The default implementation simply passes + the constraint and the actual value to the writer, which + then displays the constraint description and the value. + + Constraints that need to provide additional details, + such as where the error occured can override this. + + The MessageWriter on which to display the message + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Test whether the constraint is satisfied by an + ActualValueDelegate that returns the value to be tested. + The default implementation simply evaluates the delegate + but derived classes may override it to provide for delayed + processing. + + An ActualValueDelegate + True for success, false for failure + + + + Test whether the constraint is satisfied by a given reference. + The default implementation simply dereferences the value but + derived classes may override it to provide for delayed processing. + + A reference to the value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + + The writer on which the actual value is displayed + + + + Default override of ToString returns the constraint DisplayName + followed by any arguments within angle brackets. + + + + + + Returns the string representation of this constraint + + + + + This operator creates a constraint that is satisfied only if both + argument constraints are satisfied. + + + + + This operator creates a constraint that is satisfied if either + of the argument constraints is satisfied. + + + + + This operator creates a constraint that is satisfied if the + argument constraint is not satisfied. + + + + + Returns a DelayedConstraint with the specified delay time. + + The delay in milliseconds. + + + + + Returns a DelayedConstraint with the specified delay time + and polling interval. + + The delay in milliseconds. + The interval at which to test the constraint. + + + + + The display name of this Constraint for use by ToString(). + The default value is the name of the constraint with + trailing "Constraint" removed. Derived classes may set + this to another name in their constructors. + + + + + Returns a ConstraintExpression by appending And + to the current constraint. + + + + + Returns a ConstraintExpression by appending And + to the current constraint. + + + + + Returns a ConstraintExpression by appending Or + to the current constraint. + + + + + Class used to detect any derived constraints + that fail to set the actual value in their + Matches override. + + + + + Constructs an AttributeExistsConstraint for a specific attribute Type + + + + + + Tests whether the object provides the expected attribute. + + A Type, MethodInfo, or other ICustomAttributeProvider + True if the expected attribute is present, otherwise false + + + + Writes the description of the constraint to the specified writer + + + + + AttributeConstraint tests that a specified attribute is present + on a Type or other provider and that the value of the attribute + satisfies some other constraint. + + + + + Abstract base class used for prefixes + + + + + The base constraint + + + + + Construct given a base constraint + + + + + + Constructs an AttributeConstraint for a specified attriute + Type and base constraint. + + + + + + + Determines whether the Type or other provider has the + expected attribute and if its value matches the + additional constraint specified. + + + + + Writes a description of the attribute to the specified writer. + + + + + Writes the actual value supplied to the specified writer. + + + + + Returns a string representation of the constraint. + + + + + BasicConstraint is the abstract base for constraints that + perform a simple comparison to a constant value. + + + + + Initializes a new instance of the class. + + The expected. + The description. + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + NullConstraint tests that the actual value is null + + + + + Initializes a new instance of the class. + + + + + TrueConstraint tests that the actual value is true + + + + + Initializes a new instance of the class. + + + + + FalseConstraint tests that the actual value is false + + + + + Initializes a new instance of the class. + + + + + NaNConstraint tests that the actual value is a double or float NaN + + + + + Test that the actual value is an NaN + + + + + + + Write the constraint description to a specified writer + + + + + + BinaryConstraint is the abstract base of all constraints + that combine two other constraints in some fashion. + + + + + The first constraint being combined + + + + + The second constraint being combined + + + + + Construct a BinaryConstraint from two other constraints + + The first constraint + The second constraint + + + + AndConstraint succeeds only if both members succeed. + + + + + Create an AndConstraint from two other constraints + + The first constraint + The second constraint + + + + Apply both member constraints to an actual value, succeeding + succeeding only if both of them succeed. + + The actual value + True if the constraints both succeeded + + + + Write a description for this contraint to a MessageWriter + + The MessageWriter to receive the description + + + + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + + The writer on which the actual value is displayed + + + + OrConstraint succeeds if either member succeeds + + + + + Create an OrConstraint from two other constraints + + The first constraint + The second constraint + + + + Apply the member constraints to an actual value, succeeding + succeeding as soon as one of them succeeds. + + The actual value + True if either constraint succeeded + + + + Write a description for this contraint to a MessageWriter + + The MessageWriter to receive the description + + + + CollectionConstraint is the abstract base class for + constraints that operate on collections. + + + + + Construct an empty CollectionConstraint + + + + + Construct a CollectionConstraint + + + + + + Determines whether the specified enumerable is empty. + + The enumerable. + + true if the specified enumerable is empty; otherwise, false. + + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Protected method to be implemented by derived classes + + + + + + + CollectionItemsEqualConstraint is the abstract base class for all + collection constraints that apply some notion of item equality + as a part of their operation. + + + + + Construct an empty CollectionConstraint + + + + + Construct a CollectionConstraint + + + + + + Flag the constraint to use the supplied IComparer object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied IComparer object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied Comparison object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied IEqualityComparer object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied IEqualityComparer object. + + The IComparer object to use. + Self. + + + + Compares two collection members for equality + + + + + Return a new CollectionTally for use in making tests + + The collection to be included in the tally + + + + Flag the constraint to ignore case and return self. + + + + + EmptyCollectionConstraint tests whether a collection is empty. + + + + + Check that the collection is empty + + + + + + + Write the constraint description to a MessageWriter + + + + + + UniqueItemsConstraint tests whether all the items in a + collection are unique. + + + + + Check that all items are unique. + + + + + + + Write a description of this constraint to a MessageWriter + + + + + + CollectionContainsConstraint is used to test whether a collection + contains an expected object as a member. + + + + + Construct a CollectionContainsConstraint + + + + + + Test whether the expected item is contained in the collection + + + + + + + Write a descripton of the constraint to a MessageWriter + + + + + + CollectionEquivalentCOnstraint is used to determine whether two + collections are equivalent. + + + + + Construct a CollectionEquivalentConstraint + + + + + + Test whether two collections are equivalent + + + + + + + Write a description of this constraint to a MessageWriter + + + + + + CollectionSubsetConstraint is used to determine whether + one collection is a subset of another + + + + + Construct a CollectionSubsetConstraint + + The collection that the actual value is expected to be a subset of + + + + Test whether the actual collection is a subset of + the expected collection provided. + + + + + + + Write a description of this constraint to a MessageWriter + + + + + + CollectionOrderedConstraint is used to test whether a collection is ordered. + + + + + Construct a CollectionOrderedConstraint + + + + + Modifies the constraint to use an IComparer and returns self. + + + + + Modifies the constraint to use an IComparer<T> and returns self. + + + + + Modifies the constraint to use a Comparison<T> and returns self. + + + + + Modifies the constraint to test ordering by the value of + a specified property and returns self. + + + + + Test whether the collection is ordered + + + + + + + Write a description of the constraint to a MessageWriter + + + + + + Returns the string representation of the constraint. + + + + + + If used performs a reverse comparison + + + + + CollectionTally counts (tallies) the number of + occurences of each object in one or more enumerations. + + + + + Construct a CollectionTally object from a comparer and a collection + + + + + Try to remove an object from the tally + + The object to remove + True if successful, false if the object was not found + + + + Try to remove a set of objects from the tally + + The objects to remove + True if successful, false if any object was not found + + + + The number of objects remaining in the tally + + + + + ComparisonAdapter class centralizes all comparisons of + values in NUnit, adapting to the use of any provided + IComparer, IComparer<T> or Comparison<T> + + + + + Returns a ComparisonAdapter that wraps an IComparer + + + + + Returns a ComparisonAdapter that wraps an IComparer<T> + + + + + Returns a ComparisonAdapter that wraps a Comparison<T> + + + + + Compares two objects + + + + + Gets the default ComparisonAdapter, which wraps an + NUnitComparer object. + + + + + Construct a ComparisonAdapter for an IComparer + + + + + Compares two objects + + + + + + + + Construct a default ComparisonAdapter + + + + + ComparisonAdapter<T> extends ComparisonAdapter and + allows use of an IComparer<T> or Comparison<T> + to actually perform the comparison. + + + + + Construct a ComparisonAdapter for an IComparer<T> + + + + + Compare a Type T to an object + + + + + Construct a ComparisonAdapter for a Comparison<T> + + + + + Compare a Type T to an object + + + + + Abstract base class for constraints that compare values to + determine if one is greater than, equal to or less than + the other. + + + + + The value against which a comparison is to be made + + + + + If true, less than returns success + + + + + if true, equal returns success + + + + + if true, greater than returns success + + + + + The predicate used as a part of the description + + + + + ComparisonAdapter to be used in making the comparison + + + + + Initializes a new instance of the class. + + The value against which to make a comparison. + if set to true less succeeds. + if set to true equal succeeds. + if set to true greater succeeds. + String used in describing the constraint. + + + + 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 + + + + 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 + + + + + Tests whether a value is greater than the value supplied to its constructor + + + + + Initializes a new instance of the class. + + The expected value. + + + + Tests whether a value is greater than or equal to the value supplied to its constructor + + + + + Initializes a new instance of the class. + + The expected value. + + + + Tests whether a value is less than the value supplied to its constructor + + + + + Initializes a new instance of the class. + + The expected value. + + + + Tests whether a value is less than or equal to the value supplied to its constructor + + + + + Initializes a new instance of the class. + + The expected value. + + + + 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 + generated ConstraintExpression class, which represents a + compound constraint in the process of being constructed + from a series of syntactic elements. + + NOTE: ConstraintExpressionBase is aware of some of its + derived classes, which is an apparent violation of + encapsulation. Ideally, these classes would be a + single class, but they must be separated in order to + allow parts to be generated under .NET 1.x and to + provide proper user feedback in syntactically + aware IDEs. + + + + + 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 new PropertyConstraintExpression, which will either + test for the existence of the named property on the object + being tested or apply any following constraint to that property. + + + + + Returns a new AttributeConstraint checking for the + presence of a particular attribute on an object. + + + + + Returns a new AttributeConstraint checking for the + presence of a particular attribute on an object. + + + + + Returns the constraint provided as an argument - used to allow custom + custom constraints to easily participate in the syntax. + + + + + Returns the constraint provided as an argument - used to allow custom + custom constraints to easily participate in the syntax. + + + + + Returns a constraint that tests two items for equality + + + + + Returns a constraint that tests that two references are the same object + + + + + Returns a constraint that tests whether the + actual value is greater than the suppled argument + + + + + Returns a constraint that tests whether the + actual value is greater than or equal to the suppled argument + + + + + Returns a constraint that tests whether the + actual value is greater than or equal to the suppled argument + + + + + Returns a constraint that tests whether the + actual value is less than the suppled argument + + + + + Returns a constraint that tests whether the + actual value is less than or equal to the suppled argument + + + + + Returns a constraint that tests whether the + actual value is less than or equal to the suppled argument + + + + + Returns a constraint that tests whether the actual + value is of the exact type supplied as an argument. + + + + + Returns a constraint that tests whether the actual + value is of the exact type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is a collection containing the same elements as the + collection supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is a subset of the collection supplied as an argument. + + + + + Returns a new CollectionContainsConstraint checking for the + presence of a particular object in the collection. + + + + + Returns a new CollectionContainsConstraint checking for the + presence of a particular object in the collection. + + + + + Returns a new ContainsConstraint. This constraint + will, in turn, make use of the appropriate second-level + constraint, depending on the type of the actual argument. + This overload is only used if the item sought is a string, + since any other type implies that we are looking for a + collection member. + + + + + Returns a constraint that succeeds if the actual + value contains the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value contains the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value starts with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value starts with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value ends with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value ends with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value matches the Regex pattern supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value matches the Regex pattern supplied as an argument. + + + + + Returns a constraint that tests whether the path provided + is the same as an expected path after canonicalization. + + + + + Returns a constraint that tests whether the path provided + is the same path or under an expected path after canonicalization. + + + + + Returns a constraint that tests whether the path provided + is the same path or under an expected path after canonicalization. + + + + + Returns a constraint that tests whether the actual value falls + within a specified range. + + + + + Returns a ConstraintExpression that negates any + following constraint. + + + + + Returns a ConstraintExpression that negates any + following constraint. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them succeed. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if at least one of them succeeds. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them fail. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the Length property of the object being tested. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the Count property of the object being tested. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the Message property of the object being tested. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the InnerException property of the object being tested. + + + + + With is currently a NOP - reserved for future use. + + + + + Returns a constraint that tests for null + + + + + Returns a constraint that tests for True + + + + + Returns a constraint that tests for False + + + + + Returns a constraint that tests for NaN + + + + + Returns a constraint that tests for empty + + + + + Returns a constraint that tests whether a collection + contains all unique items. + + + + + Returns a constraint that tests whether an object graph is serializable in binary format. + + + + + Returns a constraint that tests whether an object graph is serializable in xml format. + + + + + Returns a constraint that tests whether a collection is ordered + + + + + Helper class with properties and methods that supply + a number of constraints used in Asserts. + + + + + Returns a new PropertyConstraintExpression, which will either + test for the existence of the named property on the object + being tested or apply any following constraint to that property. + + + + + Returns a new AttributeConstraint checking for the + presence of a particular attribute on an object. + + + + + Returns a new AttributeConstraint checking for the + presence of a particular attribute on an object. + + + + + Returns a constraint that tests two items for equality + + + + + Returns a constraint that tests that two references are the same object + + + + + Returns a constraint that tests whether the + actual value is greater than the suppled argument + + + + + Returns a constraint that tests whether the + actual value is greater than or equal to the suppled argument + + + + + Returns a constraint that tests whether the + actual value is greater than or equal to the suppled argument + + + + + Returns a constraint that tests whether the + actual value is less than the suppled argument + + + + + Returns a constraint that tests whether the + actual value is less than or equal to the suppled argument + + + + + Returns a constraint that tests whether the + actual value is less than or equal to the suppled argument + + + + + Returns a constraint that tests whether the actual + value is of the exact type supplied as an argument. + + + + + Returns a constraint that tests whether the actual + value is of the exact type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is a collection containing the same elements as the + collection supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is a subset of the collection supplied as an argument. + + + + + Returns a new CollectionContainsConstraint checking for the + presence of a particular object in the collection. + + + + + Returns a new CollectionContainsConstraint checking for the + presence of a particular object in the collection. + + + + + Returns a new ContainsConstraint. This constraint + will, in turn, make use of the appropriate second-level + constraint, depending on the type of the actual argument. + This overload is only used if the item sought is a string, + since any other type implies that we are looking for a + collection member. + + + + + Returns a constraint that succeeds if the actual + value contains the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value contains the substring supplied as an argument. + + + + + Returns a constraint that fails if the actual + value contains the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value starts with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value starts with the substring supplied as an argument. + + + + + Returns a constraint that fails if the actual + value starts with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value ends with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value ends with the substring supplied as an argument. + + + + + Returns a constraint that fails if the actual + value ends with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value matches the Regex pattern supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value matches the Regex pattern supplied as an argument. + + + + + Returns a constraint that fails if the actual + value matches the pattern supplied as an argument. + + + + + Returns a constraint that tests whether the path provided + is the same as an expected path after canonicalization. + + + + + Returns a constraint that tests whether the path provided + is the same path or under an expected path after canonicalization. + + + + + Returns a constraint that tests whether the path provided + is the same path or under an expected path after canonicalization. + + + + + Returns a constraint that tests whether the actual value falls + within a specified range. + + + + + Returns a ConstraintExpression that negates any + following constraint. + + + + + Returns a ConstraintExpression that negates any + following constraint. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them succeed. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if at least one of them succeeds. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them fail. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the Length property of the object being tested. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the Count property of the object being tested. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the Message property of the object being tested. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the InnerException property of the object being tested. + + + + + Returns a constraint that tests for null + + + + + Returns a constraint that tests for True + + + + + Returns a constraint that tests for False + + + + + Returns a constraint that tests for NaN + + + + + Returns a constraint that tests for empty + + + + + Returns a constraint that tests whether a collection + contains all unique items. + + + + + Returns a constraint that tests whether an object graph is serializable in binary format. + + + + + Returns a constraint that tests whether an object graph is serializable in xml format. + + + + + Returns a constraint that tests whether a collection is ordered + + + + + The ConstraintOperator class is used internally by a + ConstraintBuilder to represent an operator that + modifies or combines constraints. + + Constraint operators use left and right precedence + values to determine whether the top operator on the + stack should be reduced before pushing a new operator. + + + + + The precedence value used when the operator + is about to be pushed to the stack. + + + + + The precedence value used when the operator + is on the top of the stack. + + + + + Reduce produces a constraint from the operator and + any arguments. It takes the arguments from the constraint + stack and pushes the resulting constraint on it. + + + + + + The syntax element preceding this operator + + + + + The syntax element folowing this operator + + + + + The precedence value used when the operator + is about to be pushed to the stack. + + + + + The precedence value used when the operator + is on the top of the stack. + + + + + PrefixOperator takes a single constraint and modifies + it's action in some way. + + + + + Reduce produces a constraint from the operator and + any arguments. It takes the arguments from the constraint + stack and pushes the resulting constraint on it. + + + + + + Returns the constraint created by applying this + prefix to another constraint. + + + + + + + Negates the test of the constraint it wraps. + + + + + Constructs a new NotOperator + + + + + Returns a NotConstraint applied to its argument. + + + + + Abstract base for operators that indicate how to + apply a constraint to items in a collection. + + + + + Constructs a CollectionOperator + + + + + Represents a constraint that succeeds if all the + members of a collection match a base constraint. + + + + + Returns a constraint that will apply the argument + to the members of a collection, succeeding if + they all succeed. + + + + + Represents a constraint that succeeds if any of the + members of a collection match a base constraint. + + + + + Returns a constraint that will apply the argument + to the members of a collection, succeeding if + any of them succeed. + + + + + Represents a constraint that succeeds if none of the + members of a collection match a base constraint. + + + + + Returns a constraint that will apply the argument + to the members of a collection, succeeding if + none of them succeed. + + + + + Represents a constraint that simply wraps the + constraint provided as an argument, without any + further functionality, but which modifes the + order of evaluation because of its precedence. + + + + + Constructor for the WithOperator + + + + + Returns a constraint that wraps its argument + + + + + Abstract base class for operators that are able to reduce to a + constraint whether or not another syntactic element follows. + + + + + Operator used to test for the presence of a named Property + on an object and optionally apply further tests to the + value of that property. + + + + + Constructs a PropOperator for a particular named property + + + + + Reduce produces a constraint from the operator and + any arguments. It takes the arguments from the constraint + stack and pushes the resulting constraint on it. + + + + + + Gets the name of the property to which the operator applies + + + + + Operator that tests for the presence of a particular attribute + on a type and optionally applies further tests to the attribute. + + + + + Construct an AttributeOperator for a particular Type + + The Type of attribute tested + + + + Reduce produces a constraint from the operator and + any arguments. It takes the arguments from the constraint + stack and pushes the resulting constraint on it. + + + + + Operator that tests that an exception is thrown and + optionally applies further tests to the exception. + + + + + Construct a ThrowsOperator + + + + + Reduce produces a constraint from the operator and + any arguments. It takes the arguments from the constraint + stack and pushes the resulting constraint on it. + + + + + Abstract base class for all binary operators + + + + + Reduce produces a constraint from the operator and + any arguments. It takes the arguments from the constraint + stack and pushes the resulting constraint on it. + + + + + + Abstract method that produces a constraint by applying + the operator to its left and right constraint arguments. + + + + + Gets the left precedence of the operator + + + + + Gets the right precedence of the operator + + + + + Operator that requires both it's arguments to succeed + + + + + Construct an AndOperator + + + + + Apply the operator to produce an AndConstraint + + + + + Operator that requires at least one of it's arguments to succeed + + + + + Construct an OrOperator + + + + + Apply the operator to produce an OrConstraint + + + + + ContainsConstraint tests a whether a string contains a substring + or a collection contains an object. It postpones the decision of + which test to use until the type of the actual argument is known. + This allows testing whether a string is contained in a collection + or as a substring of another string using the same syntax. + + + + + Initializes a new instance of the class. + + The expected. + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Flag the constraint to ignore case and return self. + + + + + Applies a delay to the match so that a match can be evaluated in the future. + + + + + Creates a new DelayedConstraint + + The inner constraint two decorate + The time interval after which the match is performed + If the value of is less than 0 + + + + Creates a new DelayedConstraint + + The inner constraint two decorate + The time interval after which the match is performed + The time interval used for polling + If the value of is less than 0 + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for if the base constraint fails, false if it succeeds + + + + Test whether the constraint is satisfied by a delegate + + The delegate whose value is to be tested + True for if the base constraint fails, false if it succeeds + + + + Test whether the constraint is satisfied by a given reference. + Overridden to wait for the specified delay period before + calling the base constraint with the dereferenced value. + + A reference to the value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a MessageWriter. + + The writer on which the actual value is displayed + + + + Returns the string representation of the constraint. + + + + + EmptyDirectoryConstraint is used to test that a directory is empty + + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + + The writer on which the actual value is displayed + + + + EmptyConstraint tests a whether a string or collection is empty, + postponing the decision about which test is applied until the + type of the actual argument is known. + + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + EqualConstraint is able to compare an actual value with the + expected value provided in its constructor. Two objects are + considered equal if both are null, or if both have the same + value. NUnit has special semantics for some object types. + + + + + If true, strings in error messages will be clipped + + + + + NUnitEqualityComparer used to test equality. + + + + + Initializes a new instance of the class. + + The expected value. + + + + Flag the constraint to use a tolerance when determining equality. + + Tolerance value to be used + Self. + + + + Flag the constraint to use the supplied IComparer object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied IComparer object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied IComparer object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied Comparison object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied IEqualityComparer object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied IEqualityComparer object. + + The IComparer object to use. + Self. + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write a failure message. Overridden to provide custom + failure messages for EqualConstraint. + + The MessageWriter to write to + + + + Write description of this constraint + + The MessageWriter to write to + + + + Display the failure information for two collections that did not match. + + The MessageWriter on which to display + The expected collection. + The actual collection + The depth of this failure in a set of nested collections + + + + Displays a single line showing the types and sizes of the expected + and actual 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 + + + + 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 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>. + + + + 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 + + + + MessageWriter is the abstract base for classes that write + constraint descriptions and messages in some form. The + class has separate methods for writing various components + of a message, allowing implementations to tailor the + presentation as needed. + + + + + Construct a MessageWriter given a culture + + + + + Method to write single line message with optional args, usually + written to precede the general failure message. + + The message to be written + Any arguments used in formatting the message + + + + Method to write single line message with optional args, usually + written to precede the general failure message, at a givel + indentation level. + + The indentation level of the message + The message to be written + Any arguments used in formatting the message + + + + Display Expected and Actual lines for a constraint. This + is called by MessageWriter's default implementation of + WriteMessageTo and provides the generic two-line display. + + The constraint that failed + + + + Display Expected and Actual lines for given values. This + method may be called by constraints that need more control over + the display of actual and expected values than is provided + by the default implementation. + + The expected value + The actual value causing the failure + + + + Display Expected and Actual lines for given values, including + a tolerance value on the Expected line. + + The expected value + The actual value causing the failure + The tolerance within which the test was made + + + + Display the expected and actual string values on separate lines. + If the mismatch parameter is >=0, an additional line is displayed + line containing a caret that points to the mismatch point. + + The expected string value + The actual string value + The point at which the strings don't match or -1 + If true, case is ignored in locating the point where the strings differ + If true, the strings should be clipped to fit the line + + + + Writes the text for a connector. + + The connector. + + + + Writes the text for a predicate. + + The predicate. + + + + Writes the text for an expected value. + + The expected value. + + + + Writes the text for a modifier + + The modifier. + + + + Writes the text for an actual value. + + The actual value. + + + + Writes the text for a generalized value. + + The value. + + + + Writes the text for a collection value, + starting at a particular point, to a max length + + The collection containing elements to write. + The starting point of the elements to write + The maximum number of elements to write + + + + Abstract method to get the max line length + + + + + Static methods used in creating messages + + + + + Static string used when strings are clipped + + + + + Returns the representation of a type as used in NUnitLite. + This is the same as Type.ToString() except for arrays, + which are displayed with their declared sizes. + + + + + + + Converts any control characters in a string + to their escaped representation. + + The string to be converted + The converted string + + + + Return the a string representation for a set of indices into an array + + Array of indices for which a string is needed + + + + Get an array of indices representing the point in a collection or + array corresponding to a single int index into the collection. + + The collection to which the indices apply + Index in the collection + Array of indices + + + + Clip a string to a given length, starting at a particular offset, returning the clipped + string with ellipses representing the removed parts + + The string to be clipped + The maximum permitted length of the result string + The point at which to start clipping + The clipped string + + + + Clip the expected and actual strings in a coordinated fashion, + so that they may be displayed together. + + + + + + + + + Shows the position two strings start to differ. Comparison + starts at the start index. + + The expected string + The actual string + The index in the strings at which comparison should start + Boolean indicating whether case should be ignored + -1 if no mismatch found, or the index where mismatch found + + + + The Numerics class contains common operations on numeric values. + + + + + Checks the type of the object, returning true if + the object is a numeric type. + + The object to check + true if the object is a numeric type + + + + Checks the type of the object, returning true if + the object is a floating point numeric type. + + The object to check + true if the object is a floating point numeric type + + + + Checks the type of the object, returning true if + the object is a fixed point numeric type. + + The object to check + true if the object is a fixed point numeric type + + + + Test two numeric values for equality, performing the usual numeric + conversions and using a provided or default tolerance. If the tolerance + provided is Empty, this method may set it to a default tolerance. + + The expected value + The actual value + A reference to the tolerance in effect + True if the values are equal + + + + Compare two numeric values, performing the usual numeric conversions. + + The expected value + The actual value + The relationship of the values to each other + + + + NUnitComparer encapsulates NUnit's default behavior + in comparing two objects. + + + + + Compares two objects + + + + + + + + Returns the default NUnitComparer. + + + + + NUnitEqualityComparer encapsulates NUnit's handling of + equality tests between objects. + + + + + If true, all string comparisons will ignore case + + + + + If true, arrays will be treated as collections, allowing + those of different dimensions to be compared + + + + + If non-zero, equality comparisons within the specified + tolerance will succeed. + + + + + Comparison object used in comparisons for some constraints. + + + + + Compares two objects for equality. + + + + + Helper method to compare two arrays + + + + + Method to compare two DirectoryInfo objects + + first directory to compare + second directory to compare + true if equivalent, false if not + + + + Returns the default NUnitEqualityComparer + + + + + Gets and sets a flag indicating whether case should + be ignored in determining equality. + + + + + Gets and sets a flag indicating that arrays should be + compared as collections, without regard to their shape. + + + + + Gets and sets an external comparer to be used to + test for equality. It is applied to members of + collections, in place of NUnit's own logic. + + + + + Gets and sets a tolerance used to compare objects of + certin types. + + + + + Gets the list of failure points for the last Match performed. + + + + + PathConstraint serves as the abstract base of constraints + that operate on paths and provides several helper methods. + + + + + The expected path used in the constraint + + + + + The actual path being tested + + + + + Flag indicating whether a caseInsensitive comparison should be made + + + + + Construct a PathConstraint for a give expected path + + The expected path + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Returns the string representation of this constraint + + + + + Canonicalize the provided path + + + The path in standardized form + + + + Test whether two paths are the same + + The first path + The second path + + + + + Test whether one path is under another path + + The first path - supposed to be the parent path + The second path - supposed to be the child path + + + + + Test whether one path is the same as or under another path + + The first path - supposed to be the parent path + The second path - supposed to be the child path + + + + + Modifies the current instance to be case-insensitve + and returns it. + + + + + Modifies the current instance to be case-sensitve + and returns it. + + + + + Summary description for SamePathConstraint. + + + + + Initializes a new instance of the class. + + The expected path + + + + Test whether the constraint is satisfied by a given value + + The 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 + + + + 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 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 + + + + 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 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 + + + + Predicate constraint wraps a Predicate in a constraint, + returning success if the predicate is true. + + + + + Construct a PredicateConstraint from a predicate + + + + + Determines whether the predicate succeeds when applied + to the actual value. + + + + + Writes the description to a MessageWriter + + + + + NotConstraint negates the effect of some other constraint + + + + + Initializes a new instance of the class. + + The base constraint to be negated. + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for if the base constraint fails, false if it succeeds + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a MessageWriter. + + The writer on which the actual value is displayed + + + + AllItemsConstraint applies another constraint to each + item in a collection, succeeding if they all succeed. + + + + + Construct an AllItemsConstraint on top of an existing constraint + + + + + + Apply the item constraint to each item in the collection, + failing if any item fails. + + + + + + + Write a description of this constraint to a MessageWriter + + + + + + SomeItemsConstraint applies another constraint to each + item in a collection, succeeding if any of them succeeds. + + + + + Construct a SomeItemsConstraint on top of an existing constraint + + + + + + Apply the item constraint to each item in the collection, + succeeding if any item succeeds. + + + + + + + Write a description of this constraint to a MessageWriter + + + + + + NoItemConstraint applies another constraint to each + item in a collection, failing if any of them succeeds. + + + + + Construct a SomeItemsConstraint 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 + + + + + + PropertyExistsConstraint tests that a named property + exists on the object provided through Match. + + Originally, PropertyConstraint provided this feature + in addition to making optional tests on the vaue + of the property. The two constraints are now separate. + + + + + Initializes a new instance of the class. + + The name of the property. + + + + Test whether the property exists for a given object + + The object to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a + MessageWriter. + + The writer on which the actual value is displayed + + + + Returns the string representation of the constraint. + + + + + + PropertyConstraint extracts a named property and uses + its value as the actual value for a chained constraint. + + + + + Initializes a new instance of the class. + + The name. + The constraint to apply to the property. + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + + The writer on which the actual value is displayed + + + + Returns the string representation of the constraint. + + + + + + RangeConstraint tests whethe two values are within a + specified range. + + + + + Initializes a new instance of the class. + + From. + To. + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + 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. + + + + + 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 + + + + + Appends an And Operator to the expression + + + + + Appends an Or operator to the expression. + + + + + SameAsConstraint tests whether an object is identical to + the object passed to its constructor + + + + + Initializes a new instance of the class. + + The expected object. + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + BinarySerializableConstraint tests whether + an object is serializable in binary format. + + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + + The writer on which the actual value is displayed + + + + Returns the string representation + + + + + BinarySerializableConstraint tests whether + an object is serializable in binary format. + + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + + The writer on which the actual value is displayed + + + + Returns the string representation of this constraint + + + + + StringConstraint is the abstract base for constraints + that operate on strings. It supports the IgnoreCase + modifier for string operations. + + + + + The expected value + + + + + Indicates whether tests should be case-insensitive + + + + + Constructs a StringConstraint given an expected value + + The expected value + + + + Modify the constraint to ignore case in matching. + + + + + EmptyStringConstraint tests whether a string is empty. + + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + NullEmptyStringConstraint tests whether a string is either null or empty. + + + + + Constructs a new NullOrEmptyStringConstraint + + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + SubstringConstraint can test whether a string contains + the expected substring. + + + + + Initializes a new instance of the class. + + The expected. + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + StartsWithConstraint can test whether a string starts + with an expected substring. + + + + + Initializes a new instance of the class. + + The expected string + + + + Test whether the constraint is matched by the actual value. + This is a template method, which calls the IsMatch method + of the derived class. + + + + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + EndsWithConstraint can test whether a string ends + with an expected substring. + + + + + Initializes a new instance of the class. + + The expected string + + + + Test whether the constraint is matched by the actual value. + This is a template method, which calls the IsMatch method + of the derived class. + + + + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + RegexConstraint can test whether a string matches + the pattern provided. + + + + + Initializes a new instance of the class. + + The pattern. + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + ThrowsConstraint is used to test the exception thrown by + a delegate by applying a constraint to it. + + + + + Initializes a new instance of the class, + using a constraint to be applied to the exception. + + A constraint to apply to the caught exception. + + + + Executes the code of the delegate and captures any exception. + If a non-null base constraint was provided, it applies that + constraint to the exception. + + A delegate representing the code to be tested + True if an exception is thrown and the constraint succeeds, otherwise false + + + + Converts an ActualValueDelegate to a TestDelegate + before calling the primary overload. + + + + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + + The writer on which the actual value is displayed + + + + Returns the string representation of this constraint + + + + + Get the actual exception thrown - used by Assert.Throws. + + + + + ThrowsNothingConstraint tests that a delegate does not + throw an exception. + + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True if no exception is thrown, otherwise false + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + + The writer on which the actual value is displayed + + + + Modes in which the tolerance value for a comparison can + be interpreted. + + + + + The tolerance was created with a value, without specifying + how the value would be used. This is used to prevent setting + the mode more than once and is generally changed to Linear + upon execution of the test. + + + + + The tolerance is used as a numeric range within which + two compared values are considered to be equal. + + + + + Interprets the tolerance as the percentage by which + the two compared values my deviate from each other. + + + + + Compares two values based in their distance in + representable numbers. + + + + + The Tolerance class generalizes the notion of a tolerance + within which an equality test succeeds. Normally, it is + used with numeric types, but it can be used with any + type that supports taking a difference between two + objects and comparing that difference to a value. + + + + + Constructs a linear tolerance of a specdified amount + + + + + Constructs a tolerance given an amount and ToleranceMode + + + + + Tests that the current Tolerance is linear with a + numeric value, throwing an exception if it is not. + + + + + Returns an empty Tolerance object, equivalent to + specifying an exact match. + + + + + Gets the ToleranceMode for the current Tolerance + + + + + Gets the value of the current Tolerance instance. + + + + + Returns a new tolerance, using the current amount as a percentage. + + + + + Returns a new tolerance, using the current amount in Ulps. + + + + + Returns a new tolerance with a TimeSpan as the amount, using + the current amount as a number of days. + + + + + Returns a new tolerance with a TimeSpan as the amount, using + the current amount as a number of hours. + + + + + Returns a new tolerance with a TimeSpan as the amount, using + the current amount as a number of minutes. + + + + + Returns a new tolerance with a TimeSpan as the amount, using + the current amount as a number of seconds. + + + + + Returns a new tolerance with a TimeSpan as the amount, using + the current amount as a number of milliseconds. + + + + + Returns a new tolerance with a TimeSpan as the amount, using + the current amount as a number of clock ticks. + + + + + Returns true if the current tolerance is empty. + + + + + TypeConstraint is the abstract base for constraints + that take a Type as their expected value. + + + + + The expected Type used by the constraint + + + + + Construct a TypeConstraint for a given Type + + + + + + Write the actual value for a failing constraint test to a + MessageWriter. TypeConstraints override this method to write + the name of the type. + + The writer on which the actual value is displayed + + + + ExactTypeConstraint is used to test that an object + is of the exact type provided in the constructor + + + + + Construct an ExactTypeConstraint for a given Type + + The expected Type. + + + + Test that an object is of the exact type specified + + The actual value. + True if the tested object is of the exact type provided, otherwise false. + + + + Write the description of this constraint to a MessageWriter + + The MessageWriter to use + + + + InstanceOfTypeConstraint is used to test that an object + is of the same type provided or derived from it. + + + + + Construct an InstanceOfTypeConstraint for the type provided + + The expected Type + + + + Test whether an object is of the specified type or a derived type + + The object to be tested + True if the object is of the provided type or derives from it, otherwise false. + + + + Write a description of this constraint to a MessageWriter + + The MessageWriter to use + + + + AssignableFromConstraint is used to test that an object + can be assigned from a given Type. + + + + + Construct an AssignableFromConstraint for the type provided + + + + + + Test whether an object can be assigned from the specified type + + The object to be tested + True if the object can be assigned a value of the expected Type, otherwise false. + + + + Write a description of this constraint to a MessageWriter + + The MessageWriter to use + + + + AssignableToConstraint is used to test that an object + can be assigned to a given Type. + + + + + Construct an AssignableToConstraint for the type provided + + + + + + Test whether an object can be assigned to the specified type + + The object to be tested + True if the object can be assigned a value of the expected Type, otherwise false. + + + + Write a description of this constraint to a MessageWriter + + The MessageWriter to use + + + + Thrown when an assertion failed. + + + + + The error message that explains + the reason for the exception + + + The error message that explains + the reason for the exception + The exception that caused the + current exception + + + + Serialization Constructor + + + + + Thrown when an assertion failed. + + + + + + + The error message that explains + the reason for the exception + The exception that caused the + current exception + + + + Serialization Constructor + + + + + Thrown when a test executes inconclusively. + + + + + The error message that explains + the reason for the exception + + + The error message that explains + the reason for the exception + The exception that caused the + current exception + + + + Serialization Constructor + + + + + Thrown when an assertion failed. + + + + + + + The error message that explains + the reason for the exception + The exception that caused the + current exception + + + + Serialization Constructor + + + + + Delegate used by tests that execute code and + capture any thrown exception. + + + + + The Assert class contains a collection of static methods that + implement the most common assertions used in NUnit. + + + + + We don't actually want any instances of this object, but some people + like to inherit from it to add other static methods. Hence, the + protected constructor disallows any instances of this object. + + + + + The Equals method throws an AssertionException. This is done + to make sure there is no mistake by calling this function. + + + + + + + override the default ReferenceEquals to throw an AssertionException. This + implementation makes sure there is no mistake in calling this function + as part of Assert. + + + + + + + Helper for Assert.AreEqual(double expected, double actual, ...) + allowing code generation to work consistently. + + The expected value + The actual value + The maximum acceptable difference between the + the expected and the actual + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Throws a with the message and arguments + that are passed in. This allows a test to be cut short, with a result + of success returned to NUnit. + + The message to initialize the with. + Arguments to be used in formatting the message + + + + Throws a with the message and arguments + that are passed in. This allows a test to be cut short, with a result + of success returned to NUnit. + + The message to initialize the with. + + + + Throws a with the message and arguments + that are passed in. This allows a test to be cut short, with a result + of success returned to NUnit. + + + + + Throws an with the message and arguments + that are passed in. This is used by the other Assert functions. + + The message to initialize the with. + Arguments to be used in formatting the message + + + + Throws an with the message that is + passed in. This is used by the other Assert functions. + + The message to initialize the with. + + + + Throws an . + This is used by the other Assert functions. + + + + + Throws an with the message and arguments + that are passed in. This causes the test to be reported as ignored. + + The message to initialize the with. + Arguments to be used in formatting the message + + + + Throws an with the message that is + passed in. This causes the test to be reported as ignored. + + The message to initialize the with. + + + + Throws an . + This causes the test to be reported as ignored. + + + + + Throws an with the message and arguments + that are passed in. This causes the test to be reported as inconclusive. + + The message to initialize the with. + Arguments to be used in formatting the message + + + + Throws an with the message that is + passed in. This causes the test to be reported as inconclusive. + + The message to initialize the with. + + + + Throws an . + This causes the test to be reported as Inconclusive. + + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint to be applied + The actual value to test + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint to be applied + The actual value to test + The message that will be displayed on failure + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint expression to be applied + The actual value to test + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint expression to be applied + An ActualValueDelegate returning the value to be tested + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint expression to be applied + An ActualValueDelegate returning the value to be tested + The message that will be displayed on failure + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + An ActualValueDelegate returning the value to be tested + A Constraint expression to be applied + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint to be applied + The actual value to test + + + + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint to be applied + The actual value to test + The message that will be displayed on failure + + + + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint to be applied + The actual value to test + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + The message to display if the condition is false + Arguments to be used in formatting the message + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + The message to display if the condition is false + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + + + + Asserts that the code represented by a delegate throws an exception + that satisfies the constraint provided. + + A TestDelegate to be executed + A ThrowsConstraint used in the test + + + + Verifies that a delegate throws a particular exception when called. + + A constraint to be satisfied by the exception + A TestSnippet delegate + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Verifies that a delegate throws a particular exception when called. + + A constraint to be satisfied by the exception + A TestSnippet delegate + The message that will be displayed on failure + + + + Verifies that a delegate throws a particular exception when called. + + A constraint to be satisfied by the exception + A TestSnippet delegate + + + + Verifies that a delegate throws a particular exception when called. + + The exception Type expected + A TestSnippet delegate + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Verifies that a delegate throws a particular exception when called. + + The exception Type expected + A TestSnippet delegate + The message that will be displayed on failure + + + + Verifies that a delegate throws a particular exception when called. + + The exception Type expected + A TestSnippet delegate + + + + Verifies that a delegate throws a particular exception when called. + + Type of the expected exception + A TestSnippet delegate + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Verifies that a delegate throws a particular exception when called. + + Type of the expected exception + A TestSnippet delegate + The message that will be displayed on failure + + + + Verifies that a delegate throws a particular exception when called. + + Type of the expected exception + A TestSnippet delegate + + + + Verifies that a delegate throws an exception when called + and returns it. + + A TestDelegate + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Verifies that a delegate throws an exception when called + and returns it. + + A TestDelegate + The message that will be displayed on failure + + + + Verifies that a delegate throws an exception when called + and returns it. + + A TestDelegate + + + + Verifies that a delegate throws an exception of a certain Type + or one derived from it when called and returns it. + + The expected Exception Type + A TestDelegate + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Verifies that a delegate throws an exception of a certain Type + or one derived from it when called and returns it. + + The expected Exception Type + A TestDelegate + The message that will be displayed on failure + + + + Verifies that a delegate throws an exception of a certain Type + or one derived from it when called and returns it. + + The expected Exception Type + A TestDelegate + + + + Verifies that a delegate throws an exception of a certain Type + or one derived from it when called and returns it. + + The expected Exception Type + A TestDelegate + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Verifies that a delegate throws an exception of a certain Type + or one derived from it when called and returns it. + + The expected Exception Type + A TestDelegate + The message that will be displayed on failure + + + + Verifies that a delegate throws an exception of a certain Type + or one derived from it when called and returns it. + + The expected Exception Type + A TestDelegate + + + + Verifies that a delegate does not throw an exception + + A TestSnippet delegate + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Verifies that a delegate does not throw an exception. + + A TestSnippet delegate + The message that will be displayed on failure + + + + Verifies that a delegate does not throw an exception. + + A TestSnippet delegate + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + The message to display in case of failure + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + The message to display in case of failure + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + + + + Asserts that a condition is false. If the condition is true the method throws + an . + + The evaluated condition + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that a condition is false. If the condition is true the method throws + an . + + The evaluated condition + The message to display in case of failure + + + + Asserts that a condition is false. If the condition is true the method throws + an . + + The evaluated condition + + + + Asserts that a condition is false. If the condition is true the method throws + an . + + The evaluated condition + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that a condition is false. If the condition is true the method throws + an . + + The evaluated condition + The message to display in case of failure + + + + Asserts that a condition is false. If the condition is true the method throws + an . + + The evaluated condition + + + + Verifies that the object that is passed in is not equal to null + If the object is null then an + is thrown. + + The object that is to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the object that is passed in is not equal to null + If the object is null then an + is thrown. + + The object that is to be tested + The message to display in case of failure + + + + Verifies that the object that is passed in is not equal to null + If the object is null then an + is thrown. + + The object that is to be tested + + + + Verifies that the object that is passed in is not equal to null + If the object is null then an + is thrown. + + The object that is to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the object that is passed in is not equal to null + If the object is null then an + is thrown. + + The object that is to be tested + The message to display in case of failure + + + + Verifies that the object that is passed in is not equal to null + If the object is null then an + is thrown. + + The object that is to be tested + + + + Verifies that the object that is passed in is equal to null + If the object is not null then an + is thrown. + + The object that is to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the object that is passed in is equal to null + If the object is not null then an + is thrown. + + The object that is to be tested + The message to display in case of failure + + + + Verifies that the object that is passed in is equal to null + If the object is not null then an + is thrown. + + The object that is to be tested + + + + Verifies that the object that is passed in is equal to null + If the object is not null then an + is thrown. + + The object that is to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the object that is passed in is equal to null + If the object is not null then an + is thrown. + + The object that is to be tested + The message to display in case of failure + + + + Verifies that the object that is passed in is equal to null + If the object is not null then an + is thrown. + + The object that is to be tested + + + + Verifies that the double that is passed in is an NaN value. + If the object is not NaN then an + is thrown. + + The value that is to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the double that is passed in is an NaN value. + If the object is not NaN then an + is thrown. + + The value that is to be tested + The message to display in case of failure + + + + Verifies that the double that is passed in is an NaN value. + If the object is not NaN then an + is thrown. + + The value that is to be tested + + + + Verifies that the double that is passed in is an NaN value. + If the object is not NaN then an + is thrown. + + The value that is to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the double that is passed in is an NaN value. + If the object is not NaN then an + is thrown. + + The value that is to be tested + The message to display in case of failure + + + + Verifies that the double that is passed in is an NaN value. + If the object is not NaN then an + is thrown. + + The value that is to be tested + + + + Assert that a string is empty - that is equal to string.Empty + + The string to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Assert that a string is empty - that is equal to string.Empty + + The string to be tested + The message to display in case of failure + + + + Assert that a string is empty - that is equal to string.Empty + + The string to be tested + + + + Assert that an array, list or other collection is empty + + An array, list or other collection implementing ICollection + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Assert that an array, list or other collection is empty + + An array, list or other collection implementing ICollection + The message to display in case of failure + + + + Assert that an array, list or other collection is empty + + An array, list or other collection implementing ICollection + + + + Assert that a string is not empty - that is not equal to string.Empty + + The string to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Assert that a string is not empty - that is not equal to string.Empty + + The string to be tested + The message to display in case of failure + + + + Assert that a string is not empty - that is not equal to string.Empty + + The string to be tested + + + + Assert that an array, list or other collection is not empty + + An array, list or other collection implementing ICollection + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Assert that an array, list or other collection is not empty + + An array, list or other collection implementing ICollection + The message to display in case of failure + + + + Assert that an array, list or other collection is not empty + + An array, list or other collection implementing ICollection + + + + Assert that a string is either null or equal to string.Empty + + The string to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Assert that a string is either null or equal to string.Empty + + The string to be tested + The message to display in case of failure + + + + Assert that a string is either null or equal to string.Empty + + The string to be tested + + + + Assert that a string is not null or empty + + The string to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Assert that a string is not null or empty + + The string to be tested + The message to display in case of failure + + + + Assert that a string is not null or empty + + The string to be tested + + + + Asserts that an object may be assigned a value of a given Type. + + The expected Type. + The object under examination + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object may be assigned a value of a given Type. + + The expected Type. + The object under examination + The message to display in case of failure + + + + Asserts that an object may be assigned a value of a given Type. + + The expected Type. + The object under examination + + + + Asserts that an object may be assigned a value of a given Type. + + The expected Type. + The object under examination + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object may be assigned a value of a given Type. + + The expected Type. + The object under examination + The message to display in case of failure + + + + Asserts that an object may be assigned a value of a given Type. + + The expected Type. + The object under examination + + + + Asserts that an object may not be assigned a value of a given Type. + + The expected Type. + The object under examination + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object may not be assigned a value of a given Type. + + The expected Type. + The object under examination + The message to display in case of failure + + + + Asserts that an object may not be assigned a value of a given Type. + + The expected Type. + The object under examination + + + + Asserts that an object may not be assigned a value of a given Type. + + The expected Type. + The object under examination + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object may not be assigned a value of a given Type. + + The expected Type. + The object under examination + The message to display in case of failure + + + + Asserts that an object may not be assigned a value of a given Type. + + The expected Type. + The object under examination + + + + Asserts that an object is an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object is an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + + + + Asserts that an object is an instance of a given type. + + The expected Type + The object being examined + + + + Asserts that an object is an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object is an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + + + + Asserts that an object is an instance of a given type. + + The expected Type + The object being examined + + + + Asserts that an object is an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object is an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + + + + Asserts that an object is an instance of a given type. + + The expected Type + The object being examined + + + + Asserts that an object is not an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object is not an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + + + + Asserts that an object is not an instance of a given type. + + The expected Type + The object being examined + + + + Asserts that an object is not an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object is not an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + + + + Asserts that an object is not an instance of a given type. + + The expected Type + The object being examined + + + + Asserts that an object is not an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object is not an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + + + + Asserts that an object is not an instance of a given type. + + The expected Type + The object being examined + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two doubles are equal considering a delta. If the + expected value is infinity then the delta value is ignored. If + they are not equal then an is + thrown. + + The expected value + The actual value + The maximum acceptable difference between the + the expected and the actual + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two doubles are equal considering a delta. If the + expected value is infinity then the delta value is ignored. If + they are not equal then an is + thrown. + + The expected value + The actual value + The maximum acceptable difference between the + the expected and the actual + The message to display in case of failure + + + + Verifies that two doubles are equal considering a delta. If the + expected value is infinity then the delta value is ignored. If + they are not equal then an is + thrown. + + The expected value + The actual value + The maximum acceptable difference between the + the expected and the actual + + + + Verifies that two doubles are equal considering a delta. If the + expected value is infinity then the delta value is ignored. If + they are not equal then an is + thrown. + + The expected value + The actual value + The maximum acceptable difference between the + the expected and the actual + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two doubles are equal considering a delta. If the + expected value is infinity then the delta value is ignored. If + they are not equal then an is + thrown. + + The expected value + The actual value + The maximum acceptable difference between the + the expected and the actual + The message to display in case of failure + + + + Verifies that two doubles are equal considering a delta. If the + expected value is infinity then the delta value is ignored. If + they are not equal then an is + thrown. + + The expected value + The actual value + The maximum acceptable difference between the + the expected and the actual + + + + Verifies that two objects are equal. Two objects are considered + equal if both are null, or if both have the same value. NUnit + has special semantics for some object types. + If they are not equal an is thrown. + + The value that is expected + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two objects are equal. Two objects are considered + equal if both are null, or if both have the same value. NUnit + has special semantics for some object types. + If they are not equal an is thrown. + + The value that is expected + The actual value + The message to display in case of failure + + + + Verifies that two objects are equal. Two objects are considered + equal if both are null, or if both have the same value. NUnit + has special semantics for some object types. + If they are not equal an is thrown. + + The value that is expected + The actual value + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two objects are not equal. Two objects are considered + equal if both are null, or if both have the same value. NUnit + has special semantics for some object types. + If they are equal an is thrown. + + The value that is expected + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two objects are not equal. Two objects are considered + equal if both are null, or if both have the same value. NUnit + has special semantics for some object types. + If they are equal an is thrown. + + The value that is expected + The actual value + The message to display in case of failure + + + + Verifies that two objects are not equal. Two objects are considered + equal if both are null, or if both have the same value. NUnit + has special semantics for some object types. + If they are equal an is thrown. + + The value that is expected + The actual value + + + + Asserts that two objects refer to the same object. If they + are not the same an is thrown. + + The expected object + The actual object + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that two objects refer to the same object. If they + are not the same an is thrown. + + The expected object + The actual object + The message to display in case of failure + + + + Asserts that two objects refer to the same object. If they + are not the same an is thrown. + + The expected object + The actual object + + + + Asserts that two objects do not refer to the same object. If they + are the same an is thrown. + + The expected object + The actual object + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that two objects do not refer to the same object. If they + are the same an is thrown. + + The expected object + The actual object + The message to display in case of failure + + + + Asserts that two objects do not refer to the same object. If they + are the same an is thrown. + + The expected object + The actual object + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Asserts that an object is contained in a list. + + The expected object + The list to be examined + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object is contained in a list. + + The expected object + The list to be examined + The message to display in case of failure + + + + Asserts that an object is contained in a list. + + The expected object + The list to be examined + + + + Gets the number of assertions executed so far and + resets the counter to zero. + + + + + AssertionHelper is an optional base class for user tests, + allowing the use of shorter names for constraints and + asserts and avoiding conflict with the definition of + , from which it inherits much of its + behavior, in certain mock object frameworks. + + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. Works + identically to + + A Constraint to be applied + The actual value to test + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. Works + identically to + + A Constraint to be applied + The actual value to test + The message that will be displayed on failure + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. Works + identically to + + A Constraint to be applied + The actual value to test + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint expression to be applied + An ActualValueDelegate returning the value to be tested + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint expression to be applied + An ActualValueDelegate returning the value to be tested + The message that will be displayed on failure + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + An ActualValueDelegate returning the value to be tested + A Constraint expression to be applied + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint to be applied + The actual value to test + + + + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint to be applied + The actual value to test + The message that will be displayed on failure + + + + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint to be applied + The actual value to test + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that a condition is true. If the condition is false the method throws + an . Works Identically to + . + + 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 + + + + Asserts that the code represented by a delegate throws an exception + that satisfies the constraint provided. + + A TestDelegate to be executed + A ThrowsConstraint used in the test + + + + Returns a ListMapper based on a collection. + + The original collection + + + + + Provides static methods to express the assumptions + that must be met for a test to give a meaningful + result. If an assumption is not met, the test + should produce an inconclusive result. + + + + + The Equals method throws an AssertionException. This is done + to make sure there is no mistake by calling this function. + + + + + + + override the default ReferenceEquals to throw an AssertionException. This + implementation makes sure there is no mistake in calling this function + as part of Assert. + + + + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + + A Constraint expression to be applied + The actual value to test + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + + A Constraint expression to be applied + The actual value to test + The message that will be displayed on failure + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + + A Constraint expression to be applied + The actual value to test + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + + A Constraint expression to be applied + An ActualValueDelegate returning the value to be tested + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + + A Constraint expression to be applied + An ActualValueDelegate returning the value to be tested + The message that will be displayed on failure + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + + An ActualValueDelegate returning the value to be tested + A Constraint expression to be applied + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + + A Constraint expression to be applied + The actual value to test + + + + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + + A Constraint expression to be applied + The actual value to test + The message that will be displayed on failure + + + + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + + A Constraint expression to be applied + The actual value to test + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + The message to display if the condition is false + Arguments to be used in formatting the message + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + The message to display if the condition is false + + + + Asserts that a condition is true. If the condition is false the + method throws an . + + The evaluated condition + + + + Asserts that the code represented by a delegate throws an exception + that satisfies the constraint provided. + + A TestDelegate to be executed + A ThrowsConstraint used in the test + + + + A set of Assert methods operationg on one or more collections + + + + + The Equals method throws an AssertionException. This is done + to make sure there is no mistake by calling this function. + + + + + + + override the default ReferenceEquals to throw an AssertionException. This + implementation makes sure there is no mistake in calling this function + as part of Assert. + + + + + + + Asserts that all items contained in collection are of the type specified by expectedType. + + IEnumerable containing objects to be considered + System.Type that all objects in collection must be instances of + + + + Asserts that all items contained in collection are of the type specified by expectedType. + + IEnumerable containing objects to be considered + System.Type that all objects in collection must be instances of + The message that will be displayed on failure + + + + Asserts that all items contained in collection are of the type specified by expectedType. + + IEnumerable containing objects to be considered + System.Type that all objects in collection must be instances of + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that all items contained in collection are not equal to null. + + IEnumerable containing objects to be considered + + + + Asserts that all items contained in collection are not equal to null. + + IEnumerable containing objects to be considered + The message that will be displayed on failure + + + + Asserts that all items contained in collection are not equal to null. + + IEnumerable of objects to be considered + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Ensures that every object contained in collection exists within the collection + once and only once. + + IEnumerable of objects to be considered + + + + Ensures that every object contained in collection exists within the collection + once and only once. + + IEnumerable of objects to be considered + The message that will be displayed on failure + + + + Ensures that every object contained in collection exists within the collection + once and only once. + + IEnumerable of objects to be considered + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that expected and actual are exactly equal. The collections must have the same count, + and contain the exact same objects in the same order. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + + + + Asserts that expected and actual are exactly equal. The collections must have the same count, + and contain the exact same objects in the same order. + If comparer is not null then it will be used to compare the objects. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The IComparer to use in comparing objects from each IEnumerable + + + + Asserts that expected and actual are exactly equal. The collections must have the same count, + and contain the exact same objects in the same order. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The message that will be displayed on failure + + + + Asserts that expected and actual are exactly equal. The collections must have the same count, + and contain the exact same objects in the same order. + If comparer is not null then it will be used to compare the objects. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The IComparer to use in comparing objects from each IEnumerable + The message that will be displayed on failure + + + + Asserts that expected and actual are exactly equal. The collections must have the same count, + and contain the exact same objects in the same order. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that expected and actual are exactly equal. The collections must have the same count, + and contain the exact same objects in the same order. + If comparer is not null then it will be used to compare the objects. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The IComparer to use in comparing objects from each IEnumerable + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + + + + Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The message that will be displayed on failure + + + + Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that expected and actual are not exactly equal. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + + + + Asserts that expected and actual are not exactly equal. + If comparer is not null then it will be used to compare the objects. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The IComparer to use in comparing objects from each IEnumerable + + + + Asserts that expected and actual are not exactly equal. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The message that will be displayed on failure + + + + Asserts that expected and actual are not exactly equal. + If comparer is not null then it will be used to compare the objects. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The IComparer to use in comparing objects from each IEnumerable + The message that will be displayed on failure + + + + Asserts that expected and actual are not exactly equal. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that expected and actual are not exactly equal. + If comparer is not null then it will be used to compare the objects. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The IComparer to use in comparing objects from each IEnumerable + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that expected and actual are not equivalent. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + + + + Asserts that expected and actual are not equivalent. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The message that will be displayed on failure + + + + Asserts that expected and actual are not equivalent. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that collection contains actual as an item. + + IEnumerable of objects to be considered + Object to be found within collection + + + + Asserts that collection contains actual as an item. + + IEnumerable of objects to be considered + Object to be found within collection + The message that will be displayed on failure + + + + Asserts that collection contains actual as an item. + + IEnumerable of objects to be considered + Object to be found within collection + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that collection does not contain actual as an item. + + IEnumerable of objects to be considered + Object that cannot exist within collection + + + + Asserts that collection does not contain actual as an item. + + IEnumerable of objects to be considered + Object that cannot exist within collection + The message that will be displayed on failure + + + + Asserts that collection does not contain actual as an item. + + IEnumerable of objects to be considered + Object that cannot exist within collection + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that superset is not a subject of subset. + + The IEnumerable superset to be considered + The IEnumerable subset to be considered + + + + Asserts that superset is not a subject of subset. + + The IEnumerable superset to be considered + The IEnumerable subset to be considered + The message that will be displayed on failure + + + + Asserts that superset is not a subject of subset. + + The IEnumerable superset to be considered + The IEnumerable subset to be considered + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that superset is a subset of subset. + + The IEnumerable superset to be considered + The IEnumerable subset to be considered + + + + Asserts that superset is a subset of subset. + + The IEnumerable superset to be considered + The IEnumerable subset to be considered + The message that will be displayed on failure + + + + Asserts that superset is a subset of subset. + + The IEnumerable superset to be considered + The IEnumerable subset to be considered + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Assert that an array, list or other collection is empty + + An array, list or other collection implementing IEnumerable + The message to be displayed on failure + Arguments to be used in formatting the message + + + + Assert that an array, list or other collection is empty + + An array, list or other collection implementing IEnumerable + The message to be displayed on failure + + + + Assert that an array,list or other collection is empty + + An array, list or other collection implementing IEnumerable + + + + Assert that an array, list or other collection is empty + + An array, list or other collection implementing IEnumerable + The message to be displayed on failure + Arguments to be used in formatting the message + + + + Assert that an array, list or other collection is empty + + An array, list or other collection implementing IEnumerable + The message to be displayed on failure + + + + Assert that an array,list or other collection is empty + + An array, list or other collection implementing IEnumerable + + + + Assert that an array, list or other collection is ordered + + An array, list or other collection implementing IEnumerable + The message to be displayed on failure + Arguments to be used in formatting the message + + + + Assert that an array, list or other collection is ordered + + An array, list or other collection implementing IEnumerable + The message to be displayed on failure + + + + Assert that an array, list or other collection is ordered + + An array, list or other collection implementing IEnumerable + + + + Assert that an array, list or other collection is ordered + + An array, list or other collection implementing IEnumerable + A custom comparer to perform the comparisons + The message to be displayed on failure + Arguments to be used in formatting the message + + + + Assert that an array, list or other collection is ordered + + An array, list or other collection implementing IEnumerable + A custom comparer to perform the comparisons + The message to be displayed on failure + + + + Assert that an array, list or other collection is ordered + + An array, list or other collection implementing IEnumerable + A custom comparer to perform the comparisons + + + + Static helper class used in the constraint-based syntax + + + + + Creates a new SubstringConstraint + + The value of the substring + A SubstringConstraint + + + + Creates a new CollectionContainsConstraint. + + The item that should be found. + A new CollectionContainsConstraint + + + + Summary description for DirectoryAssert + + + + + The Equals method throws an AssertionException. This is done + to make sure there is no mistake by calling this function. + + + + + + + override the default ReferenceEquals to throw an AssertionException. This + implementation makes sure there is no mistake in calling this function + as part of Assert. + + + + + + + We don't actually want any instances of this object, but some people + like to inherit from it to add other static methods. Hence, the + protected constructor disallows any instances of this object. + + + + + Verifies that two directories are equal. Two directories are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + A directory containing the value that is expected + A directory containing the actual value + The message to display if directories are not equal + Arguments to be used in formatting the message + + + + Verifies that two directories are equal. Two directories are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + A directory containing the value that is expected + A directory containing the actual value + The message to display if directories are not equal + + + + Verifies that two directories are equal. Two directories are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + A directory containing the value that is expected + A directory containing the actual value + + + + Verifies that two directories are equal. Two directories are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + A directory path string containing the value that is expected + A directory path string containing the actual value + The message to display if directories are not equal + Arguments to be used in formatting the message + + + + Verifies that two directories are equal. Two directories are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + A directory path string containing the value that is expected + A directory path string containing the actual value + The message to display if directories are not equal + + + + Verifies that two directories are equal. Two directories are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + A directory path string containing the value that is expected + A directory path string containing the actual value + + + + Asserts that two directories are not equal. If they are equal + an is thrown. + + A directory containing the value that is expected + A directory containing the actual value + The message to display if directories are not equal + Arguments to be used in formatting the message + + + + Asserts that two directories are not equal. If they are equal + an is thrown. + + A directory containing the value that is expected + A directory containing the actual value + The message to display if directories are not equal + + + + Asserts that two directories are not equal. If they are equal + an is thrown. + + A directory containing the value that is expected + A directory containing the actual value + + + + Asserts that two directories are not equal. If they are equal + an is thrown. + + A directory path string containing the value that is expected + A directory path string containing the actual value + The message to display if directories are equal + Arguments to be used in formatting the message + + + + Asserts that two directories are not equal. If they are equal + an is thrown. + + A directory path string containing the value that is expected + A directory path string containing the actual value + The message to display if directories are equal + + + + Asserts that two directories are not equal. If they are equal + an is thrown. + + A directory path string containing the value that is expected + A directory path string containing the actual value + + + + Asserts that the directory is empty. If it is not empty + an is thrown. + + A directory to search + The message to display if directories are not equal + Arguments to be used in formatting the message + + + + Asserts that the directory is empty. If it is not empty + an is thrown. + + A directory to search + The message to display if directories are not equal + + + + Asserts that the directory is empty. If it is not empty + an is thrown. + + A directory to search + + + + Asserts that the directory is empty. If it is not empty + an is thrown. + + A directory to search + The message to display if directories are not equal + Arguments to be used in formatting the message + + + + Asserts that the directory is empty. If it is not empty + an is thrown. + + A directory to search + The message to display if directories are not equal + + + + Asserts that the directory is empty. If it is not empty + an is thrown. + + A directory to search + + + + Asserts that the directory is not empty. If it is empty + an is thrown. + + A directory to search + The message to display if directories are not equal + Arguments to be used in formatting the message + + + + Asserts that the directory is not empty. If it is empty + an is thrown. + + A directory to search + The message to display if directories are not equal + + + + Asserts that the directory is not empty. If it is empty + an is thrown. + + A directory to search + + + + Asserts that the directory is not empty. If it is empty + an is thrown. + + A directory to search + The message to display if directories are not equal + Arguments to be used in formatting the message + + + + Asserts that the directory is not empty. If it is empty + an is thrown. + + A directory to search + The message to display if directories are not equal + + + + Asserts that the directory is not empty. If it is empty + an is thrown. + + A directory to search + + + + Asserts that path contains actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + The message to display if directory is not within the path + Arguments to be used in formatting the message + + + + Asserts that path contains actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + The message to display if directory is not within the path + + + + Asserts that path contains actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + + + + Asserts that path contains actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + The message to display if directory is not within the path + Arguments to be used in formatting the message + + + + Asserts that path contains actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + The message to display if directory is not within the path + + + + Asserts that path contains actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + + + + Asserts that path does not contain actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + The message to display if directory is not within the path + Arguments to be used in formatting the message + + + + Asserts that path does not contain actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + The message to display if directory is not within the path + + + + Asserts that path does not contain actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + + + + Asserts that path does not contain actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + The message to display if directory is not within the path + Arguments to be used in formatting the message + + + + Asserts that path does not contain actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + The message to display if directory is not within the path + + + + Asserts that path does not contain actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + + + + Summary description for FileAssert. + + + + + The Equals method throws an AssertionException. This is done + to make sure there is no mistake by calling this function. + + + + + + + override the default ReferenceEquals to throw an AssertionException. This + implementation makes sure there is no mistake in calling this function + as part of Assert. + + + + + + + We don't actually want any instances of this object, but some people + like to inherit from it to add other static methods. Hence, the + protected constructor disallows any instances of this object. + + + + + Verifies that two Streams are equal. Two Streams are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + The expected Stream + The actual Stream + The message to display if Streams are not equal + Arguments to be used in formatting the message + + + + Verifies that two Streams are equal. Two Streams are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + The expected Stream + The actual Stream + The message to display if objects are not equal + + + + Verifies that two Streams are equal. Two Streams are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + The expected Stream + The actual Stream + + + + Verifies that two files are equal. Two files are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + A file containing the value that is expected + A file containing the actual value + The message to display if Streams are not equal + Arguments to be used in formatting the message + + + + Verifies that two files are equal. Two files are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + A file containing the value that is expected + A file containing the actual value + The message to display if objects are not equal + + + + Verifies that two files are equal. Two files are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + A file containing the value that is expected + A file containing the actual value + + + + Verifies that two files are equal. Two files are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + The path to a file containing the value that is expected + The path to a file containing the actual value + The message to display if Streams are not equal + Arguments to be used in formatting the message + + + + Verifies that two files are equal. Two files are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + The path to a file containing the value that is expected + The path to a file containing the actual value + The message to display if objects are not equal + + + + Verifies that two files are equal. Two files are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + The path to a file containing the value that is expected + The path to a file containing the actual value + + + + Asserts that two Streams are not equal. If they are equal + an is thrown. + + The expected Stream + The actual Stream + The message to be displayed when the two Stream are the same. + Arguments to be used in formatting the message + + + + Asserts that two Streams are not equal. If they are equal + an is thrown. + + The expected Stream + The actual Stream + The message to be displayed when the Streams are the same. + + + + Asserts that two Streams are not equal. If they are equal + an is thrown. + + The expected Stream + The actual Stream + + + + Asserts that two files are not equal. If they are equal + an is thrown. + + A file containing the value that is expected + A file containing the actual value + The message to display if Streams are not equal + Arguments to be used in formatting the message + + + + Asserts that two files are not equal. If they are equal + an is thrown. + + A file containing the value that is expected + A file containing the actual value + The message to display if objects are not equal + + + + Asserts that two files are not equal. If they are equal + an is thrown. + + A file containing the value that is expected + A file containing the actual value + + + + Asserts that two files are not equal. If they are equal + an is thrown. + + The path to a file containing the value that is expected + The path to a file containing the actual value + The message to display if Streams are not equal + Arguments to be used in formatting the message + + + + Asserts that two files are not equal. If they are equal + an is thrown. + + The path to a file containing the value that is expected + The path to a file containing the actual value + The message to display if objects are not equal + + + + Asserts that two files are not equal. If they are equal + an is thrown. + + The path to a file containing the value that is expected + The path to a file containing the actual value + + + + GlobalSettings is a place for setting default values used + by the framework in performing asserts. + + + + + Default tolerance for floating point equality + + + + + Helper class with properties and methods that supply + a number of constraints used in Asserts. + + + + + Returns a new PropertyConstraintExpression, which will either + test for the existence of the named property on the object + being tested or apply any following constraint to that property. + + + + + Returns a new AttributeConstraint checking for the + presence of a particular attribute on an object. + + + + + Returns a new AttributeConstraint checking for the + presence of a particular attribute on an object. + + + + + Returns a new CollectionContainsConstraint checking for the + presence of a particular object in the collection. + + + + + Returns a ConstraintExpression that negates any + following constraint. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them succeed. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if at least one of them succeeds. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them fail. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the Length property of the object being tested. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the Count property of the object being tested. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the Message property of the object being tested. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the InnerException property of the object being tested. + + + + + Interface implemented by a user fixture in order to + validate any expected exceptions. It is only called + for test methods marked with the ExpectedException + attribute. + + + + + Method to handle an expected exception + + The exception to be handled + + + + Helper class with properties and methods that supply + a number of constraints used in Asserts. + + + + + Returns a constraint that tests two items for equality + + + + + Returns a constraint that tests that two references are the same object + + + + + Returns a constraint that tests whether the + actual value is greater than the suppled argument + + + + + Returns a constraint that tests whether the + actual value is greater than or equal to the suppled argument + + + + + Returns a constraint that tests whether the + actual value is greater than or equal to the suppled argument + + + + + Returns a constraint that tests whether the + actual value is less than the suppled argument + + + + + Returns a constraint that tests whether the + actual value is less than or equal to the suppled argument + + + + + Returns a constraint that tests whether the + actual value is less than or equal to the suppled argument + + + + + Returns a constraint that tests whether the actual + value is of the exact type supplied as an argument. + + + + + Returns a constraint that tests whether the actual + value is of the exact type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is a collection containing the same elements as the + collection supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is a subset of the collection supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value contains the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value starts with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value ends with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value matches the Regex pattern supplied as an argument. + + + + + Returns a constraint that tests whether the path provided + is the same as an expected path after canonicalization. + + + + + Returns a constraint that tests whether the path provided + is the same path or under an expected path after canonicalization. + + + + + Returns a constraint that tests whether the path provided + is the same path or under an expected path after canonicalization. + + + + + Returns a constraint that tests whether the actual value falls + within a specified range. + + + + + Returns a ConstraintExpression that negates any + following constraint. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them succeed. + + + + + Returns a constraint that tests for null + + + + + Returns a constraint that tests for True + + + + + Returns a constraint that tests for False + + + + + Returns a constraint that tests for NaN + + + + + Returns a constraint that tests for empty + + + + + Returns a constraint that tests whether a collection + contains all unique items. + + + + + Returns a constraint that tests whether an object graph is serializable in binary format. + + + + + Returns a constraint that tests whether an object graph is serializable in xml format. + + + + + Returns a constraint that tests whether a collection is ordered + + + + + The Iz class is a synonym for Is intended for use in VB, + which regards Is as a keyword. + + + + + The List class is a helper class with properties and methods + that supply a number of constraints used with lists and collections. + + + + + List.Map returns a ListMapper, which can be used to map + the original collection to another collection. + + + + + + + ListMapper is used to transform a collection used as an actual argument + producing another collection to be used in the assertion. + + + + + Construct a ListMapper based on a collection + + The collection to be transformed + + + + Produces a collection containing all the values of a property + + The collection of property values + + + + + Randomizer returns a set of random values in a repeatable + way, to allow re-running of tests if necessary. + + + + + Get a randomizer for a particular member, returning + one that has already been created if it exists. + This ensures that the same values are generated + each time the tests are reloaded. + + + + + Get a randomizer for a particular parameter, returning + one that has already been created if it exists. + This ensures that the same values are generated + each time the tests are reloaded. + + + + + Construct a randomizer using a random seed + + + + + Construct a randomizer using a specified seed + + + + + Return an array of random doubles between 0.0 and 1.0. + + + + + + + Return an array of random doubles with values in a specified range. + + + + + Return an array of random ints with values in a specified range. + + + + + Get a random seed for use in creating a randomizer. + + + + + The SpecialValue enum is used to represent TestCase arguments + that cannot be used as arguments to an Attribute. + + + + + Null represents a null value, which cannot be used as an + argument to an attriute under .NET 1.x + + + + + Basic Asserts on strings. + + + + + The Equals method throws an AssertionException. This is done + to make sure there is no mistake by calling this function. + + + + + + + override the default ReferenceEquals to throw an AssertionException. This + implementation makes sure there is no mistake in calling this function + as part of Assert. + + + + + + + Asserts that a string is found within another string. + + The expected string + The string to be examined + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that a string is found within another string. + + The expected string + The string to be examined + The message to display in case of failure + + + + Asserts that a string is found within another string. + + The expected string + The string to be examined + + + + Asserts that a string is not found within another string. + + The expected string + The string to be examined + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that a string is found within another string. + + The expected string + The string to be examined + The message to display in case of failure + + + + Asserts that a string is found within another string. + + The expected string + The string to be examined + + + + Asserts that a string starts with another string. + + The expected string + The string to be examined + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that a string starts with another string. + + The expected string + The string to be examined + The message to display in case of failure + + + + Asserts that a string starts with another string. + + The expected string + The string to be examined + + + + Asserts that a string does not start with another string. + + The expected string + The string to be examined + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that a string does not start with another string. + + The expected string + The string to be examined + The message to display in case of failure + + + + Asserts that a string does not start with another string. + + The expected string + The string to be examined + + + + Asserts that a string ends with another string. + + The expected string + The string to be examined + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that a string ends with another string. + + The expected string + The string to be examined + The message to display in case of failure + + + + Asserts that a string ends with another string. + + The expected string + The string to be examined + + + + Asserts that a string does not end with another string. + + The expected string + The string to be examined + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that a string does not end with another string. + + The expected string + The string to be examined + The message to display in case of failure + + + + Asserts that a string does not end with another string. + + The expected string + The string to be examined + + + + Asserts that two strings are equal, without regard to case. + + The expected string + The actual string + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that two strings are equal, without regard to case. + + The expected string + The actual string + The message to display in case of failure + + + + Asserts that two strings are equal, without regard to case. + + The expected string + The actual string + + + + Asserts that two strings are not equal, without regard to case. + + The expected string + The actual string + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that two strings are Notequal, without regard to case. + + The expected string + The actual string + The message to display in case of failure + + + + Asserts that two strings are not equal, without regard to case. + + The expected string + The actual string + + + + Asserts that a string matches an expected regular expression pattern. + + The regex pattern to be matched + The actual string + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that a string matches an expected regular expression pattern. + + The regex pattern to be matched + The actual string + The message to display in case of failure + + + + Asserts that a string matches an expected regular expression pattern. + + The regex pattern to be matched + The actual string + + + + Asserts that a string does not match an expected regular expression pattern. + + The regex pattern to be used + The actual string + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that a string does not match an expected regular expression pattern. + + The regex pattern to be used + The actual string + The message to display in case of failure + + + + Asserts that a string does not match an expected regular expression pattern. + + The regex pattern to be used + The actual string + + + + The TestCaseData class represents a set of arguments + and other parameter info to be used for a parameterized + test case. It provides a number of instance modifiers + for use in initializing the test case. + + Note: Instance modifiers are getters that return + the same instance after modifying it's state. + + + + + The argument list to be provided to the test + + + + + The expected result to be returned + + + + + 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 + + + + + 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. + + + + + Gets the argument list to be provided to the test + + + + + Gets the expected result + + + + + 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 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 + + + + + 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. + + + + + TestAdapter adapts a Test for consumption by + the user test code. + + + + + 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 TestResult + + The TestResult to be adapted + + + + 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. + + + + + The ResultState enum indicates the result of running a test + + + + + The result is inconclusive + + + + + The test was not runnable. + + + + + The test has been skipped. + + + + + The test has been ignored. + + + + + The test succeeded + + + + + The test failed + + + + + The test encountered an unexpected exception + + + + + The test was cancelled by the user + + + + + The TestStatus enum indicates the result of running a test + + + + + The test was inconclusive + + + + + The test has skipped + + + + + The test succeeded + + + + + The test failed + + + + + Helper class with static methods used to supply constraints + that operate on strings. + + + + + Returns a constraint that succeeds if the actual + value contains the substring supplied as an argument. + + + + + Returns a constraint that fails if the actual + value contains the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value starts with the substring supplied as an argument. + + + + + Returns a constraint that fails if the actual + value starts with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value ends with the substring supplied as an argument. + + + + + Returns a constraint that fails if the actual + value ends with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value matches the Regex pattern supplied as an argument. + + + + + Returns a constraint that fails if the actual + value matches the pattern supplied as an argument. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them succeed. + + + + + TextMessageWriter writes constraint descriptions and messages + in displayable form as a text stream. It tailors the display + of individual message components to form the standard message + format of NUnit assertion failure messages. + + + + + Prefix used for the expected value line of a message + + + + + Prefix used for the actual value line of a message + + + + + Length of a message prefix + + + + + Construct a TextMessageWriter + + + + + Construct a TextMessageWriter, specifying a user message + and optional formatting arguments. + + + + + + + Method to write single line message with optional args, usually + written to precede the general failure message, at a givel + indentation level. + + The indentation level of the message + The message to be written + Any arguments used in formatting the message + + + + Display Expected and Actual lines for a constraint. This + is called by MessageWriter's default implementation of + WriteMessageTo and provides the generic two-line display. + + The constraint that failed + + + + Display Expected and Actual lines for given values. This + method may be called by constraints that need more control over + the display of actual and expected values than is provided + by the default implementation. + + The expected value + The actual value causing the failure + + + + Display Expected and Actual lines for given values, including + a tolerance value on the expected line. + + The expected value + The actual value causing the failure + The tolerance within which the test was made + + + + Display the expected and actual string values on separate lines. + If the mismatch parameter is >=0, an additional line is displayed + line containing a caret that points to the mismatch point. + + The expected string value + The actual string value + The point at which the strings don't match or -1 + If true, case is ignored in string comparisons + If true, clip the strings to fit the max line length + + + + Writes the text for a connector. + + The connector. + + + + Writes the text for a predicate. + + The predicate. + + + + Write the text for a modifier. + + The modifier. + + + + Writes the text for an expected value. + + The expected value. + + + + Writes the text for an actual value. + + The actual value. + + + + Writes the text for a generalized value. + + The value. + + + + Writes the text for a collection value, + starting at a particular point, to a max length + + The collection containing elements to write. + The starting point of the elements to write + The maximum number of elements to write + + + + Write the generic 'Expected' line for a constraint + + The constraint that failed + + + + Write the generic 'Expected' line for a given value + + The expected value + + + + Write the generic 'Expected' line for a given value + and tolerance. + + The expected value + The tolerance within which the test was made + + + + Write the generic 'Actual' line for a constraint + + The constraint for which the actual value is to be written + + + + Write the generic 'Actual' line for a given value + + The actual value causing a failure + + + + Gets or sets the maximum line length for this writer + + + + + Helper class with properties and methods that supply + constraints that operate on exceptions. + + + + + Creates a constraint specifying the exact type of exception expected + + + + + Creates a constraint specifying the exact type of exception expected + + + + + Creates a constraint specifying the type of exception expected + + + + + Creates a constraint specifying the type of exception expected + + + + + Creates a constraint specifying an expected exception + + + + + Creates a constraint specifying an exception with a given InnerException + + + + + Creates a constraint specifying an expected TargetInvocationException + + + + + Creates a constraint specifying an expected TargetInvocationException + + + + + Creates a constraint specifying an expected TargetInvocationException + + + + + Creates a constraint specifying that no exception is thrown + + + + diff --git a/lib/NUnit-2.5.8/nunit.mocks.dll b/lib/NUnit-2.5.8/nunit.mocks.dll new file mode 100644 index 0000000000000000000000000000000000000000..759b5e6389140bf4596c68c227aa267e748e96ed GIT binary patch literal 20480 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 s`|Fs4e9ZX_t<8 literal 0 HcmV?d00001 diff --git a/lib/NUnit-2.5.8/pnunit.framework.dll b/lib/NUnit-2.5.8/pnunit.framework.dll new file mode 100644 index 0000000000000000000000000000000000000000..0a01a33893d3cc9ca0dc7e312f80f7611d17affc GIT binary patch literal 6656 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 +// Math.NET Numerics, part of the Math.NET Project +// http://numerics.mathdotnet.com +// http://github.com/mathnet/mathnet-numerics +// http://mathnetnumerics.codeplex.com +// +// Copyright (c) 2009-2010 Math.NET +// +// Permission is hereby granted, free of charge, to any person +// obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without +// restriction, including without limitation the rights to use, +// copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following +// conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// + +namespace MathNet.Numerics.UnitTests +{ + using System.Collections.Generic; + using System.Numerics; + using NUnit.Framework; + + /// + /// A class which includes some assertion helper methods particularly for numerical code. + /// + internal class AssertHelpers + { + /// + /// Asserts that the expected value and the actual value are equal. + /// + /// The expected value. + /// The actual value. + public static void AreEqual(Complex expected, Complex actual) + { + if (expected.IsNaN() && actual.IsNaN()) + { + return; + } + + if (expected.IsInfinity() && expected.IsInfinity()) + { + return; + } + + bool pass = expected.Real.AlmostEqual(actual.Real); + if (!pass) + { + Assert.Fail("Real components are not equal. Expected:{0}; Actual:{1}", expected.Real, actual.Real); + } + + pass = expected.Imaginary.AlmostEqual(actual.Imaginary); + if (!pass) + { + Assert.Fail("Imaginary components are not equal. Expected:{0}; Actual:{1}", expected.Imaginary, actual.Imaginary); + } + } + + /// + /// Asserts that the expected value and the actual value are equal. + /// + /// The expected value. + /// The actual value. + public static void AreEqual(Complex32 expected, Complex32 actual) + { + if (expected.IsNaN() && actual.IsNaN()) + { + return; + } + + if (expected.IsInfinity() && expected.IsInfinity()) + { + return; + } + + bool pass = expected.Real.AlmostEqual(actual.Real); + if (!pass) + { + Assert.Fail("Real components are not equal. Expected:{0}; Actual:{1}", expected.Real, actual.Real); + } + + pass = expected.Imaginary.AlmostEqual(actual.Imaginary); + if (!pass) + { + Assert.Fail("Imaginary components are not equal. Expected:{0}; Actual:{1}", expected.Imaginary, actual.Imaginary); + } + } + + /// + /// Asserts that the expected value and the actual value are equal up to a certain number of decimal places. If both + /// and are NaN then no assert is thrown. + /// + /// The expected value. + /// The actual value. + /// The number of decimal places to agree on. + public static void AlmostEqual(double expected, double actual, int decimalPlaces) + { + if (double.IsNaN(expected) && double.IsNaN(actual)) + { + return; + } + + bool pass = expected.AlmostEqualInDecimalPlaces(actual, decimalPlaces); + if (!pass) + { + // signals Gallio that the test failed. + Assert.Fail("Not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected, actual); + } + } + + /// + /// Asserts that the expected value and the actual value are equal up to a certain number of decimal places. If both + /// and are NaN then no assert is thrown. + /// + /// The expected value. + /// The actual value. + /// The number of decimal places to agree on. + public static void AlmostEqual(float expected, float actual, int decimalPlaces) + { + if (float.IsNaN(expected) && float.IsNaN(actual)) + { + return; + } + + bool pass = expected.AlmostEqualInDecimalPlaces(actual, decimalPlaces); + if (!pass) + { + // signals Gallio that the test failed. + Assert.Fail("Not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected, actual); + } + } + + /// + /// Asserts that the expected value and the actual value are equal up to a certain number of decimal places. + /// + /// The expected value. + /// The actual value. + /// The number of decimal places to agree on. + public static void AlmostEqual(Complex expected, Complex actual, int decimalPlaces) + { + bool pass = expected.Real.AlmostEqualInDecimalPlaces(actual.Real, decimalPlaces); + if (!pass) + { + Assert.Fail("Real components are not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected.Real, actual.Real); + } + + pass = expected.Imaginary.AlmostEqualInDecimalPlaces(actual.Imaginary, decimalPlaces); + if (!pass) + { + Assert.Fail("Imaginary components are not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected.Imaginary, actual.Imaginary); + } + } + + /// + /// Asserts that the expected value and the actual value are equal up to a certain number of decimal places. + /// + /// The expected value. + /// The actual value. + /// The number of decimal places to agree on. + public static void AlmostEqual(Complex32 expected, Complex32 actual, int decimalPlaces) + { + bool pass = expected.Real.AlmostEqualInDecimalPlaces(actual.Real, decimalPlaces); + if (!pass) + { + Assert.Fail("Real components are not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected.Real, actual.Real); + } + + pass = expected.Imaginary.AlmostEqualInDecimalPlaces(actual.Imaginary, decimalPlaces); + if (!pass) + { + Assert.Fail("Imaginary components are not equal within {0} places. Expected:{1}; Actual:{2}", decimalPlaces, expected.Imaginary, actual.Imaginary); + } + } + + /// + /// Asserts that the expected value and the actual value are equal up to a certain + /// maximum error. + /// + /// The type of the structures. Must implement + /// . + /// The expected value. + /// The actual value. + /// The accuracy required for being almost equal. + public static void AlmostEqual(T expected, T actual, double maximumError) + where T : IPrecisionSupport + { + if (!actual.AlmostEqualWithError(expected, maximumError)) + { + Assert.Fail("Not equal within a maximum error {0}. Expected:{1}; Actual:{2}", maximumError, expected, actual); + } + } + + /// + /// Asserts that the expected value and the actual value are equal up to a certain + /// maximum error. + /// + /// The expected value list. + /// The actual value list. + /// The accuracy required for being almost equal. + public static void AlmostEqualList(IList expected, IList actual, double maximumError) + { + for (int i = 0; i < expected.Count; i++) + { + if (!actual[i].AlmostEqualWithError(expected[i], maximumError)) + { + Assert.Fail("Not equal within a maximum error {0}. Expected:{1}; Actual:{2}", maximumError, expected[i], actual[i]); + } + } + } + + /// + /// Asserts that the expected value and the actual value are equal up to a certain + /// maximum error. + /// + /// The expected value list. + /// The actual value list. + /// The accuracy required for being almost equal. + public static void AlmostEqualList(IList expected, IList actual, double maximumError) + { + for (int i = 0; i < expected.Count; i++) + { + if (!actual[i].AlmostEqualWithError(expected[i], maximumError)) + { + Assert.Fail("Not equal within a maximum error {0}. Expected:{1}; Actual:{2}", maximumError, expected[i], actual[i]); + } + } + } + + /// + /// Asserts that the expected value and the actual value are equal up to a certain + /// maximum error. + /// + /// The type of the structures. Must implement + /// . + /// The expected value list. + /// The actual value list. + /// The accuracy required for being almost equal. + public static void AlmostEqualList(IList expected, IList actual, double maximumError) + where T : IPrecisionSupport + { + for (int i = 0; i < expected.Count; i++) + { + if (!actual[i].AlmostEqualWithError(expected[i], maximumError)) + { + Assert.Fail("Not equal within a maximum error {0}. Expected:{1}; Actual:{2}", maximumError, expected[i], actual[i]); + } + } + } + + /// + /// Asserts that the expected value and the actual value are equal up to a certain + /// maximum error. + /// + /// The expected value list. + /// The actual value list. + /// The accuracy required for being almost equal. + public static void AlmostEqualList(IList expected, IList actual, double maximumError) + { + for (int i = 0; i < expected.Count; i++) + { + if (!actual[i].AlmostEqualWithError(expected[i], maximumError)) + { + Assert.Fail("Not equal within a maximum error {0}. Expected:{1}; Actual:{2}", maximumError, expected[i], actual[i]); + } + } + } + } +} diff --git a/src/NUnitTests/LinearAlgebraProviderTests/Double/LinearAlgebraProviderTests.cs b/src/NUnitTests/LinearAlgebraProviderTests/Double/LinearAlgebraProviderTests.cs new file mode 100644 index 00000000..c737c0a2 --- /dev/null +++ b/src/NUnitTests/LinearAlgebraProviderTests/Double/LinearAlgebraProviderTests.cs @@ -0,0 +1,439 @@ +// +// Math.NET Numerics, part of the Math.NET Project +// http://numerics.mathdotnet.com +// http://github.com/mathnet/mathnet-numerics +// http://mathnetnumerics.codeplex.com +// +// Copyright (c) 2009-2010 Math.NET +// +// Permission is hereby granted, free of charge, to any person +// obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without +// restriction, including without limitation the rights to use, +// copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following +// conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +// +namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double +{ + using System; + using System.Collections.Generic; + using Algorithms.LinearAlgebra; + using LinearAlgebra.Double; + using NUnit.Framework; + + /// + /// Base class for linear algebra provider tests. + /// + [TestFixture] + public class LinearAlgebraProviderTests + { + /// + /// Initializes a new instance of the class. + /// + public LinearAlgebraProviderTests() + { + Provider = new ManagedLinearAlgebraProvider(); + } + + /// + /// Gets or sets linear algebra provider to test. + /// + protected ILinearAlgebraProvider Provider + { + get; + set; + } + + /// + /// The Y double test vector. + /// + private readonly double[] _y = new[] { 1.1, 2.2, 3.3, 4.4, 5.5 }; + + /// + /// The X double test vector. + /// + private readonly double[] _x = new[] { 6.6, 7.7, 8.8, 9.9, 10.1 }; + + /// + /// Test matrix to use. + /// + private readonly IDictionary _matrices = new Dictionary + { + { "Singular3x3", new DenseMatrix(new[,] { { 1.0, 1.0, 2.0 }, { 1.0, 1.0, 2.0 }, { 1.0, 1.0, 2.0 } }) }, + { "Square3x3", new DenseMatrix(new[,] { { -1.1, -2.2, -3.3 }, { 0.0, 1.1, 2.2 }, { -4.4, 5.5, 6.6 } }) }, + { "Square4x4", new DenseMatrix(new[,] { { -1.1, -2.2, -3.3, -4.4 }, { 0.0, 1.1, 2.2, 3.3 }, { 1.0, 2.1, 6.2, 4.3 }, { -4.4, 5.5, 6.6, -7.7 } }) }, + { "Singular4x4", new DenseMatrix(new[,] { { -1.1, -2.2, -3.3, -4.4 }, { -1.1, -2.2, -3.3, -4.4 }, { -1.1, -2.2, -3.3, -4.4 }, { -1.1, -2.2, -3.3, -4.4 } }) }, + { "Tall3x2", new DenseMatrix(new[,] { { -1.1, -2.2 }, { 0.0, 1.1 }, { -4.4, 5.5 } }) }, + { "Wide2x3", new DenseMatrix(new[,] { { -1.1, -2.2, -3.3 }, { 0.0, 1.1, 2.2 } }) } + }; + + /// + /// Can add a vector to scaled vector + /// + [Test] + public void CanAddVectorToScaledVectorDouble() + { + var result = new double[_y.Length]; + Array.Copy(_y, result, _y.Length); + + Provider.AddVectorToScaledVector(result, 0, _x); + for (var i = 0; i < _y.Length; i++) + { + Assert.AreEqual(_y[i], result[i]); + } + + Array.Copy(_y, result, _y.Length); + Provider.AddVectorToScaledVector(result, 1, _x); + for (var i = 0; i < _y.Length; i++) + { + Assert.AreEqual(_y[i] + _x[i], result[i]); + } + + Array.Copy(_y, result, _y.Length); + Provider.AddVectorToScaledVector(result, Math.PI, _x); + for (var i = 0; i < _y.Length; i++) + { + Assert.AreEqual(_y[i] + (Math.PI * _x[i]), result[i]); + } + } + + /// + /// Can scale an array. + /// + [Test] + public void CanScaleArray() + { + var result = new double[_y.Length]; + + Array.Copy(_y, result, _y.Length); + Provider.ScaleArray(1, result); + for (var i = 0; i < _y.Length; i++) + { + Assert.AreEqual(_y[i], result[i]); + } + + Array.Copy(_y, result, _y.Length); + Provider.ScaleArray(Math.PI, result); + for (var i = 0; i < _y.Length; i++) + { + Assert.AreEqual(_y[i] * Math.PI, result[i]); + } + } + + /// + /// Can compute the dot product. + /// + [Test] + public void CanComputeDotProduct() + { + var result = Provider.DotProduct(_x, _y); + AssertHelpers.AlmostEqual(152.35, result, 15); + } + + /// + /// Can add two arrays. + /// + [Test] + public void CanAddArrays() + { + var result = new double[_y.Length]; + Provider.AddArrays(_x, _y, result); + for (var i = 0; i < result.Length; i++) + { + Assert.AreEqual(_x[i] + _y[i], result[i]); + } + } + + /// + /// Can subtract two arrays. + /// + [Test] + public void CanSubtractArrays() + { + var result = new double[_y.Length]; + Provider.SubtractArrays(_x, _y, result); + for (var i = 0; i < result.Length; i++) + { + Assert.AreEqual(_x[i] - _y[i], result[i]); + } + } + + /// + /// Can pointwise multiply two arrays. + /// + [Test] + public void CanPointWiseMultiplyArrays() + { + var result = new double[_y.Length]; + Provider.PointWiseMultiplyArrays(_x, _y, result); + for (var i = 0; i < result.Length; i++) + { + Assert.AreEqual(_x[i] * _y[i], result[i]); + } + } + + /// + /// Can compute L1 norm. + /// + [Test] + public void CanComputeMatrixL1Norm() + { + var matrix = _matrices["Square3x3"]; + var work = new double[matrix.RowCount]; + var norm = Provider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data, work); + AssertHelpers.AlmostEqual(12.1, norm, 6); + } + + /// + /// Can compute Frobenius norm. + /// + [Test] + public void CanComputeMatrixFrobeniusNorm() + { + var matrix = _matrices["Square3x3"]; + var work = new double[matrix.RowCount]; + var norm = Provider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data, work); + AssertHelpers.AlmostEqual(10.777754868246, norm, 8); + } + + /// + /// Can compute Infinity norm. + /// + [Test] + public void CanComputeMatrixInfinityNorm() + { + var matrix = _matrices["Square3x3"]; + var work = new double[matrix.RowCount]; + var norm = Provider.MatrixNorm(Norm.InfinityNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data, work); + Assert.AreEqual(16.5, norm); + } + + /// + /// Can compute L1 norm using a work array. + /// + [Test] + public void CanComputeMatrixL1NormWithWorkArray() + { + var matrix = _matrices["Square3x3"]; + var norm = Provider.MatrixNorm(Norm.OneNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data); + AssertHelpers.AlmostEqual(12.1, norm, 6); + } + + /// + /// Can compute Frobenius norm using a work array. + /// + [Test] + public void CanComputeMatrixFrobeniusNormWithWorkArray() + { + var matrix = _matrices["Square3x3"]; + var norm = Provider.MatrixNorm(Norm.FrobeniusNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data); + AssertHelpers.AlmostEqual(10.777754868246, norm, 8); + } + + /// + /// Can compute Infinity norm using a work array. + /// + [Test] + public void CanComputeMatrixInfinityNormWithWorkArray() + { + var matrix = _matrices["Square3x3"]; + var norm = Provider.MatrixNorm(Norm.InfinityNorm, matrix.RowCount, matrix.ColumnCount, matrix.Data); + Assert.AreEqual(16.5, norm); + } + + /// + /// Can multiply two square matrices. + /// + [Test] + public void CanMultiplySquareMatrices() + { + var x = _matrices["Singular3x3"]; + var y = _matrices["Square3x3"]; + var c = new DenseMatrix(x.RowCount, y.ColumnCount); + + Provider.MatrixMultiply(x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, c.Data); + + for (var i = 0; i < c.RowCount; i++) + { + for (var j = 0; j < c.ColumnCount; j++) + { + AssertHelpers.AlmostEqual(x.Row(i) * y.Column(j), c[i, j], 15); + } + } + } + + /// + /// Can multiply a wide and tall matrix. + /// + [Test] + public void CanMultiplyWideAndTallMatrices() + { + var x = _matrices["Wide2x3"]; + var y = _matrices["Tall3x2"]; + var c = new DenseMatrix(x.RowCount, y.ColumnCount); + + Provider.MatrixMultiply(x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, c.Data); + + for (var i = 0; i < c.RowCount; i++) + { + for (var j = 0; j < c.ColumnCount; j++) + { + AssertHelpers.AlmostEqual(x.Row(i) * y.Column(j), c[i, j], 15); + } + } + } + + /// + /// Can multiply a tall and wide matrix. + /// + [Test] + public void CanMultiplyTallAndWideMatrices() + { + var x = _matrices["Tall3x2"]; + var y = _matrices["Wide2x3"]; + var c = new DenseMatrix(x.RowCount, y.ColumnCount); + + Provider.MatrixMultiply(x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, c.Data); + + for (var i = 0; i < c.RowCount; i++) + { + for (var j = 0; j < c.ColumnCount; j++) + { + AssertHelpers.AlmostEqual(x.Row(i) * y.Column(j), c[i, j], 15); + } + } + } + + /// + /// Can multiply two square matrices. + /// + [Test] + public void CanMultiplySquareMatricesWithUpdate() + { + var x = _matrices["Singular3x3"]; + var y = _matrices["Square3x3"]; + var c = new DenseMatrix(x.RowCount, y.ColumnCount); + + Provider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2, x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, 1.0, c.Data); + + for (var i = 0; i < c.RowCount; i++) + { + for (var j = 0; j < c.ColumnCount; j++) + { + AssertHelpers.AlmostEqual(2.2 * x.Row(i) * y.Column(j), c[i, j], 15); + } + } + } + + /// + /// Can multiply a wide and tall matrix. + /// + [Test] + public void CanMultiplyWideAndTallMatricesWithUpdate() + { + var x = _matrices["Wide2x3"]; + var y = _matrices["Tall3x2"]; + var c = new DenseMatrix(x.RowCount, y.ColumnCount); + + Provider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2, x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, 1.0, c.Data); + + for (var i = 0; i < c.RowCount; i++) + { + for (var j = 0; j < c.ColumnCount; j++) + { + AssertHelpers.AlmostEqual(2.2 * x.Row(i) * y.Column(j), c[i, j], 15); + } + } + } + + /// + /// Can multiply a tall and wide matrix. + /// + [Test] + public void CanMultiplyTallAndWideMatricesWithUpdate() + { + var x = _matrices["Tall3x2"]; + var y = _matrices["Wide2x3"]; + var c = new DenseMatrix(x.RowCount, y.ColumnCount); + + Provider.MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, 2.2, x.Data, x.RowCount, x.ColumnCount, y.Data, y.RowCount, y.ColumnCount, 1.0, c.Data); + + for (var i = 0; i < c.RowCount; i++) + { + for (var j = 0; j < c.ColumnCount; j++) + { + AssertHelpers.AlmostEqual(2.2 * x.Row(i) * y.Column(j), c[i, j], 15); + } + } + } + + /// + /// Can compute the Cholesky factorization. + /// + [Test] + public void CanComputeCholeskyFactor() + { + var matrix = new double[] { 1, 1, 1, 1, 1, 5, 5, 5, 1, 5, 14, 14, 1, 5, 14, 15 }; + Provider.CholeskyFactor(matrix, 4); + Assert.AreEqual(matrix[0], 1); + Assert.AreEqual(matrix[1], 1); + Assert.AreEqual(matrix[2], 1); + Assert.AreEqual(matrix[3], 1); + Assert.AreEqual(matrix[4], 0); + Assert.AreEqual(matrix[5], 2); + Assert.AreEqual(matrix[6], 2); + Assert.AreEqual(matrix[7], 2); + Assert.AreEqual(matrix[8], 0); + Assert.AreEqual(matrix[9], 0); + Assert.AreEqual(matrix[10], 3); + Assert.AreEqual(matrix[11], 3); + Assert.AreEqual(matrix[12], 0); + Assert.AreEqual(matrix[13], 0); + Assert.AreEqual(matrix[14], 0); + Assert.AreEqual(matrix[15], 1); + } + + /// + /// Can compute the LU factor of a matrix. + /// + [Test] + public void CanComputeLuFactor() + { + var matrix = _matrices["Square3x3"]; + var a = new double[matrix.RowCount * matrix.RowCount]; + Array.Copy(matrix.Data, a, a.Length); + + var ipiv = new int[matrix.RowCount]; + + Provider.LUFactor(a, matrix.RowCount, ipiv); + + AssertHelpers.AlmostEqual(a[0], -4.4, 15); + AssertHelpers.AlmostEqual(a[1], 0.25, 15); + AssertHelpers.AlmostEqual(a[2], 0, 15); + AssertHelpers.AlmostEqual(a[3], 5.5, 15); + AssertHelpers.AlmostEqual(a[4], -3.575, 15); + AssertHelpers.AlmostEqual(a[5], -0.307692307692308, 15); + AssertHelpers.AlmostEqual(a[6], 6.6, 15); + AssertHelpers.AlmostEqual(a[7], -4.95, 15); + AssertHelpers.AlmostEqual(a[8], 0.676923076923077, 15); + + Assert.AreEqual(ipiv[0], 2); + Assert.AreEqual(ipiv[1], 2); + Assert.AreEqual(ipiv[2], 2); + } + } +} \ No newline at end of file diff --git a/src/NUnitTests/NUnitTests.csproj b/src/NUnitTests/NUnitTests.csproj new file mode 100644 index 00000000..83129b7e --- /dev/null +++ b/src/NUnitTests/NUnitTests.csproj @@ -0,0 +1,65 @@ + + + + Debug + AnyCPU + 8.0.30703 + 2.0 + {DAF07AA8-C5C9-4963-98F7-2C3285064DAD} + Library + Properties + MathNet.Numerics.UnitTests + MathNet.Numerics.UnitTests + v4.0 + 512 + + + true + full + false + ..\..\out\test\debug\Net40\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + ..\..\lib\NUnit-2.5.8\nunit.framework.dll + + + + + + + + + + + + + + + + + + {B7CAE5F4-A23F-4438-B5BE-41226618B695} + Numerics + + + + + \ No newline at end of file diff --git a/src/NUnitTests/Properties/AssemblyInfo.cs b/src/NUnitTests/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..e0256c79 --- /dev/null +++ b/src/NUnitTests/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("NUnitTests")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("Microsoft")] +[assembly: AssemblyProduct("NUnitTests")] +[assembly: AssemblyCopyright("Copyright © Microsoft 2010")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("04157581-63f3-447b-a277-83c6e69126a4")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")]