# SyntaxElements.txt
#
# This file is used to control generation of certain source files
# in the NUnit framework, so that all overloads are defined
# consistently.
#
# The file is organized in stanzas, seperated by a line containing
# only a percent sign (%) in the first column. By convention, the
# first stanza consists only of defaults, while the remaining
# stanzas generate code for one or more classes.
#
# Within a stanza, individual lines are recognized by a prefix
# and lines not starting with a recognized prefix will cause an 
# exception. With the exception of # and /// all prefixes are
# terminated by a colon.
#
# NOTE: Lines beginning with whitespace are treated as a
# continuation of the preceding line.
# 
# Prefix '#' introduces a comment. Use an otherwise blank line 
#   starting with '#' for spacing, if desired.
#
# Prefix 'Default:' indicates a default option using the same
#   format as the -gen option on the commandline. Defaults are
#   only used if no -gen options are provided.
#
# Prefix '///' introduces a comment to be included in the
#   generated source code. Each stanza contains a single block
#   of comments, conventionally placed at the beginning of
#   the stanza. All methods generated from a stanza use
#   the same comment. 
#
# Prefix 'Type:' may appear once in each stanza and indicates
#   the return type of the methods defined in the stanza. If
#   it is not specified, all methods default to 'void'.
#
# Prefix 'Gen:' introduces a method or property definition.
#   The format of the line is as follows:
#     'Gen:' [attributes]...signature=>definition
#   where 
#     [attributes] represents any attributes to be placed on the
#        method. It is optional and may be repeated.
#      signature is the method signature, including the class
#        name and arguments.
#      definition is the code for the method
#
#   The code generator distinguishes methods from properties
#   and generates the necessary get {...} sequence in the 
#   latter case. Note that only getters are generated. If
#   the method signature uses generics, the entire definition
#   is enclosed in an #if NET_2_0 ... #endif sequence.
#
#   If the class name in a method signature is 'Assert' the
#   code generator creates multiple overloads of the method,
#   allowing for provision of an optional message and args.
#
# Prefix 'Gen3' causes the code generator to create code
#   in three classes: a static helper class specified in
#   the signature, the ConstraintFactory class and the
#   ConstraintExpression class. These three classes are
#   used by the NUnit fluent syntax. The code after the
#   arrow (=>) is used in all three definitions.
#
# You may browse the remainder of this file for examples
# of use of each prefix.
#
#
#
# Define default classes to be generated:
#
Default: Is
Default: Has
Default: Text
Default: Throws
Default: ConstraintFactory=Constraints/ConstraintFactory.cs
Default: ConstraintExpression=Constraints/ConstraintExpression.cs
Default: Assert
%
#
# Prefix Operators
#
/// <summary>
/// Returns a ConstraintExpression that negates any
/// following constraint.
/// </summary>
Type: ConstraintExpression
Gen: Is.Not=>new ConstraintExpression().Not
Gen: Has.No=>new ConstraintExpression().Not
Gen: ConstraintFactory.Not=>Is.Not
Gen: ConstraintFactory.No=>Has.No
Gen: ConstraintExpression.Not=>this.Append(new NotOperator())
Gen: ConstraintExpression.No=>this.Append(new NotOperator())
%
/// <summary>
/// Returns a ConstraintExpression, which will apply
/// the following constraint to all members of a collection,
/// succeeding if all of them succeed.
/// </summary>
Type: ConstraintExpression
Gen: Is.All=>new ConstraintExpression().All
Gen: Has.All=>new ConstraintExpression().All
Gen: [Obsolete("Use Is.All")]Text.All=>new ConstraintExpression().All
Gen: ConstraintFactory.All=>Is.All
Gen: ConstraintExpression.All=>this.Append(new AllOperator())
%
/// <summary>
/// Returns a ConstraintExpression, which will apply
/// the following constraint to all members of a collection,
/// succeeding if at least one of them succeeds.
/// </summary>
Type: ConstraintExpression
Gen: Has.Some=>new ConstraintExpression().Some
Gen: ConstraintFactory.Some=>Has.Some
Gen: ConstraintExpression.Some=>this.Append(new SomeOperator())
%
/// <summary>
/// Returns a ConstraintExpression, which will apply
/// the following constraint to all members of a collection,
/// succeeding if all of them fail.
/// </summary>
Type: ConstraintExpression
Gen: Has.None=>new ConstraintExpression().None
Gen: ConstraintFactory.None=>Has.None
Gen: ConstraintExpression.None=>this.Append(new NoneOperator())
%
/// <summary>
/// Returns a new PropertyConstraintExpression, which will either
/// test for the existence of the named property on the object
/// being tested or apply any following constraint to that property.
/// </summary>
Type: ResolvableConstraintExpression
Gen: Has.Property(string name)=>new ConstraintExpression().Property(name)
Gen: ConstraintFactory.Property(string name)=>Has.Property(name)
Gen: ConstraintExpression.Property(string name)=>this.Append(new PropOperator(name))
%
/// <summary>
/// Returns a new ConstraintExpression, which will apply the following
/// constraint to the Length property of the object being tested.
/// </summary>
Type: ResolvableConstraintExpression
Gen: Has.Length=>Property("Length")
Gen: ConstraintFactory.Length=>Has.Length
Gen: ConstraintExpression.Length=>Property("Length")
%
/// <summary>
/// Returns a new ConstraintExpression, which will apply the following
/// constraint to the Count property of the object being tested.
/// </summary>
Type: ResolvableConstraintExpression
Gen: Has.Count=>Property("Count")
Gen: ConstraintFactory.Count=>Has.Count
Gen: ConstraintExpression.Count=>Property("Count")
%
/// <summary>
/// Returns a new ConstraintExpression, which will apply the following
/// constraint to the Message property of the object being tested.
/// </summary>
Type: ResolvableConstraintExpression
Gen: Has.Message=>Property("Message")
Gen: ConstraintFactory.Message=>Has.Message
Gen: ConstraintExpression.Message=>Property("Message")
%
/// <summary>
/// Returns a new ConstraintExpression, which will apply the following
/// constraint to the InnerException property of the object being tested.
/// </summary>
Type: ResolvableConstraintExpression
Gen: Has.InnerException=>Property("InnerException")
Gen: ConstraintFactory.InnerException=>Has.InnerException
Gen: ConstraintExpression.InnerException=>Property("InnerException")
%
/// <summary>
/// Returns a new AttributeConstraint checking for the
/// presence of a particular attribute on an object.
/// </summary>
Type: ResolvableConstraintExpression
Gen: Has.Attribute(Type expectedType)=>new ConstraintExpression().Attribute(expectedType)
Gen: Has.Attribute<T>()=>Attribute(typeof(T))
Gen: ConstraintFactory.Attribute(Type expectedType)=>Has.Attribute(expectedType)
Gen: ConstraintFactory.Attribute<T>()=>Attribute(typeof(T))
Gen: ConstraintExpression.Attribute(Type expectedType)=>this.Append(new AttributeOperator(expectedType))
Gen: ConstraintExpression.Attribute<T>()=>Attribute(typeof(T))
%
/// <summary>
/// Creates a constraint specifying an expected exception
/// </summary>
Type: ResolvableConstraintExpression
Gen: Throws.Exception=>new ConstraintExpression().Append(new ThrowsOperator())
%
/// <summary>
/// Creates a constraint specifying an exception with a given InnerException
/// </summary>
Type: ResolvableConstraintExpression
Gen: Throws.InnerException=> Exception.InnerException
%
/// <summary>
/// Creates a constraint specifying an expected TargetInvocationException
/// </summary>
Type: ExactTypeConstraint
Gen: Throws.TargetInvocationException=>TypeOf(typeof(System.Reflection.TargetInvocationException))
%
/// <summary>
/// Creates a constraint specifying an expected TargetInvocationException
/// </summary>
Type: ExactTypeConstraint
Gen: Throws.ArgumentException=>TypeOf(typeof(System.ArgumentException))
%
/// <summary>
/// Creates a constraint specifying an expected TargetInvocationException
/// </summary>
Type: ExactTypeConstraint
Gen: Throws.InvalidOperationException=>TypeOf(typeof(System.InvalidOperationException))
%
/// <summary>
/// Creates a constraint specifying that no exception is thrown
/// </summary>
Type: ThrowsNothingConstraint
Gen: Throws.Nothing=>new ThrowsNothingConstraint()
%
/// <summary>
/// Creates a constraint specifying the exact type of exception expected
/// </summary>
Type: ExactTypeConstraint
Gen: Throws.TypeOf(Type expectedType)=>Exception.TypeOf(expectedType)
Gen: Throws.TypeOf<T>()=>TypeOf(typeof(T))
%
/// <summary>
/// Creates a constraint specifying the type of exception expected
/// </summary>
Type: InstanceOfTypeConstraint
Gen: Throws.InstanceOf(Type expectedType)=>Exception.InstanceOf(expectedType)
Gen: Throws.InstanceOf<T>()=>InstanceOf(typeof(T))
%
/// <summary>
/// With is currently a NOP - reserved for future use.
/// </summary>
Type: ConstraintExpression
Gen: ConstraintExpression.With=>this.Append(new WithOperator())
%
/// <summary>
/// Returns the constraint provided as an argument - used to allow custom
/// custom constraints to easily participate in the syntax.
/// </summary>
Type: Constraint
Gen: ConstraintExpression.Matches(Constraint constraint)=>this.Append(constraint)
Gen: ConstraintExpression.Matches<T>(Predicate<T> predicate)=>this.Append(new PredicateConstraint<T>(predicate))
%
#
# Constraints Without Arguments
#
/// <summary>
/// Returns a constraint that tests for null
/// </summary>
Gen3: Is.Null=>new NullConstraint()
%
/// <summary>
/// Returns a constraint that tests for True
/// </summary>
Gen3: Is.True=>new TrueConstraint()
%
/// <summary>
/// Returns a constraint that tests for False
/// </summary>
Gen3: Is.False=>new FalseConstraint()
%
/// <summary>
/// Returns a constraint that tests for NaN
/// </summary>
Gen3: Is.NaN=>new NaNConstraint()
%
/// <summary>
/// Returns a constraint that tests for empty
/// </summary>
Gen3: Is.Empty=>new EmptyConstraint()
%
/// <summary>
/// Returns a constraint that tests whether a collection 
/// contains all unique items.
/// </summary>
Gen3: Is.Unique=>new UniqueItemsConstraint()
%
/// <summary>
/// Returns a constraint that tests whether an object graph is serializable in binary format.
/// </summary>
Gen3: Is.BinarySerializable=>new BinarySerializableConstraint()
%
/// <summary>
/// Returns a constraint that tests whether an object graph is serializable in xml format.
/// </summary>
Gen3: Is.XmlSerializable=>new XmlSerializableConstraint()
%
#
# Constraints Taking an Expected Value 
#
/// <summary>
/// Returns a constraint that tests two items for equality
/// </summary>
Gen3: Is.EqualTo(object expected)=>new EqualConstraint(expected)
%
/// <summary>
/// Returns a constraint that tests that two references are the same object
/// </summary>
Gen3: Is.SameAs(object expected)=>new SameAsConstraint(expected)
%
/// <summary>
/// Returns a constraint that tests whether the
/// actual value is greater than the suppled argument
/// </summary>
Gen3: Is.GreaterThan(object expected)=>new GreaterThanConstraint(expected)
%
/// <summary>
/// Returns a constraint that tests whether the
/// actual value is greater than or equal to the suppled argument
/// </summary>
Gen3: Is.GreaterThanOrEqualTo(object expected)=>new GreaterThanOrEqualConstraint(expected)
Gen3: Is.AtLeast(object expected)=>new GreaterThanOrEqualConstraint(expected)
%
/// <summary>
/// Returns a constraint that tests whether the
/// actual value is less than the suppled argument
/// </summary>
Gen3: Is.LessThan(object expected)=>new LessThanConstraint(expected)
%
/// <summary>
/// Returns a constraint that tests whether the
/// actual value is less than or equal to the suppled argument
/// </summary>
Gen3: Is.LessThanOrEqualTo(object expected)=>new LessThanOrEqualConstraint(expected)
Gen3: Is.AtMost(object expected)=>new LessThanOrEqualConstraint(expected)
%
/// <summary>
/// Returns a constraint that tests whether the actual
/// value is of the exact type supplied as an argument.
/// </summary>
Gen3: Is.TypeOf(Type expectedType)=>new ExactTypeConstraint(expectedType)
Gen3: Is.TypeOf<T>()=>new ExactTypeConstraint(typeof(T))
%
/// <summary>
/// Returns a constraint that tests whether the actual value
/// is of the type supplied as an argument or a derived type.
/// </summary>
Gen3: Is.InstanceOf(Type expectedType)=>new InstanceOfTypeConstraint(expectedType)
Gen3: Is.InstanceOf<T>()=>new InstanceOfTypeConstraint(typeof(T))
Gen3: [Obsolete("Use InstanceOf(expectedType)")]Is.InstanceOfType(Type expectedType)=>new InstanceOfTypeConstraint(expectedType)
Gen3: [Obsolete("Use InstanceOf<T>()")]Is.InstanceOfType<T>()=>new InstanceOfTypeConstraint(typeof(T))
%
/// <summary>
/// Returns a constraint that tests whether the actual value
/// is assignable from the type supplied as an argument.
/// </summary>
Gen3: Is.AssignableFrom(Type expectedType)=>new AssignableFromConstraint(expectedType)
Gen3: Is.AssignableFrom<T>()=>new AssignableFromConstraint(typeof(T))
%
/// <summary>
/// Returns a constraint that tests whether the actual value
/// is assignable from the type supplied as an argument.
/// </summary>
Gen3: Is.AssignableTo(Type expectedType)=>new AssignableToConstraint(expectedType)
Gen3: Is.AssignableTo<T>()=>new AssignableToConstraint(typeof(T))
%
/// <summary>
/// Returns a constraint that tests whether the actual value
/// is a collection containing the same elements as the 
/// collection supplied as an argument.
/// </summary>
Gen3: Is.EquivalentTo(IEnumerable expected)=>new CollectionEquivalentConstraint(expected)
%
/// <summary>
/// Returns a constraint that tests whether the actual value
/// is a subset of the collection supplied as an argument.
/// </summary>
Gen3: Is.SubsetOf(IEnumerable expected)=>new CollectionSubsetConstraint(expected)
%
/// <summary>
/// Returns a constraint that tests whether a collection is ordered
/// </summary>
Gen3: Is.Ordered=>new CollectionOrderedConstraint()
%
/// <summary>
/// Returns a new CollectionContainsConstraint checking for the
/// presence of a particular object in the collection.
/// </summary>
Gen3: Has.Member(object expected)=>new CollectionContainsConstraint(expected)
Gen: ConstraintFactory.Contains(object expected)=>new CollectionContainsConstraint(expected)
Gen: ConstraintExpression.Contains(object expected)=>(CollectionContainsConstraint)this.Append(new CollectionContainsConstraint(expected))
%
/// <summary>
/// Returns a new ContainsConstraint. This constraint
/// will, in turn, make use of the appropriate second-level
/// constraint, depending on the type of the actual argument. 
/// This overload is only used if the item sought is a string,
/// since any other type implies that we are looking for a 
/// collection member.
/// </summary>
Type: ContainsConstraint
Gen: ConstraintFactory.Contains(string expected)=>new ContainsConstraint(expected)
Gen: ConstraintExpression.Contains(string expected)=>(ContainsConstraint)this.Append(new ContainsConstraint(expected))
%
/// <summary>
/// Returns a constraint that succeeds if the actual
/// value contains the substring supplied as an argument.
/// </summary>
Type: SubstringConstraint
Gen3: Is.StringContaining(string expected)=>new SubstringConstraint(expected)
Gen: [Obsolete("Use Is.StringContaining")]Text.Contains(string expected)=>new SubstringConstraint(expected)
Gen: ConstraintFactory.ContainsSubstring(string expected)=>new SubstringConstraint(expected)
Gen: ConstraintExpression.ContainsSubstring(string expected)=>(SubstringConstraint)this.Append(new SubstringConstraint(expected))
%
/// <summary>
/// Returns a constraint that fails if the actual
/// value contains the substring supplied as an argument.
/// </summary>
Type: SubstringConstraint
Gen: [Obsolete("Use Is.Not.StringContaining")]Text.DoesNotContain(string expected)=>new ConstraintExpression().Not.ContainsSubstring(expected)
Gen: ConstraintFactory.DoesNotContain(string expected)=>new ConstraintExpression().Not.ContainsSubstring(expected)
%
/// <summary>
/// Returns a constraint that succeeds if the actual
/// value starts with the substring supplied as an argument.
/// </summary>
Gen: [Obsolete("Use Is.StringStarting")]Text.StartsWith(string expected)=>new StartsWithConstraint(expected)
Gen: ConstraintFactory.StartsWith(string expected)=>new StartsWithConstraint(expected)
Gen: ConstraintExpression.StartsWith(string expected)=>(StartsWithConstraint)this.Append(new StartsWithConstraint(expected))
Gen3: Is.StringStarting(string expected)=>new StartsWithConstraint(expected)
%
/// <summary>
/// Returns a constraint that fails if the actual
/// value starts with the substring supplied as an argument.
/// </summary>
Type: StartsWithConstraint
Gen: Text.DoesNotStartWith(string expected)=>new ConstraintExpression().Not.StartsWith(expected)
Gen: ConstraintFactory.DoesNotStartWith(string expected)=>new ConstraintExpression().Not.StartsWith(expected)
%
/// <summary>
/// Returns a constraint that succeeds if the actual
/// value ends with the substring supplied as an argument.
/// </summary>
Gen: [Obsolete("Use Is.StringEnding")]Text.EndsWith(string expected)=>new EndsWithConstraint(expected)
Gen: ConstraintFactory.EndsWith(string expected)=>new EndsWithConstraint(expected)
Gen: ConstraintExpression.EndsWith(string expected)=>(EndsWithConstraint)this.Append(new EndsWithConstraint(expected))
Gen3: Is.StringEnding(string expected)=>new EndsWithConstraint(expected)
%
/// <summary>
/// Returns a constraint that fails if the actual
/// value ends with the substring supplied as an argument.
/// </summary>
Type: EndsWithConstraint
Gen: Text.DoesNotEndWith(string expected)=>new ConstraintExpression().Not.EndsWith(expected)
Gen: ConstraintFactory.DoesNotEndWith(string expected)=>new ConstraintExpression().Not.EndsWith(expected)
%
/// <summary>
/// Returns a constraint that succeeds if the actual
/// value matches the Regex pattern supplied as an argument.
/// </summary>
Gen: [Obsolete("Use Is.StringMatching")]Text.Matches(string pattern)=>new RegexConstraint(pattern)
Gen: ConstraintFactory.Matches(string pattern)=>new RegexConstraint(pattern)
Gen: ConstraintExpression.Matches(string pattern)=>(RegexConstraint)this.Append(new RegexConstraint(pattern))
Gen3: Is.StringMatching(string pattern)=>new RegexConstraint(pattern)
%
/// <summary>
/// Returns a constraint that fails if the actual
/// value matches the pattern supplied as an argument.
/// </summary>
Type: RegexConstraint
Gen: [Obsolete]Text.DoesNotMatch(string pattern)=>new ConstraintExpression().Not.Matches(pattern)
Gen: ConstraintFactory.DoesNotMatch(string pattern)=>new ConstraintExpression().Not.Matches(pattern)
%
/// <summary>
/// Returns a constraint that tests whether the path provided 
/// is the same as an expected path after canonicalization.
/// </summary>
Gen3: Is.SamePath(string expected)=>new SamePathConstraint(expected)
%
/// <summary>
/// Returns a constraint that tests whether the path provided 
/// is the same path or under an expected path after canonicalization.
/// </summary>
Gen3: Is.SamePathOrUnder(string expected)=>new SamePathOrUnderConstraint(expected)
%
#
# Constraints with Two Arguments
#
/// <summary>
/// Returns a constraint that tests whether the actual value falls 
/// within a specified range.
/// </summary>
Gen3: Is.InRange(IComparable from, IComparable to)=>new RangeConstraint(from, to)
%
/// <summary>
/// Returns a constraint that tests whether the actual value falls 
/// within a specified range.
/// </summary>
#Gen3: Is.InRange<T>(T from, T to) where T : IComparable=>new RangeConstraint<T>(from, to)
%
#
# Asserts
#
/// <summary>
/// Asserts that a condition is true. If the condition is false the method throws
/// an <see cref="AssertionException"/>.
/// </summary>
/// <param name="condition">The evaluated condition</param>
Gen: Assert.True(bool condition)=>Assert.That(condition, Is.True)
Gen: Assert.IsTrue(bool condition)=>Assert.That(condition, Is.True)
%
/// <summary>
/// Asserts that a condition is false. If the condition is true the method throws
/// an <see cref="AssertionException"/>.
/// </summary> 
/// <param name="condition">The evaluated condition</param>
Gen: Assert.False(bool condition)=>Assert.That(condition, Is.False)
Gen: Assert.IsFalse(bool condition)=>Assert.That(condition, Is.False)
%
/// <summary>
/// Verifies that the object that is passed in is not equal to <code>null</code>
/// If the object is <code>null</code> then an <see cref="AssertionException"/>
/// is thrown.
/// </summary>
/// <param name="anObject">The object that is to be tested</param>
Gen: Assert.NotNull(object anObject)=>Assert.That(anObject, Is.Not.Null)
Gen: Assert.IsNotNull(object anObject)=>Assert.That(anObject, Is.Not.Null)
%
/// <summary>
/// Verifies that the object that is passed in is equal to <code>null</code>
/// If the object is not <code>null</code> then an <see cref="AssertionException"/>
/// is thrown.
/// </summary>
/// <param name="anObject">The object that is to be tested</param>
Gen: Assert.Null(object anObject)=>Assert.That(anObject, Is.Null)
Gen: Assert.IsNull(object anObject)=>Assert.That(anObject, Is.Null)
%
/// <summary>
/// Verifies that the double that is passed in is an <code>NaN</code> value.
/// If the object is not <code>NaN</code> then an <see cref="AssertionException"/>
/// is thrown.
/// </summary>
/// <param name="aDouble">The value that is to be tested</param>
Gen: Assert.IsNaN(double aDouble)=>Assert.That(aDouble, Is.NaN)
Gen: Assert.IsNaN(double? aDouble)=>Assert.That(aDouble, Is.NaN)
%
/// <summary>
/// Assert that a string is empty - that is equal to string.Empty
/// </summary>
/// <param name="aString">The string to be tested</param>
Gen: Assert.IsEmpty(string aString)=>Assert.That(aString, new EmptyStringConstraint())
%
/// <summary>
/// Assert that an array, list or other collection is empty
/// </summary>
/// <param name="collection">An array, list or other collection implementing ICollection</param>
Gen: Assert.IsEmpty(ICollection collection)=>Assert.That(collection, new EmptyCollectionConstraint())
%
/// <summary>
/// Assert that a string is not empty - that is not equal to string.Empty
/// </summary>
/// <param name="aString">The string to be tested</param>
Gen: Assert.IsNotEmpty(string aString)=>Assert.That(aString, Is.Not.Empty)
%
/// <summary>
/// Assert that an array, list or other collection is not empty
/// </summary>
/// <param name="collection">An array, list or other collection implementing ICollection</param>
Gen: Assert.IsNotEmpty(ICollection collection)=>Assert.That(collection, Is.Not.Empty)
%
/// <summary>
/// Assert that a string is either null or equal to string.Empty
/// </summary>
/// <param name="aString">The string to be tested</param>
Gen: Assert.IsNullOrEmpty(string aString)=>Assert.That(aString, new NullOrEmptyStringConstraint())
%
/// <summary>
/// Assert that a string is not null or empty
/// </summary>
/// <param name="aString">The string to be tested</param>
Gen: Assert.IsNotNullOrEmpty(string aString)=>Assert.That(aString, new NotConstraint( new NullOrEmptyStringConstraint()))
%
/// <summary>
/// Asserts that an object may be assigned a  value of a given Type.
/// </summary>
/// <param name="expected">The expected Type.</param>
/// <param name="actual">The object under examination</param>
Gen: Assert.IsAssignableFrom(Type expected, object actual)=>Assert.That(actual, Is.AssignableFrom(expected))
%
/// <summary>
/// Asserts that an object may be assigned a  value of a given Type.
/// </summary>
/// <typeparam name="T">The expected Type.</typeparam>
/// <param name="actual">The object under examination</param>
Gen: Assert.IsAssignableFrom<T>(object actual)=>Assert.That(actual, Is.AssignableFrom(typeof(T)))
%
/// <summary>
/// Asserts that an object may not be assigned a  value of a given Type.
/// </summary>
/// <param name="expected">The expected Type.</param>
/// <param name="actual">The object under examination</param>
Gen: Assert.IsNotAssignableFrom(Type expected, object actual)=>Assert.That(actual, Is.Not.AssignableFrom(expected))
%
/// <summary>
/// Asserts that an object may not be assigned a  value of a given Type.
/// </summary>
/// <typeparam name="T">The expected Type.</typeparam>
/// <param name="actual">The object under examination</param>
Gen: Assert.IsNotAssignableFrom<T>(object actual)=>Assert.That(actual, Is.Not.AssignableFrom(typeof(T)))
%
/// <summary>
/// Asserts that an object is an instance of a given type.
/// </summary>
/// <param name="expected">The expected Type</param>
/// <param name="actual">The object being examined</param>
Gen: Assert.IsInstanceOf(Type expected, object actual)=>Assert.That(actual, Is.InstanceOf(expected))
Gen: [Obsolete]Assert.IsInstanceOfType(Type expected, object actual)=>Assert.That(actual, Is.InstanceOf(expected))
%
/// <summary>
/// Asserts that an object is an instance of a given type.
/// </summary>
/// <typeparam name="T">The expected Type</typeparam>
/// <param name="actual">The object being examined</param>
Gen: Assert.IsInstanceOf<T>(object actual)=>Assert.That(actual, Is.InstanceOf(typeof(T)))
%
/// <summary>
/// Asserts that an object is not an instance of a given type.
/// </summary>
/// <param name="expected">The expected Type</param>
/// <param name="actual">The object being examined</param>
Gen: Assert.IsNotInstanceOf(Type expected, object actual)=>Assert.That(actual, Is.Not.InstanceOf(expected))
Gen: [Obsolete]Assert.IsNotInstanceOfType(Type expected, object actual)=>Assert.That(actual, Is.Not.InstanceOf(expected))
%
/// <summary>
/// Asserts that an object is not an instance of a given type.
/// </summary>
/// <typeparam name="T">The expected Type</typeparam>
/// <param name="actual">The object being examined</param>
Gen: Assert.IsNotInstanceOf<T>(object actual)=>Assert.That(actual, Is.Not.InstanceOf(typeof(T)))
%
/// <summary>
/// Verifies that two values are equal. If they are not, then an 
/// <see cref="AssertionException"/> is thrown.
/// </summary>
/// <param name="expected">The expected value</param>
/// <param name="actual">The actual value</param>
Gen: Assert.AreEqual(int expected, int actual)=>Assert.That(actual, Is.EqualTo(expected))
Gen: Assert.AreEqual(long expected, long actual)=>Assert.That(actual, Is.EqualTo(expected))
Gen: [CLSCompliant(false)]Assert.AreEqual(uint expected, uint actual)=>Assert.That(actual, Is.EqualTo(expected))
Gen: [CLSCompliant(false)]Assert.AreEqual(ulong expected, ulong actual)=>Assert.That(actual, Is.EqualTo(expected))
Gen: Assert.AreEqual(decimal expected, decimal actual)=>Assert.That(actual, Is.EqualTo(expected))
%
/// <summary>
/// Verifies that two doubles are equal considering a delta. If the
/// expected value is infinity then the delta value is ignored. If 
/// they are not equal then an <see cref="AssertionException"/> is
/// thrown.
/// </summary>
/// <param name="expected">The expected value</param>
/// <param name="actual">The actual value</param>
/// <param name="delta">The maximum acceptable difference between the
/// the expected and the actual</param>
Gen: Assert.AreEqual(double expected, double actual, double delta)=>AssertDoublesAreEqual(expected, actual, delta)
Gen: Assert.AreEqual(double expected, double? actual, double delta)=>AssertDoublesAreEqual(expected, (double)actual, delta)
%
/// <summary>
/// Verifies that two objects are equal.  Two objects are considered
/// equal if both are null, or if both have the same value. NUnit
/// has special semantics for some object types.
/// If they are not equal an <see cref="AssertionException"/> is thrown.
/// </summary>
/// <param name="expected">The value that is expected</param>
/// <param name="actual">The actual value</param>
Gen: Assert.AreEqual(object expected, object actual)=>Assert.That(actual, Is.EqualTo(expected))
%
/// <summary>
/// Verifies that two values are not equal. If they are equal, then an 
/// <see cref="AssertionException"/> is thrown.
/// </summary>
/// <param name="expected">The expected value</param>
/// <param name="actual">The actual value</param>
Gen: Assert.AreNotEqual(int expected, int actual)=>Assert.That(actual, Is.Not.EqualTo(expected))
Gen: Assert.AreNotEqual(long expected, long actual)=>Assert.That(actual, Is.Not.EqualTo(expected))
Gen: [CLSCompliant(false)]Assert.AreNotEqual(uint expected, uint actual)=>Assert.That(actual, Is.Not.EqualTo(expected))
Gen: [CLSCompliant(false)]Assert.AreNotEqual(ulong expected, ulong actual)=>Assert.That(actual, Is.Not.EqualTo(expected))
Gen: Assert.AreNotEqual(decimal expected, decimal actual)=>Assert.That(actual, Is.Not.EqualTo(expected))
Gen: Assert.AreNotEqual(float expected, float actual)=>Assert.That(actual, Is.Not.EqualTo(expected))
Gen: Assert.AreNotEqual(double expected, double actual)=>Assert.That(actual, Is.Not.EqualTo(expected))
%
/// <summary>
/// Verifies that two objects are not equal.  Two objects are considered
/// equal if both are null, or if both have the same value. NUnit
/// has special semantics for some object types.
/// If they are equal an <see cref="AssertionException"/> is thrown.
/// </summary>
/// <param name="expected">The value that is expected</param>
/// <param name="actual">The actual value</param>
Gen: Assert.AreNotEqual(object expected, object actual)=>Assert.That(actual, Is.Not.EqualTo(expected))
%
/// <summary>
/// Asserts that two objects refer to the same object. If they
/// are not the same an <see cref="AssertionException"/> is thrown.
/// </summary>
/// <param name="expected">The expected object</param>
/// <param name="actual">The actual object</param>
Gen: Assert.AreSame(object expected, object actual)=>Assert.That(actual, Is.SameAs(expected))
%
/// <summary>
/// Asserts that two objects do not refer to the same object. If they
/// are the same an <see cref="AssertionException"/> is thrown.
/// </summary>
/// <param name="expected">The expected object</param>
/// <param name="actual">The actual object</param>
Gen: Assert.AreNotSame(object expected, object actual)=>Assert.That(actual, Is.Not.SameAs(expected))
%
/// <summary>
/// Verifies that the first value is greater than the second
/// value. If it is not, then an
/// <see cref="AssertionException"/> is thrown. 
/// </summary>
/// <param name="arg1">The first value, expected to be greater</param>
/// <param name="arg2">The second value, expected to be less</param>
Gen: Assert.Greater(int arg1, int arg2)=>Assert.That(arg1, Is.GreaterThan(arg2))
Gen: [CLSCompliant(false)]Assert.Greater(uint arg1, uint arg2)=>Assert.That(arg1, Is.GreaterThan(arg2))
Gen: Assert.Greater(long arg1, long arg2)=>Assert.That(arg1, Is.GreaterThan(arg2))
Gen: [CLSCompliant(false)]Assert.Greater(ulong arg1, ulong arg2)=>Assert.That(arg1, Is.GreaterThan(arg2))
Gen: Assert.Greater(decimal arg1, decimal arg2)=>Assert.That(arg1, Is.GreaterThan(arg2))
Gen: Assert.Greater(double arg1, double arg2)=>Assert.That(arg1, Is.GreaterThan(arg2))
Gen: Assert.Greater(float arg1, float arg2)=>Assert.That(arg1, Is.GreaterThan(arg2))
Gen: Assert.Greater(IComparable arg1, IComparable arg2)=>Assert.That(arg1, Is.GreaterThan(arg2))
%
/// <summary>
/// Verifies that the first value is less than the second
/// value. If it is not, then an
/// <see cref="AssertionException"/> is thrown. 
/// </summary>
/// <param name="arg1">The first value, expected to be less</param>
/// <param name="arg2">The second value, expected to be greater</param>
Gen: Assert.Less(int arg1, int arg2)=>Assert.That(arg1, Is.LessThan(arg2))
Gen: [CLSCompliant(false)]Assert.Less(uint arg1, uint arg2)=>Assert.That(arg1, Is.LessThan(arg2))
Gen: Assert.Less(long arg1, long arg2)=>Assert.That(arg1, Is.LessThan(arg2))
Gen: [CLSCompliant(false)]Assert.Less(ulong arg1, ulong arg2)=>Assert.That(arg1, Is.LessThan(arg2))
Gen: Assert.Less(decimal arg1, decimal arg2)=>Assert.That(arg1, Is.LessThan(arg2))
Gen: Assert.Less(double arg1, double arg2)=>Assert.That(arg1, Is.LessThan(arg2))
Gen: Assert.Less(float arg1, float arg2)=>Assert.That(arg1, Is.LessThan(arg2))
Gen: Assert.Less(IComparable arg1, IComparable arg2)=>Assert.That(arg1, Is.LessThan(arg2))
%
/// <summary>
/// Verifies that the first value is greater than or equal tothe second
/// value. If it is not, then an
/// <see cref="AssertionException"/> is thrown. 
/// </summary>
/// <param name="arg1">The first value, expected to be greater</param>
/// <param name="arg2">The second value, expected to be less</param>
Gen: Assert.GreaterOrEqual(int arg1, int arg2)=>Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2))
Gen: [CLSCompliant(false)]Assert.GreaterOrEqual(uint arg1, uint arg2)=>Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2))
Gen: Assert.GreaterOrEqual(long arg1, long arg2)=>Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2))
Gen: [CLSCompliant(false)]Assert.GreaterOrEqual(ulong arg1, ulong arg2)=>Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2))
Gen: Assert.GreaterOrEqual(decimal arg1, decimal arg2)=>Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2))
Gen: Assert.GreaterOrEqual(double arg1, double arg2)=>Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2))
Gen: Assert.GreaterOrEqual(float arg1, float arg2)=>Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2))
Gen: Assert.GreaterOrEqual(IComparable arg1, IComparable arg2)=>Assert.That(arg1, Is.GreaterThanOrEqualTo(arg2))
%
/// <summary>
/// Verifies that the first value is less than or equal to the second
/// value. If it is not, then an
/// <see cref="AssertionException"/> is thrown. 
/// </summary>
/// <param name="arg1">The first value, expected to be less</param>
/// <param name="arg2">The second value, expected to be greater</param>
Gen: Assert.LessOrEqual(int arg1, int arg2)=>Assert.That(arg1, Is.LessThanOrEqualTo(arg2))
Gen: [CLSCompliant(false)]Assert.LessOrEqual(uint arg1, uint arg2)=>Assert.That(arg1, Is.LessThanOrEqualTo(arg2))
Gen: Assert.LessOrEqual(long arg1, long arg2)=>Assert.That(arg1, Is.LessThanOrEqualTo(arg2))
Gen: [CLSCompliant(false)]Assert.LessOrEqual(ulong arg1, ulong arg2)=>Assert.That(arg1, Is.LessThanOrEqualTo(arg2))
Gen: Assert.LessOrEqual(decimal arg1, decimal arg2)=>Assert.That(arg1, Is.LessThanOrEqualTo(arg2))
Gen: Assert.LessOrEqual(double arg1, double arg2)=>Assert.That(arg1, Is.LessThanOrEqualTo(arg2))
Gen: Assert.LessOrEqual(float arg1, float arg2)=>Assert.That(arg1, Is.LessThanOrEqualTo(arg2))
Gen: Assert.LessOrEqual(IComparable arg1, IComparable arg2)=>Assert.That(arg1, Is.LessThanOrEqualTo(arg2))
%
/// <summary>
/// Asserts that an object is contained in a list.
/// </summary>
/// <param name="expected">The expected object</param>
/// <param name="actual">The list to be examined</param>
Gen: Assert.Contains(object expected, ICollection actual)=>Assert.That(actual, new CollectionContainsConstraint(expected))
%
