<PackageReference Include="NUnit" Version="3.8.0" />

---

API Differences between 3.8.0 and 2.7.0

1954 Additions 382 Removals

NUnit

• public static class FrameworkPackageSettings
  • public const string DebugTests = "DebugTests"
  • public const string DefaultTestNamePattern = "DefaultTestNamePattern"
  • public const string DefaultTimeout = "DefaultTimeout"
  • public const string InternalTraceLevel = "InternalTraceLevel"
  • public const string InternalTraceWriter = "InternalTraceWriter"
  • public const string LOAD = "LOAD"
  • public const string NumberOfTestWorkers = "NumberOfTestWorkers"
  • public const string PauseBeforeRun = "PauseBeforeRun"
  • public const string RandomSeed = "RandomSeed"
  • public const string StopOnError = "StopOnError"
  • public const string SynchronousEvents = "SynchronousEvents"
  • public const string TestParameters = "TestParameters"
  • public const string TestParametersDictionary = "TestParametersDictionary"
  • public const string WorkDirectory = "WorkDirectory"

NUnit.Compatibility

• public static class AdditionalTypeExtensions
  • public static bool IsCastableFrom(this Type to, Type from)
  • public static bool ParametersMatch(this ParameterInfo[] pinfos, Type[] ptypes)
• public static class AssemblyExtensions
  • public static T GetCustomAttribute<T>(this Assembly assembly) where T : Attribute
• public static class AttributeHelper
  • public static Attribute[] GetCustomAttributes(object actual, Type attributeType, bool inherit)
• public class LongLivedMarshalByRefObject : MarshalByRefObject
  • public LongLivedMarshalByRefObject()
• public class NUnitNullType
  • public NUnitNullType()
• public static class ReaderWriterLockExtensions
  • public static void EnterReadLock(this ReaderWriterLock rwLock)
  • public static void EnterWriteLock(this ReaderWriterLock rwLock)
  • public static void ExitReadLock(this ReaderWriterLock rwLock)
  • public static void ExitWriteLock(this ReaderWriterLock rwLock)
• public static class TypeExtensions
  • public static Type GetTypeInfo(this Type type)

NUnit.Framework

• public class Assert
  • public static int Counter { get; }
  • public static void AreEqual(int expected, int actual, string message, object[] args)
  • public static void AreEqual(int expected, int actual, string message)
  • public static void AreEqual(int expected, int actual)
  • public static void AreEqual(long expected, long actual, string message, object[] args)
  • public static void AreEqual(long expected, long actual, string message)
  • public static void AreEqual(long expected, long actual)
  • public static void AreEqual(uint expected, uint actual, string message, object[] args)
  • public static void AreEqual(uint expected, uint actual, string message)
  • public static void AreEqual(uint expected, uint actual)
  • public static void AreEqual(ulong expected, ulong actual, string message, object[] args)
  • public static void AreEqual(ulong expected, ulong actual, string message)
  • public static void AreEqual(ulong expected, ulong actual)
  • public static void AreEqual(decimal expected, decimal actual, string message, object[] args)
  • public static void AreEqual(decimal expected, decimal actual, string message)
  • public static void AreEqual(decimal expected, decimal actual)
  • public static void AreEqual(double expected, double actual, double delta, string message)
  • public static void AreEqual(double expected, double? actual, double delta, string message)
  • public static void AreEqual(object expected, object actual, string message)
  • public static void AreNotEqual(int expected, int actual, string message, object[] args)
  • public static void AreNotEqual(int expected, int actual, string message)
  • public static void AreNotEqual(int expected, int actual)
  • public static void AreNotEqual(long expected, long actual, string message, object[] args)
  • public static void AreNotEqual(long expected, long actual, string message)
  • public static void AreNotEqual(long expected, long actual)
  • public static void AreNotEqual(uint expected, uint actual, string message, object[] args)
  • public static void AreNotEqual(uint expected, uint actual, string message)
  • public static void AreNotEqual(uint expected, uint actual)
  • public static void AreNotEqual(ulong expected, ulong actual, string message, object[] args)
  • public static void AreNotEqual(ulong expected, ulong actual, string message)
  • public static void AreNotEqual(ulong expected, ulong actual)
  • public static void AreNotEqual(decimal expected, decimal actual, string message, object[] args)
  • public static void AreNotEqual(decimal expected, decimal actual, string message)
  • public static void AreNotEqual(decimal expected, decimal actual)
  • public static void AreNotEqual(float expected, float actual, string message, object[] args)
  • public static void AreNotEqual(float expected, float actual, string message)
  • public static void AreNotEqual(float expected, float actual)
  • public static void AreNotEqual(double expected, double actual, string message, object[] args)
  • public static void AreNotEqual(double expected, double actual, string message)
  • public static void AreNotEqual(double expected, double actual)
  • public static void AreNotEqual(object expected, object actual, string message)
  • public static void AreNotSame(object expected, object actual, string message)
  • public static void AreSame(object expected, object actual, string message)
  • public static void ByVal(object actual, IResolveConstraint expression, string message)
  • public static Exception Catch(TestDelegate code, string message)
  • public static Exception Catch(Type expectedExceptionType, TestDelegate code, string message)
  • public static T Catch<T>(TestDelegate code, string message, object[] args) where T : Exception
  • public static T Catch<T>(TestDelegate code, string message) where T : Exception
  • public static T Catch<T>(TestDelegate code) where T : Exception
  • public static TActual Catch<TActual>(TestDelegate code, string message, object[] args) where TActual : Exception
  • public static TActual Catch<TActual>(TestDelegate code) where TActual : Exception
  • public static void Contains(object expected, ICollection actual, string message)
  • public static void DoesNotThrow(TestDelegate code, string message)
  • public static void False(bool? condition, string message, object[] args)
  • public static void False(bool condition, string message)
  • public static void False(bool? condition)
  • public static void Greater(int arg1, int arg2, string message)
  • public static void Greater(uint arg1, uint arg2, string message)
  • public static void Greater(long arg1, long arg2, string message)
  • public static void Greater(ulong arg1, ulong arg2, string message)
  • public static void Greater(decimal arg1, decimal arg2, string message)
  • public static void Greater(double arg1, double arg2, string message)
  • public static void Greater(float arg1, float arg2, string message)
  • public static void Greater(IComparable arg1, IComparable arg2, string message)
  • public static void GreaterOrEqual(int arg1, int arg2, string message)
  • public static void GreaterOrEqual(uint arg1, uint arg2, string message)
  • public static void GreaterOrEqual(long arg1, long arg2, string message)
  • public static void GreaterOrEqual(ulong arg1, ulong arg2, string message)
  • public static void GreaterOrEqual(decimal arg1, decimal arg2, string message)
  • public static void GreaterOrEqual(double arg1, double arg2, string message)
  • public static void GreaterOrEqual(float arg1, float arg2, string message)
  • public static void GreaterOrEqual(IComparable arg1, IComparable arg2, string message)
  • public static void IsAssignableFrom(Type expected, object actual, string message)
  • public static void IsAssignableFrom<T>(object actual, string message)
  • public static void IsEmpty(string aString, string message)
  • public static void IsEmpty(IEnumerable collection, string message)
  • public static void IsFalse(bool? condition, string message, object[] args)
  • public static void IsFalse(bool condition, string message)
  • public static void IsFalse(bool? condition)
  • public static void IsInstanceOf(Type expected, object actual, string message)
  • public static void IsInstanceOf<T>(object actual, string message)
  • public static void IsInstanceOfType(Type expected, object actual, string message, object[] args)
  • public static void IsInstanceOfType(Type expected, object actual, string message)
  • public static void IsInstanceOfType(Type expected, object actual)
  • public static void IsNaN(double aDouble, string message)
  • public static void IsNaN(double? aDouble, string message)
  • public static void IsNotAssignableFrom(Type expected, object actual, string message)
  • public static void IsNotAssignableFrom<T>(object actual, string message)
  • public static void IsNotEmpty(string aString, string message)
  • public static void IsNotEmpty(IEnumerable collection, string message)
  • public static void IsNotInstanceOf(Type expected, object actual, string message)
  • public static void IsNotInstanceOf<T>(object actual, string message)
  • public static void IsNotInstanceOfType(Type expected, object actual, string message, object[] args)
  • public static void IsNotInstanceOfType(Type expected, object actual, string message)
  • public static void IsNotInstanceOfType(Type expected, object actual)
  • public static void IsNotNull(object anObject, string message)
  • public static void IsNotNullOrEmpty(string aString, string message, object[] args)
  • public static void IsNotNullOrEmpty(string aString, string message)
  • public static void IsNotNullOrEmpty(string aString)
  • public static void IsNull(object anObject, string message)
  • public static void IsNullOrEmpty(string aString, string message, object[] args)
  • public static void IsNullOrEmpty(string aString, string message)
  • public static void IsNullOrEmpty(string aString)
  • public static void IsTrue(bool? condition, string message, object[] args)
  • public static void IsTrue(bool condition, string message)
  • public static void IsTrue(bool? condition)
  • public static void Less(int arg1, int arg2, string message)
  • public static void Less(uint arg1, uint arg2, string message)
  • public static void Less(long arg1, long arg2, string message)
  • public static void Less(ulong arg1, ulong arg2, string message)
  • public static void Less(decimal arg1, decimal arg2, string message)
  • public static void Less(double arg1, double arg2, string message)
  • public static void Less(float arg1, float arg2, string message)
  • public static void Less(IComparable arg1, IComparable arg2, string message)
  • public static void LessOrEqual(int arg1, int arg2, string message)
  • public static void LessOrEqual(uint arg1, uint arg2, string message)
  • public static void LessOrEqual(long arg1, long arg2, string message)
  • public static void LessOrEqual(ulong arg1, ulong arg2, string message)
  • public static void LessOrEqual(decimal arg1, decimal arg2, string message)
  • public static void LessOrEqual(double arg1, double arg2, string message)
  • public static void LessOrEqual(float arg1, float arg2, string message)
  • public static void LessOrEqual(IComparable arg1, IComparable arg2, string message)
  • public static void Multiple(TestDelegate testDelegate)
  • public static void Negative(int actual)
  • public static void Negative(int actual, string message, object[] args)
  • public static void Negative(uint actual)
  • public static void Negative(uint actual, string message, object[] args)
  • public static void Negative(long actual)
  • public static void Negative(long actual, string message, object[] args)
  • public static void Negative(ulong actual)
  • public static void Negative(ulong actual, string message, object[] args)
  • public static void Negative(decimal actual)
  • public static void Negative(decimal actual, string message, object[] args)
  • public static void Negative(double actual)
  • public static void Negative(double actual, string message, object[] args)
  • public static void Negative(float actual)
  • public static void Negative(float actual, string message, object[] args)
  • public static void NotNull(object anObject, string message)
  • public static void NotZero(int actual)
  • public static void NotZero(int actual, string message, object[] args)
  • public static void NotZero(uint actual)
  • public static void NotZero(uint actual, string message, object[] args)
  • public static void NotZero(long actual)
  • public static void NotZero(long actual, string message, object[] args)
  • public static void NotZero(ulong actual)
  • public static void NotZero(ulong actual, string message, object[] args)
  • public static void NotZero(decimal actual)
  • public static void NotZero(decimal actual, string message, object[] args)
  • public static void NotZero(double actual)
  • public static void NotZero(double actual, string message, object[] args)
  • public static void NotZero(float actual)
  • public static void NotZero(float actual, string message, object[] args)
  • public static void Null(object anObject, string message)
  • public static void Positive(int actual)
  • public static void Positive(int actual, string message, object[] args)
  • public static void Positive(uint actual)
  • public static void Positive(uint actual, string message, object[] args)
  • public static void Positive(long actual)
  • public static void Positive(long actual, string message, object[] args)
  • public static void Positive(ulong actual)
  • public static void Positive(ulong actual, string message, object[] args)
  • public static void Positive(decimal actual)
  • public static void Positive(decimal actual, string message, object[] args)
  • public static void Positive(double actual)
  • public static void Positive(double actual, string message, object[] args)
  • public static void Positive(float actual)
  • public static void Positive(float actual, string message, object[] args)
  • public static void That(object actual, IResolveConstraint expression)
  • public static void That(object actual, IResolveConstraint expression, string message)
  • public static void That(object actual, IResolveConstraint expression, string message, object[] args)
  • public static void That(bool condition, string message)
  • public static void That<T>(ActualValueDelegate<T> del, IResolveConstraint expr)
  • public static void That<T>(ActualValueDelegate<T> del, IResolveConstraint expr, string message)
  • public static void That<T>(ActualValueDelegate<T> del, IResolveConstraint expr, string message, object[] args)
  • public static void That<T>(ref T actual, IResolveConstraint expression)
  • public static void That<T>(ref T actual, IResolveConstraint expression, string message)
  • public static void That<T>(ref T actual, IResolveConstraint expression, string message, object[] args)
  • public static void That<TActual>(ActualValueDelegate<TActual> del, IResolveConstraint expr)
  • public static void That<TActual>(ActualValueDelegate<TActual> del, IResolveConstraint expr, string message, object[] args)
  • public static void That(TestDelegate code, IResolveConstraint constraint, string message, object[] args)
  • public static void That<TActual>(TActual actual, IResolveConstraint expression)
  • public static void That<TActual>(TActual actual, IResolveConstraint expression, string message, object[] args)
  • public static Exception Throws(IResolveConstraint expression, TestDelegate code, string message)
  • public static Exception Throws(Type expectedExceptionType, TestDelegate code, string message)
  • public static T Throws<T>(TestDelegate code, string message, object[] args) where T : Exception
  • public static T Throws<T>(TestDelegate code, string message) where T : Exception
  • public static T Throws<T>(TestDelegate code) where T : Exception
  • public static TActual Throws<TActual>(TestDelegate code, string message, object[] args) where TActual : Exception
  • public static TActual Throws<TActual>(TestDelegate code) where TActual : Exception
  • public static void True(bool? condition, string message, object[] args)
  • public static void True(bool condition, string message)
  • public static void True(bool? condition)
  • public static void Warn(string message, object[] args)
  • public static void Warn(string message)
  • public static void Zero(int actual)
  • public static void Zero(int actual, string message, object[] args)
  • public static void Zero(uint actual)
  • public static void Zero(uint actual, string message, object[] args)
  • public static void Zero(long actual)
  • public static void Zero(long actual, string message, object[] args)
  • public static void Zero(ulong actual)
  • public static void Zero(ulong actual, string message, object[] args)
  • public static void Zero(decimal actual)
  • public static void Zero(decimal actual, string message, object[] args)
  • public static void Zero(double actual)
  • public static void Zero(double actual, string message, object[] args)
  • public static void Zero(float actual)
  • public static void Zero(float actual, string message, object[] args)
• public class AssertionHelper
  • public ConstraintExpression All { get; }
  • public BinarySerializableConstraint BinarySerializable { get; }
  • public ResolvableConstraintExpression Count { get; }
  • public EmptyConstraint Empty { get; }
  • public FalseConstraint False { get; }
  • public ResolvableConstraintExpression InnerException { get; }
  • public ResolvableConstraintExpression Length { get; }
  • public ResolvableConstraintExpression Message { get; }
  • public NaNConstraint NaN { get; }
  • public LessThanConstraint Negative { get; }
  • public ConstraintExpression No { get; }
  • public ConstraintExpression None { get; }
  • public ConstraintExpression Not { get; }
  • public NullConstraint Null { get; }
  • public CollectionOrderedConstraint Ordered { get; }
  • public GreaterThanConstraint Positive { get; }
  • public ConstraintExpression Some { get; }
  • public TrueConstraint True { get; }
  • public UniqueItemsConstraint Unique { get; }
  • public XmlSerializableConstraint XmlSerializable { get; }
  • public EqualConstraint Zero { get; }
  • public void Expect(object actual, IResolveConstraint expression)
  • public void Expect(object actual, IResolveConstraint expression, string message)
  • public void Expect(object actual, IResolveConstraint expression, string message, object[] args)
  • public static ConstraintExpression Exactly(int expectedCount)
  • public static void Expect<TActual>(TActual actual, IResolveConstraint expression)
  • public static void Expect<TActual>(TActual actual, IResolveConstraint expression, string message, object[] args)
  • public AssignableFromConstraint AssignableFrom(Type expectedType)
  • public AssignableFromConstraint AssignableFrom<TExpected>()
  • public AssignableToConstraint AssignableTo(Type expectedType)
  • public AssignableToConstraint AssignableTo<TExpected>()
  • public GreaterThanOrEqualConstraint AtLeast(object expected)
  • public LessThanOrEqualConstraint AtMost(object expected)
  • public ResolvableConstraintExpression Attribute(Type expectedType)
  • public ResolvableConstraintExpression Attribute<TExpected>()
  • public EqualConstraint Contains(object expected)
  • public ContainsConstraint Contains(string expected)
  • public SubstringConstraint ContainsSubstring(string expected)
  • public SubstringConstraint DoesNotContain(string expected)
  • public EndsWithConstraint DoesNotEndWith(string expected)
  • public RegexConstraint DoesNotMatch(string pattern)
  • public StartsWithConstraint DoesNotStartWith(string expected)
  • public EndsWithConstraint EndsWith(string expected)
  • public EndsWithConstraint EndWith(string expected)
  • public EqualConstraint EqualTo(object expected)
  • public CollectionEquivalentConstraint EquivalentTo(IEnumerable expected)
  • public void Expect(bool condition, string message)
  • public void Expect<T>(ActualValueDelegate<T> del, IResolveConstraint expr)
  • public void Expect<T>(ActualValueDelegate<T> del, IResolveConstraint expr, string message)
  • public void Expect<T>(ActualValueDelegate<T> del, IResolveConstraint expr, string message, object[] args)
  • public void Expect<T>(ref T actual, IResolveConstraint expression)
  • public void Expect<T>(ref T actual, IResolveConstraint expression, string message)
  • public void Expect<T>(ref T actual, IResolveConstraint expression, string message, object[] args)
  • public void Expect<TActual>(ActualValueDelegate<TActual> del, IResolveConstraint expr)
  • public void Expect<TActual>(ActualValueDelegate<TActual> del, IResolveConstraint expr, string message, object[] args)
  • public GreaterThanConstraint GreaterThan(object expected)
  • public GreaterThanOrEqualConstraint GreaterThanOrEqualTo(object expected)
  • public RangeConstraint InRange(IComparable from, IComparable to)
  • public InstanceOfTypeConstraint InstanceOf(Type expectedType)
  • public InstanceOfTypeConstraint InstanceOf<TExpected>()
  • public LessThanConstraint LessThan(object expected)
  • public LessThanOrEqualConstraint LessThanOrEqualTo(object expected)
  • public RegexConstraint Match(string pattern)
  • public RegexConstraint Matches(string pattern)
  • public EqualConstraint Member(object expected)
  • public ResolvableConstraintExpression Property(string name)
  • public SameAsConstraint SameAs(object expected)
  • public SamePathConstraint SamePath(string expected)
  • public SamePathOrUnderConstraint SamePathOrUnder(string expected)
  • public StartsWithConstraint StartsWith(string expected)
  • public StartsWithConstraint StartWith(string expected)
  • public SubstringConstraint StringContaining(string expected)
  • public EndsWithConstraint StringEnding(string expected)
  • public RegexConstraint StringMatching(string pattern)
  • public StartsWithConstraint StringStarting(string expected)
  • public SubPathConstraint SubPathOf(string expected)
  • public CollectionSubsetConstraint SubsetOf(IEnumerable expected)
  • public CollectionSupersetConstraint SupersetOf(IEnumerable expected)
  • public ExactTypeConstraint TypeOf(Type expectedType)
  • public ExactTypeConstraint TypeOf<TExpected>()
• public class Assume
  • public static void That(object actual, IResolveConstraint expression)
  • public static void That(object actual, IResolveConstraint expression, string message)
  • public static void That(object actual, IResolveConstraint expression, string message, object[] args)
  • public static void That<TActual>(ActualValueDelegate<TActual> del, IResolveConstraint expr)
  • public static void That<TActual>(ActualValueDelegate<TActual> del, IResolveConstraint expr, string message, object[] args)
  • public static void That(bool condition, string message)
  • public static void That<T>(ActualValueDelegate<T> del, IResolveConstraint expr)
  • public static void That<T>(ActualValueDelegate<T> del, IResolveConstraint expr, string message)
  • public static void That<T>(ActualValueDelegate<T> del, IResolveConstraint expr, string message, object[] args)
  • public static void That<T>(ref T actual, IResolveConstraint expression)
  • public static void That<T>(ref T actual, IResolveConstraint expression, string message)
  • public static void That<T>(ref T actual, IResolveConstraint expression, string message, object[] args)
  • public static void That<TActual>(TActual actual, IResolveConstraint expression)
  • public static void That<TActual>(TActual actual, IResolveConstraint expression, string message, object[] args)
• public class AuthorAttribute : PropertyAttribute
  • public AuthorAttribute(string name)
  • public AuthorAttribute(string name, string email)
• public class CategoryAttribute : NUnitAttribute, IApplyToTest
  • public void ApplyToTest(Test test)
• public class CollectionAssert
  • public static void AllItemsAreInstancesOfType(IEnumerable collection, Type expectedType, string message)
  • public static void AllItemsAreNotNull(IEnumerable collection, string message)
  • public static void AllItemsAreUnique(IEnumerable collection, string message)
  • public static void AreEqual(IEnumerable expected, IEnumerable actual, string message)
  • public static void AreEqual(IEnumerable expected, IEnumerable actual, IComparer comparer, string message)
  • public static void AreEquivalent(IEnumerable expected, IEnumerable actual, string message)
  • public static void AreNotEqual(IEnumerable expected, IEnumerable actual, string message)
  • public static void AreNotEqual(IEnumerable expected, IEnumerable actual, IComparer comparer, string message)
  • public static void AreNotEquivalent(IEnumerable expected, IEnumerable actual, string message)
  • public static void Contains(IEnumerable collection, object actual, string message)
  • public static void DoesNotContain(IEnumerable collection, object actual, string message)
  • public static void IsEmpty(IEnumerable collection, string message)
  • public static void IsNotEmpty(IEnumerable collection, string message)
  • public static void IsNotSubsetOf(IEnumerable subset, IEnumerable superset, string message)
  • public static void IsNotSupersetOf(IEnumerable superset, IEnumerable subset)
  • public static void IsNotSupersetOf(IEnumerable superset, IEnumerable subset, string message, object[] args)
  • public static void IsOrdered(IEnumerable collection, string message)
  • public static void IsOrdered(IEnumerable collection, IComparer comparer, string message)
  • public static void IsSubsetOf(IEnumerable subset, IEnumerable superset, string message)
  • public static void IsSupersetOf(IEnumerable superset, IEnumerable subset)
  • public static void IsSupersetOf(IEnumerable superset, IEnumerable subset, string message, object[] args)
• public abstract class CombiningStrategyAttribute : NUnitAttribute, ITestBuilder, IApplyToTest
  • protected CombiningStrategyAttribute(ICombiningStrategy strategy, IParameterDataProvider provider)
  • protected CombiningStrategyAttribute(object strategy, object provider)
  • public void ApplyToTest(Test test)
  • public IEnumerable<TestMethod> BuildFrom(IMethodInfo method, Test suite)
• public class Contains
  • public static CollectionContainsConstraint Item(object expected)
  • public static EqualConstraint Item(object expected)
  • public static DictionaryContainsKeyConstraint Key(object expected)
  • public static DictionaryContainsValueConstraint Value(object expected)
• public class CultureAttribute : IncludeExcludeAttribute, IApplyToTest
  • public void ApplyToTest(Test test)
  • public bool IsCultureSupported(string culture)
  • public bool IsCultureSupported(string[] cultures)
• public abstract class DataAttribute : NUnitAttribute
  • public DataAttribute()
• public class DatapointSourceAttribute : NUnitAttribute
  • public DatapointSourceAttribute()
• public class DefaultFloatingPointToleranceAttribute : NUnitAttribute, IApplyToContext
  • public DefaultFloatingPointToleranceAttribute(double amount)
  • public void ApplyToContext(TestExecutionContext context)
• public sealed class DescriptionAttribute : PropertyAttribute
  • public string Description { get; }
• public static class DirectoryAssert
  • protected DirectoryAssert()
  • public static void AreEqual(DirectoryInfo expected, DirectoryInfo actual, string message)
  • public static void AreEqual(string expected, string actual, string message, object[] args)
  • public static void AreEqual(string expected, string actual, string message)
  • public static void AreEqual(string expected, string actual)
  • public static void AreNotEqual(DirectoryInfo expected, DirectoryInfo actual, string message)
  • public static void AreNotEqual(string expected, string actual, string message, object[] args)
  • public static void AreNotEqual(string expected, string actual, string message)
  • public static void AreNotEqual(string expected, string actual)
  • public static void DoesNotExist(DirectoryInfo actual, string message, object[] args)
  • public static void DoesNotExist(DirectoryInfo actual)
  • public static void DoesNotExist(string actual, string message, object[] args)
  • public static void DoesNotExist(string actual)
  • public static void IsEmpty(DirectoryInfo directory, string message, object[] args)
  • public static void IsEmpty(DirectoryInfo directory, string message)
  • public static void IsEmpty(DirectoryInfo directory)
  • public static void IsEmpty(string directory, string message, object[] args)
  • public static void IsEmpty(string directory, string message)
  • public static void IsEmpty(string directory)
  • public static void IsNotEmpty(DirectoryInfo directory, string message, object[] args)
  • public static void IsNotEmpty(DirectoryInfo directory, string message)
  • public static void IsNotEmpty(DirectoryInfo directory)
  • public static void IsNotEmpty(string directory, string message, object[] args)
  • public static void IsNotEmpty(string directory, string message)
  • public static void IsNotEmpty(string directory)
  • public static void IsNotWithin(DirectoryInfo directory, DirectoryInfo actual, string message, object[] args)
  • public static void IsNotWithin(DirectoryInfo directory, DirectoryInfo actual, string message)
  • public static void IsNotWithin(DirectoryInfo directory, DirectoryInfo actual)
  • public static void IsNotWithin(string directory, string actual, string message, object[] args)
  • public static void IsNotWithin(string directory, string actual, string message)
  • public static void IsNotWithin(string directory, string actual)
  • public static void IsWithin(DirectoryInfo directory, DirectoryInfo actual, string message, object[] args)
  • public static void IsWithin(DirectoryInfo directory, DirectoryInfo actual, string message)
  • public static void IsWithin(DirectoryInfo directory, DirectoryInfo actual)
  • public static void IsWithin(string directory, string actual, string message, object[] args)
  • public static void IsWithin(string directory, string actual, string message)
  • public static void IsWithin(string directory, string actual)
  • public static void Exists(DirectoryInfo actual, string message, object[] args)
  • public static void Exists(DirectoryInfo actual)
  • public static void Exists(string actual, string message, object[] args)
  • public static void Exists(string actual)
• public static class Does
  • public static FileOrDirectoryExistsConstraint Exist { get; }
  • public static SubstringConstraint Contain(string expected)
  • public static EqualConstraint Contain(object expected)
  • public static ContainsConstraint Contain(string expected)
  • public static DictionaryContainsKeyConstraint ContainKey(object expected)
  • public static DictionaryContainsValueConstraint ContainValue(object expected)
• public class ExpectedExceptionAttribute : Attribute
• public class ExplicitAttribute : NUnitAttribute, IApplyToTest
  • public string Reason { get; }
  • public void ApplyToTest(Test test)
• public static class FileAssert
  • protected FileAssert()
  • public static void AreEqual(Stream expected, Stream actual, string message)
  • public static void AreEqual(FileInfo expected, FileInfo actual, string message)
  • public static void AreEqual(string expected, string actual, string message)
  • public static void AreNotEqual(Stream expected, Stream actual, string message)
  • public static void AreNotEqual(FileInfo expected, FileInfo actual, string message)
  • public static void AreNotEqual(string expected, string actual, string message)
  • public static void DoesNotExist(FileInfo actual, string message, object[] args)
  • public static void DoesNotExist(FileInfo actual)
  • public static void DoesNotExist(string actual, string message, object[] args)
  • public static void DoesNotExist(string actual)
  • public static void Exists(FileInfo actual, string message, object[] args)
  • public static void Exists(FileInfo actual)
  • public static void Exists(string actual, string message, object[] args)
  • public static void Exists(string actual)
• public class GlobalSettings
• public class Guard
• public class Has
  • public static ItemsConstraintExpression One { get; }
  • public static ConstraintExpression Exactly(int expectedCount)
  • public static CollectionContainsConstraint Member(object expected)
  • public static ItemsConstraintExpression Exactly(int expectedCount)
  • public static EqualConstraint Member(object expected)
• public interface IExpectException
• public class IgnoreAttribute : NUnitAttribute, IApplyToTest
  • public string Reason { get; }
  • public IgnoreAttribute()
  • public string Until { get; set; }
  • public void ApplyToTest(Test test)
• public interface INUnitEqualityComparer
• public interface INUnitEqualityComparer<T>
• public class Is
  • public static EqualConstraint Zero { get; }
  • public static RangeConstraint<T> InRange<T>(T from, T to) where T : IComparable<T>
  • public static RangeConstraint InRange(object from, object to)
  • public static InstanceOfTypeConstraint InstanceOfType(Type expectedType)
  • public static InstanceOfTypeConstraint InstanceOfType<T>()
  • public static SubstringConstraint StringContaining(string expected)
  • public static EndsWithConstraint StringEnding(string expected)
  • public static RegexConstraint StringMatching(string pattern)
  • public static StartsWithConstraint StringStarting(string expected)
  • public static SubPathConstraint SubPath(string expected)
  • public static SubPathConstraint SubPathOf(string expected)
  • public static CollectionSupersetConstraint SupersetOf(IEnumerable expected)
• public interface ITestAction
  • void AfterTest(TestDetails testDetails)
  • void BeforeTest(TestDetails testDetails)
  • void AfterTest(ITest test)
  • void BeforeTest(ITest test)
• public interface ITestCaseData
• public sealed class LevelOfParallelismAttribute : PropertyAttribute
  • public LevelOfParallelismAttribute(int level)
• public enum MessageMatch
• public class MultipleAssertException : ResultStateException
  • public MultipleAssertException()
  • public MultipleAssertException(string message, Exception inner)
  • protected MultipleAssertException(SerializationInfo info, StreamingContext context)
• public sealed class NonParallelizableAttribute : ParallelizableAttribute
  • public NonParallelizableAttribute()
• public class NonTestAssemblyAttribute : NUnitAttribute
  • public NonTestAssemblyAttribute()
• public abstract class NUnitAttribute : Attribute
  • public NUnitAttribute()
• public class OrderAttribute : NUnitAttribute, IApplyToTest
  • public readonly int Order
  • public OrderAttribute(int order)
  • public void ApplyToTest(Test test)
• public abstract class ParameterDataAttribute : Attribute
• public class ParallelizableAttribute : PropertyAttribute, IApplyToContext
  • public ParallelScope Scope { get; }
  • public ParallelizableAttribute()
  • public ParallelizableAttribute(ParallelScope scope)
  • public void ApplyToContext(TestExecutionContext context)
• public enum ParallelScope
  • All = 257
  • Children = 256
  • ContextMask = 768
  • Default = 0
  • Fixtures = 512
  • ItemMask = 3
  • None = 2
  • Self = 1
• public class PlatformAttribute : IncludeExcludeAttribute, IApplyToTest
  • public void ApplyToTest(Test test)
• public class PropertyAttribute : NUnitAttribute, IApplyToTest
  • public IDictionary Properties { get; }
  • public IPropertyBag Properties { get; }
  • public virtual void ApplyToTest(Test test)
• public class RandomAttribute : DataAttribute, IParameterDataSource
  • public bool Distinct { get; set; }
  • public RandomAttribute(double min, double max, int count)
  • public RandomAttribute(uint min, uint max, int count)
  • public RandomAttribute(long min, long max, int count)
  • public RandomAttribute(ulong min, ulong max, int count)
  • public RandomAttribute(short min, short max, int count)
  • public RandomAttribute(ushort min, ushort max, int count)
  • public RandomAttribute(double min, double max, int count)
  • public RandomAttribute(float min, float max, int count)
  • public RandomAttribute(byte min, byte max, int count)
  • public RandomAttribute(sbyte min, sbyte max, int count)
  • public IEnumerable GetData(IParameterInfo parameter)
• public class Randomizer : Random
• public class RangeAttribute : ValuesAttribute
  • public RangeAttribute(uint from, uint to)
  • public RangeAttribute(uint from, uint to, uint step)
  • public RangeAttribute(long from, long to)
  • public RangeAttribute(ulong from, ulong to)
  • public RangeAttribute(ulong from, ulong to, ulong step)
• public class RepeatAttribute : PropertyAttribute, IWrapSetUpTearDown, ICommandWrapper
  • public class RepeatedTestCommand : DelegatingTestCommand
  • public TestCommand Wrap(TestCommand command)
• public class RequiredAddinAttribute : Attribute
• public class RequiresMTAAttribute : PropertyAttribute
• public class RequiresSTAAttribute : PropertyAttribute
• public abstract class ResultStateException : Exception
  • public abstract ResultState ResultState { get; }
  • public ResultStateException(string message)
  • public ResultStateException(string message, Exception inner)
  • protected ResultStateException(SerializationInfo info, StreamingContext context)
• public class RetryAttribute : PropertyAttribute, IWrapSetUpTearDown, ICommandWrapper
  • public class RetryCommand : DelegatingTestCommand
  • public RetryAttribute(int tryCount)
  • public TestCommand Wrap(TestCommand command)
• public class SetUpFixtureAttribute : NUnitAttribute, IFixtureBuilder
  • public IEnumerable<TestSuite> BuildFrom(ITypeInfo typeInfo)
• public enum SpecialValue
• public class SingleThreadedAttribute : NUnitAttribute, IApplyToContext
  • public SingleThreadedAttribute()
  • public void ApplyToContext(TestExecutionContext context)
• public class StringAssert
  • public static void AreEqualIgnoringCase(string expected, string actual, string message)
  • public static void AreNotEqualIgnoringCase(string expected, string actual, string message)
  • public static void Contains(string expected, string actual, string message)
  • public static void DoesNotContain(string expected, string actual, string message)
  • public static void DoesNotEndWith(string expected, string actual, string message)
  • public static void DoesNotMatch(string pattern, string actual, string message)
  • public static void DoesNotStartWith(string expected, string actual, string message)
  • public static void EndsWith(string expected, string actual, string message)
  • public static void IsMatch(string pattern, string actual, string message)
  • public static void StartsWith(string expected, string actual, string message)
• public class SuiteAttribute : Attribute
• public abstract class TestActionAttribute : Attribute, ITestAction
  • public virtual void AfterTest(TestDetails testDetails)
  • public virtual void BeforeTest(TestDetails testDetails)
  • public virtual void AfterTest(ITest test)
  • public virtual void BeforeTest(ITest test)
• public class TestAssemblyDirectoryResolveAttribute : NUnitAttribute
  • public TestAssemblyDirectoryResolveAttribute()
• public class TestAttribute : NUnitAttribute, ISimpleTestBuilder, IApplyToTest, IImplyFixture
  • public string Author { get; set; }
  • public object ExpectedResult { get; set; }
  • public bool HasExpectedResult { get; }
  • public Type TestOf { get; set; }
  • public void ApplyToTest(Test test)
  • public TestMethod BuildFrom(IMethodInfo method, Test suite)
• public class TestCaseAttribute : NUnitAttribute, ITestBuilder, ITestCaseData, ITestData, IImplyFixture
  • public IList Categories { get; }
  • public string Author { get; set; }
  • public Type ExpectedException { get; set; }
  • public string ExpectedExceptionName { get; set; }
  • public string ExpectedMessage { get; set; }
  • public string ExcludePlatform { get; set; }
  • public bool Ignore { get; set; }
  • public bool Ignored { get; set; }
  • public string Ignore { get; set; }
  • public MessageMatch MatchType { get; set; }
  • public string IncludePlatform { get; set; }
  • public IPropertyBag Properties { get; }
  • public object Result { get; set; }
  • public RunState RunState { get; }
  • public Type TestOf { get; set; }
  • public IEnumerable<TestMethod> BuildFrom(IMethodInfo method, Test suite)
• public class TestCaseData : TestCaseParameters
  • public object[] Arguments { get; }
  • public IList Categories { get; }
  • public string Description { get; }
  • public Type ExpectedException { get; }
  • public string ExpectedExceptionName { get; }
  • public bool Explicit { get; }
  • public bool HasExpectedResult { get; }
  • public bool Ignored { get; }
  • public string IgnoreReason { get; }
  • public IDictionary Properties { get; }
  • public object Result { get; }
  • public string TestName { get; }
  • public TestCaseData Ignore()
  • public TestCaseData Explicit()
  • public TestCaseData Explicit(string reason)
  • public TestCaseData MakeExplicit()
  • public TestCaseData MakeExplicit(string reason)
  • public TestCaseData Throws(Type exceptionType)
  • public TestCaseData Throws(string exceptionName)
• public class TestCaseSourceAttribute : NUnitAttribute, ITestBuilder, IImplyFixture
  • public object[] MethodParams { get; }
  • public TestCaseSourceAttribute(Type sourceType)
  • public TestCaseSourceAttribute(Type sourceType, string sourceName, object[] methodParams)
  • public TestCaseSourceAttribute(string sourceName, object[] methodParams)
  • public TestCaseSourceAttribute(Type sourceType)
  • public IEnumerable<TestMethod> BuildFrom(IMethodInfo method, Test suite)
• public class TestContext
  • public static TextWriter Error
  • public static readonly TestParameters Parameters
  • public static readonly TextWriter Progress
  • public static TextWriter Out { get; }
  • public int AssertCount { get; }
  • public Randomizer Random { get; }
  • public TestContext(IDictionary context)
  • public string WorkerId { get; }
  • public TestContext(TestExecutionContext testExecutionContext)
  • public static void AddFormatter(ValueFormatterFactory formatterFactory)
  • public static void AddFormatter<TSUPPORTED>(ValueFormatter formatter)
  • public static void AddTestAttachment(string filePath, string description = null)
  • public static void Write(bool value)
  • public static void Write(char value)
  • public static void Write(char[] value)
  • public static void Write(double value)
  • public static void Write(int value)
  • public static void Write(long value)
  • public static void Write(decimal value)
  • public static void Write(object value)
  • public static void Write(float value)
  • public static void Write(string value)
  • public static void Write(uint value)
  • public static void Write(ulong value)
  • public static void Write(string format, object arg1)
  • public static void Write(string format, object arg1, object arg2)
  • public static void Write(string format, object arg1, object arg2, object arg3)
  • public static void Write(string format, object[] args)
  • public static void WriteLine()
  • public static void WriteLine(bool value)
  • public static void WriteLine(char value)
  • public static void WriteLine(char[] value)
  • public static void WriteLine(double value)
  • public static void WriteLine(int value)
  • public static void WriteLine(long value)
  • public static void WriteLine(decimal value)
  • public static void WriteLine(object value)
  • public static void WriteLine(float value)
  • public static void WriteLine(string value)
  • public static void WriteLine(uint value)
  • public static void WriteLine(ulong value)
  • public static void WriteLine(string format, object arg1)
  • public static void WriteLine(string format, object arg1, object arg2)
  • public static void WriteLine(string format, object arg1, object arg2, object arg3)
  • public static void WriteLine(string format, object[] args)
• public class TestDetails
• public class TestFixtureAttribute : NUnitAttribute, IFixtureBuilder, ITestFixtureData, ITestData
  • public IList Categories { get; }
  • public string Author { get; set; }
  • public bool Ignore { get; set; }
  • public bool Explicit { get; set; }
  • public string Ignore { get; set; }
  • public IPropertyBag Properties { get; }
  • public string Reason { get; set; }
  • public RunState RunState { get; }
  • public string TestName { get; set; }
  • public Type TestOf { get; set; }
  • public IEnumerable<TestSuite> BuildFrom(ITypeInfo typeInfo)
• public class TestFixtureSetUpAttribute : Attribute
• public class TestFixtureTearDownAttribute : Attribute
• public enum TestState
• public enum TestStatus
• public class Text
• public class TextMessageWriter : MessageWriter
• public class TestFixtureData : TestFixtureParameters
  • public TestFixtureData(object[] args)
  • public TestFixtureData(object arg)
  • public TestFixtureData(object arg1, object arg2)
  • public TestFixtureData(object arg1, object arg2, object arg3)
  • public TestFixtureData Explicit()
  • public TestFixtureData Explicit(string reason)
  • public TestFixtureData Ignore(string reason)
• public class TestFixtureSourceAttribute : NUnitAttribute, IFixtureBuilder
  • public const string MUST_BE_STATIC = "The sourceName specified on a TestCaseSourceAttribute must refer to a static field, property or method."
  • public string Category { get; set; }
  • public string SourceName { get; }
  • public Type SourceType { get; }
  • public TestFixtureSourceAttribute(string sourceName)
  • public TestFixtureSourceAttribute(Type sourceType, string sourceName)
  • public TestFixtureSourceAttribute(Type sourceType)
  • public IEnumerable<TestSuite> BuildFrom(ITypeInfo typeInfo)
  • public IEnumerable<ITestFixtureData> GetParametersFor(Type sourceType)
• public class TestOfAttribute : PropertyAttribute
  • public TestOfAttribute(Type type)
  • public TestOfAttribute(string typeName)
• public class TestParameters
  • public int Count { get; }
  • public string this[string name] { get; }
  • public ICollection<string> Names { get; }
  • public TestParameters()
  • public bool Exists(string name)
  • public string Get(string name)
  • public string Get(string name, string defaultValue)
  • public T Get<T>(string name, T defaultValue)
• public class Throws
  • public static ExactTypeConstraint ArgumentNullException { get; }
  • public Throws()
• public class ValuesAttribute : DataAttribute, IParameterDataSource
  • public ValuesAttribute()
  • public IEnumerable GetData(IParameterInfo parameter)
• public class ValueSourceAttribute : DataAttribute, IParameterDataSource
  • public IEnumerable GetData(IParameterInfo parameter)
• public class Warn
  • public Warn()
  • public static bool Equals(object a, object b)
  • public static void If<TActual>(ActualValueDelegate<TActual> del, IResolveConstraint expr)
  • public static void If<TActual>(ActualValueDelegate<TActual> del, IResolveConstraint expr, string message, object[] args)
  • public static void If(bool condition, string message, object[] args)
  • public static void If(bool condition)
  • public static void If<TActual>(TActual actual, IResolveConstraint expression)
  • public static void If<TActual>(TActual actual, IResolveConstraint expression, string message, object[] args)
  • public static void ReferenceEquals(object a, object b)
  • public static void Unless<TActual>(ActualValueDelegate<TActual> del, IResolveConstraint expr)
  • public static void Unless<TActual>(ActualValueDelegate<TActual> del, IResolveConstraint expr, string message, object[] args)
  • public static void Unless(bool condition, string message, object[] args)
  • public static void Unless(bool condition)
  • public static void Unless(TestDelegate code, IResolveConstraint constraint)
  • public static void Unless<TActual>(TActual actual, IResolveConstraint expression)
  • public static void Unless<TActual>(TActual actual, IResolveConstraint expression, string message, object[] args)

NUnit.Framework.Api

• public class DefaultTestAssemblyBuilder : ITestAssemblyBuilder
  • public DefaultTestAssemblyBuilder()
  • public ITest Build(Assembly assembly, IDictionary<string, object> options)
  • public ITest Build(string assemblyName, IDictionary<string, object> options)
• public class FrameworkController : LongLivedMarshalByRefObject
  • public class CountTestsAction : FrameworkControllerAction
  • public class ExploreTestsAction : FrameworkControllerAction
  • public abstract class FrameworkControllerAction : LongLivedMarshalByRefObject
  • public class LoadTestsAction : FrameworkControllerAction
  • public class RunAsyncAction : FrameworkControllerAction
  • public class RunTestsAction : FrameworkControllerAction
  • public class StopRunAction : FrameworkControllerAction
  • public Assembly Assembly { get; }
  • public string AssemblyNameOrPath { get; }
  • public ITestAssemblyBuilder Builder { get; }
  • public ITestAssemblyRunner Runner { get; }
  • public FrameworkController(string assemblyNameOrPath, string idPrefix, IDictionary settings)
  • public FrameworkController(Assembly assembly, string idPrefix, IDictionary settings)
  • public FrameworkController(string assemblyNameOrPath, string idPrefix, IDictionary settings, string runnerType, string builderType)
  • public FrameworkController(Assembly assembly, string idPrefix, IDictionary settings, string runnerType, string builderType)
  • public static TNode InsertEnvironmentElement(TNode targetNode)
  • public static TNode InsertSettingsElement(TNode targetNode, IDictionary<string, object> settings)
  • public int CountTests(string filter)
  • public string ExploreTests(string filter)
  • public string LoadTests()
  • public string RunTests(string filter)
  • public void StopRun(bool force)
• public interface ITestAssemblyBuilder
  • ITest Build(Assembly assembly, IDictionary<string, object> options)
  • ITest Build(string assemblyName, IDictionary<string, object> options)
• public interface ITestAssemblyRunner
  • bool IsTestComplete { get; }
  • bool IsTestLoaded { get; }
  • bool IsTestRunning { get; }
  • ITest LoadedTest { get; }
  • ITestResult Result { get; }
  • int CountTestCases(ITestFilter filter)
  • ITest ExploreTests(ITestFilter filter)
  • ITest Load(string assemblyName, IDictionary<string, object> settings)
  • ITest Load(Assembly assembly, IDictionary<string, object> settings)
  • ITestResult Run(ITestListener listener, ITestFilter filter)
  • void RunAsync(ITestListener listener, ITestFilter filter)
  • void StopRun(bool force)
  • bool WaitForCompletion(int timeout)
• public class NUnitTestAssemblyRunner : ITestAssemblyRunner
  • public static int DefaultLevelOfParallelism { get; }
  • public bool IsTestComplete { get; }
  • public bool IsTestLoaded { get; }
  • public bool IsTestRunning { get; }
  • public ITest LoadedTest { get; }
  • public ITestResult Result { get; }
  • public NUnitTestAssemblyRunner(ITestAssemblyBuilder builder)
  • public int CountTestCases(ITestFilter filter)
  • public ITest ExploreTests(ITestFilter filter)
  • public ITest Load(string assemblyName, IDictionary<string, object> settings)
  • public ITest Load(Assembly assembly, IDictionary<string, object> settings)
  • public ITestResult Run(ITestListener listener, ITestFilter filter)
  • public void RunAsync(ITestListener listener, ITestFilter filter)
  • public void StopRun(bool force)
  • public bool WaitForCompletion(int timeout)

NUnit.Framework.Constraints

• public sealed delegate ActualValueDelegate<TActual> : MulticastDelegate
  • public virtual T EndInvoke(IAsyncResult result)
  • public virtual T Invoke()
  • public virtual TActual EndInvoke(IAsyncResult result)
  • public virtual TActual Invoke()
• public class AllItemsConstraint : PrefixConstraint
  • public AllItemsConstraint(Constraint itemConstraint)
  • public AllItemsConstraint(IConstraint itemConstraint)
• public class AndConstraint : BinaryConstraint
  • public AndConstraint(Constraint left, Constraint right)
  • public AndConstraint(IConstraint left, IConstraint right)
• public class AttributeConstraint : PrefixConstraint
  • public AttributeConstraint(Type type, Constraint baseConstraint)
  • public AttributeConstraint(Type type, IConstraint baseConstraint)
• public abstract class BasicConstraint : Constraint
• public abstract class BinaryConstraint : Constraint
  • protected Constraint left
  • protected Constraint right
  • protected BinaryConstraint(Constraint left, Constraint right)
  • protected IConstraint Left
  • protected IConstraint Right
  • protected BinaryConstraint(IConstraint left, IConstraint right)
• public abstract class BinaryOperator : ConstraintOperator
  • public abstract Constraint ApplyOperator(Constraint left, Constraint right)
  • public abstract IConstraint ApplyOperator(IConstraint left, IConstraint right)
• public abstract class CollectionConstraint : Constraint
  • protected abstract bool doMatch(IEnumerable collection)
  • protected abstract bool Matches(IEnumerable collection)
• public class CollectionContainsConstraint : CollectionItemsEqualConstraint
  • protected object Expected { get; }
  • public CollectionContainsConstraint Using<TCollectionType, TMemberType>(Func<TCollectionType, TMemberType, bool> comparison)
• public class CollectionEquivalentConstraint : CollectionItemsEqualConstraint
  • public CollectionEquivalentConstraint Using<TActual, TExpected>(Func<TActual, TExpected, bool> comparison)
• public class CollectionEquivalentConstraintResult : ConstraintResult
  • public CollectionEquivalentConstraintResult(CollectionEquivalentConstraint constraint, CollectionTallyResult tallyResult, object actual, bool isSuccess)
• public class CollectionOrderedConstraint : CollectionConstraint
  • public CollectionOrderedConstraint Ascending { get; }
  • public CollectionOrderedConstraint Then { get; }
• public class CollectionSubsetConstraint : CollectionItemsEqualConstraint
  • public CollectionSubsetConstraint Using<TSubsetType, TSupersetType>(Func<TSubsetType, TSupersetType, bool> comparison)
• public class CollectionSupersetConstraint : CollectionItemsEqualConstraint
  • public CollectionSupersetConstraint(IEnumerable expected)
  • public CollectionSupersetConstraint Using<TSupersetType, TSubsetType>(Func<TSupersetType, TSubsetType, bool> comparison)
• public class CollectionTally
  • public int Count { get; }
  • public class CollectionTallyResult
  • public CollectionTallyResult Result { get; }
  • public bool TryRemove(object o)
  • public bool TryRemove(IEnumerable c)
  • public void TryRemove(object o)
  • public void TryRemove(IEnumerable c)
• public abstract class ComparisonConstraint : Constraint
  • protected ComparisonAdapter comparer
  • public ComparisonConstraint Percent { get; }
  • public ComparisonConstraint(object arg1, object arg2)
  • protected abstract bool PerformComparison(ComparisonAdapter comparer, object actual, object expected, Tolerance tolerance)
  • public ComparisonConstraint Within(object amount)
• public abstract class Constraint : IConstraint, IResolveConstraint
  • protected static object UNSET
  • protected object actual
  • public object[] Arguments { get; }
  • public ConstraintBuilder Builder { get; set; }
  • public virtual string Description { get; protected set; }
  • protected Constraint()
  • protected Constraint(object arg)
  • protected Constraint(object arg1, object arg2)
  • protected Constraint(object[] args)
  • public DelayedConstraint After(int delayInMilliseconds)
  • public WithRawDelayInterval After(int delay)
  • public abstract ConstraintResult ApplyTo<TActual>(TActual actual)
  • public virtual ConstraintResult ApplyTo<TActual>(ActualValueDelegate<TActual> del)
  • public virtual ConstraintResult ApplyTo<TActual>(ref TActual actual)
  • public abstract bool Matches(object actual)
  • public virtual bool Matches<T>(ActualValueDelegate<T> del)
  • public virtual bool Matches<T>(ref T actual)
  • public virtual void WriteActualValueTo(MessageWriter writer)
  • public abstract void WriteDescriptionTo(MessageWriter writer)
  • public virtual void WriteMessageTo(MessageWriter writer)
  • protected virtual object GetTestObject<TActual>(ActualValueDelegate<TActual> del)
• public class ConstraintBuilder : IResolveConstraint
  • public bool IsResolvable { get; }
  • public Constraint Resolve()
  • public IConstraint Resolve()
• public class ConstraintExpression
  • protected ConstraintBuilder builder
  • public Constraint Exist { get; }
  • public ItemsConstraintExpression One { get; }
  • public EqualConstraint Zero { get; }
  • public ConstraintExpression Append(ConstraintOperator op)
  • public ResolvableConstraintExpression Append(SelfResolvingOperator op)
  • public Constraint Append(Constraint constraint)
  • public CollectionContainsConstraint Contains(object expected)
  • public SomeItemsConstraint Contain(object expected)
  • public ContainsConstraint Contain(string expected)
  • public DictionaryContainsKeyConstraint ContainKey(object expected)
  • public SomeItemsConstraint Contains(object expected)
  • public DictionaryContainsValueConstraint ContainValue(object expected)
  • public EndsWithConstraint EndWith(string expected)
  • public ConstraintExpression Exactly(int expectedCount)
  • public ItemsConstraintExpression Exactly(int expectedCount)
  • public RangeConstraint<T> InRange<T>(T from, T to) where T : IComparable<T>
  • public RangeConstraint InRange(object from, object to)
  • public InstanceOfTypeConstraint InstanceOfType(Type expectedType)
  • public InstanceOfTypeConstraint InstanceOfType<T>()
  • public RegexConstraint Match(string pattern)
  • public Constraint Matches<T>(Predicate<T> predicate)
  • public Constraint Matches<TActual>(Predicate<TActual> predicate)
  • public CollectionContainsConstraint Member(object expected)
  • public SomeItemsConstraint Member(object expected)
  • public StartsWithConstraint StartWith(string expected)
  • public SubPathConstraint SubPath(string expected)
  • public SubPathConstraint SubPathOf(string expected)
  • public CollectionSupersetConstraint SupersetOf(IEnumerable expected)
• public abstract class ConstraintExpressionBase
• public class ConstraintFactory
• public class ConstraintResult
  • public object ActualValue { get; }
  • public string Description { get; }
  • public virtual bool IsSuccess { get; }
  • public string Name { get; }
  • public ConstraintStatus Status { get; set; }
  • public ConstraintResult(IConstraint constraint, object actualValue)
  • public ConstraintResult(IConstraint constraint, object actualValue, ConstraintStatus status)
  • public ConstraintResult(IConstraint constraint, object actualValue, bool isSuccess)
  • public virtual void WriteActualValueTo(MessageWriter writer)
  • public virtual void WriteMessageTo(MessageWriter writer)
• public enum ConstraintStatus
  • Error = 3
  • Failure = 2
  • Success = 1
  • Unknown = 0
• public class ContainsConstraint : Constraint
  • public ContainsConstraint Using(IComparer comparer)
  • public ContainsConstraint Using<T>(IComparer<T> comparer)
  • public ContainsConstraint Using<T>(Comparison<T> comparer)
  • public ContainsConstraint Using(IEqualityComparer comparer)
  • public ContainsConstraint Using<T>(IEqualityComparer<T> comparer)
• public class DelayedConstraint : PrefixConstraint
  • public DelayedConstraint(Constraint baseConstraint, int delayInMilliseconds)
  • public DelayedConstraint(Constraint baseConstraint, int delayInMilliseconds, int pollingInterval)
  • public class WithDimensionedDelayInterval : DelayedConstraint
  • public class WithRawDelayInterval : DelayedConstraint
  • public class WithRawPollingInterval : DelayedConstraint
  • protected Interval DelayInterval { get; protected set; }
  • protected Interval PollingInterval { get; protected set; }
  • public DelayedConstraint(IConstraint baseConstraint, int delayInMilliseconds)
  • public DelayedConstraint(IConstraint baseConstraint, int delayInMilliseconds, int pollingIntervalInMilliseconds)
• public class DictionaryContainsKeyConstraint : CollectionItemsEqualConstraint
  • protected object Expected { get; }
  • public DictionaryContainsKeyConstraint(object expected)
  • public DictionaryContainsKeyConstraint Using<TCollectionType, TMemberType>(Func<TCollectionType, TMemberType, bool> comparison)
• public class DictionaryContainsValueConstraint : CollectionItemsEqualConstraint
  • protected object Expected { get; }
  • public DictionaryContainsValueConstraint(object expected)
  • public DictionaryContainsValueConstraint Using<TCollectionType, TMemberType>(Func<TCollectionType, TMemberType, bool> comparison)
• public class EqualConstraint : Constraint
  • public bool CaseInsensitive { get; }
  • public bool ClipStrings { get; }
  • public IList<FailurePoint> FailurePoints { get; }
  • public Tolerance Tolerance { get; }
  • public EqualConstraint WithSameOffset { get; }
  • public EqualConstraint Comparer(IComparer comparer)
  • public EqualConstraint Using<TCollectionType, TMemberType>(Func<TCollectionType, TMemberType, bool> comparison)
• public class EqualConstraintResult : ConstraintResult
  • public EqualConstraintResult(EqualConstraint constraint, object actual, bool hasSucceeded)
• public abstract class EqualityAdapter
  • public static EqualityAdapter For<TExpected, TActual>(Func<TExpected, TActual, bool> comparison)
• public class ExactCountConstraint : Constraint
  • public ExactCountConstraint(int expectedCount, Constraint itemConstraint)
  • public ExactCountConstraint(int expectedCount)
  • public ExactCountConstraint(int expectedCount, IConstraint itemConstraint)
• public class FailurePoint
• public class FileExistsConstraint : FileOrDirectoryExistsConstraint
  • public FileExistsConstraint()
• public class FileOrDirectoryExistsConstraint : Constraint
  • public FileOrDirectoryExistsConstraint IgnoreDirectories { get; }
  • public FileOrDirectoryExistsConstraint IgnoreFiles { get; }
  • public FileOrDirectoryExistsConstraint()
  • public FileOrDirectoryExistsConstraint(bool ignoreDirectories)
• public interface IConstraint : IResolveConstraint
  • object[] Arguments { get; }
  • ConstraintBuilder Builder { get; set; }
  • string Description { get; }
  • string DisplayName { get; }
  • ConstraintResult ApplyTo<TActual>(TActual actual)
  • ConstraintResult ApplyTo<TActual>(ActualValueDelegate<TActual> del)
  • ConstraintResult ApplyTo<TActual>(ref TActual actual)
• public class Interval
  • public TimeSpan AsTimeSpan { get; }
  • public Interval InMilliseconds { get; }
  • public Interval InMinutes { get; }
  • public Interval InSeconds { get; }
  • public bool IsNotZero { get; }
  • public Interval(int value)
• public interface IResolveConstraint
  • Constraint Resolve()
  • IConstraint Resolve()
• public sealed class ItemsConstraintExpression : ConstraintExpression
  • public ResolvableConstraintExpression Items { get; }
  • public ItemsConstraintExpression()
  • public ItemsConstraintExpression(ConstraintBuilder builder)
• public abstract class MessageWriter : StringWriter
  • public abstract void DisplayDifferences(Constraint constraint)
  • public abstract void DisplayDifferences(ConstraintResult result)
  • public abstract void WriteCollectionElements(IEnumerable collection, int start, int max)
  • public abstract void WriteConnector(string connector)
  • public abstract void WriteExpectedValue(object expected)
  • public abstract void WriteCollectionElements(IEnumerable collection, long start, int max)
  • public abstract void WriteModifier(string modifier)
  • public abstract void WritePredicate(string predicate)
• public class MsgUtils
• public class NoItemConstraint : PrefixConstraint
  • public NoItemConstraint(Constraint itemConstraint)
  • public NoItemConstraint(IConstraint itemConstraint)
• public class NotConstraint : PrefixConstraint
  • public NotConstraint(Constraint baseConstraint)
  • public NotConstraint(IConstraint baseConstraint)
• public class NullOrEmptyStringConstraint : Constraint
• public class NUnitComparer<T> : IComparer<T>
• public class NUnitEqualityComparer
  • public class FailurePoint
  • public IList<FailurePoint> FailurePoints { get; }
  • public IList<FailurePoint> FailurePoints { get; }
  • public NUnitEqualityComparer()
  • public bool WithSameOffset { get; set; }
• public class OrConstraint : BinaryConstraint
  • public OrConstraint(Constraint left, Constraint right)
  • public OrConstraint(IConstraint left, IConstraint right)
• public abstract class PathConstraint : StringConstraint
  • protected bool caseInsensitive
  • protected string expectedPath
  • public PathConstraint IgnoreCase { get; }
  • protected static bool IsSubPath(string path1, string path2, bool ignoreCase)
  • protected abstract bool IsMatch(string expectedPath, string actualPath)
  • protected bool IsSubPath(string path1, string path2)
• public abstract class PrefixConstraint : Constraint
  • protected Constraint baseConstraint
  • protected IConstraint BaseConstraint { get; protected set; }
  • protected string DescriptionPrefix { get; protected set; }
• public abstract class PrefixOperator : ConstraintOperator
  • public abstract Constraint ApplyPrefix(Constraint constraint)
  • public abstract IConstraint ApplyPrefix(IConstraint constraint)
• public class PropertyConstraint : PrefixConstraint
  • public PropertyConstraint(string name, Constraint baseConstraint)
  • public PropertyConstraint(string name, IConstraint baseConstraint)
• public class RangeConstraint<T> : ComparisonConstraint where T : IComparable<T>
• public class RangeConstraint : Constraint
  • public RangeConstraint(object from, object to)
  • public RangeConstraint Using(IComparer comparer)
  • public RangeConstraint Using<T>(IComparer<T> comparer)
  • public RangeConstraint Using<T>(Comparison<T> comparer)
• public class ResolvableConstraintExpression : ConstraintExpression, IResolveConstraint
  • public static Constraint op_BitwiseAnd(ResolvableConstraintExpression left, ResolvableConstraintExpression right)
  • public static Constraint op_BitwiseAnd(Constraint left, ResolvableConstraintExpression right)
  • public static Constraint op_BitwiseAnd(ResolvableConstraintExpression left, Constraint right)
  • public static Constraint op_BitwiseOr(ResolvableConstraintExpression left, ResolvableConstraintExpression right)
  • public static Constraint op_BitwiseOr(ResolvableConstraintExpression left, Constraint right)
  • public static Constraint op_BitwiseOr(Constraint left, ResolvableConstraintExpression right)
  • public static Constraint op_LogicalNot(ResolvableConstraintExpression constraint)
• public class ReusableConstraint : IResolveConstraint
  • public Constraint Resolve()
  • public IConstraint Resolve()
• public class SomeItemsConstraint : PrefixConstraint
  • public SomeItemsConstraint(Constraint itemConstraint)
  • public SomeItemsConstraint(IConstraint itemConstraint)
• public abstract class StringConstraint : Constraint
  • protected string descriptionText
  • protected StringConstraint()
• public class SubstringConstraint : StringConstraint
  • public SubstringConstraint Using(StringComparison comparisonType)
• public class ThrowsConstraint : PrefixConstraint
  • public ThrowsConstraint(Constraint baseConstraint)
  • public ThrowsConstraint(IConstraint baseConstraint)
• public class ThrowsExceptionConstraint : Constraint
  • public ThrowsExceptionConstraint()
• public class Tolerance
  • public static Tolerance Empty { get; }
  • public static Tolerance Zero { get; }
  • public class Range
  • public static Tolerance Default { get; }
  • public static Tolerance Exact { get; }
  • public object Amount { get; }
  • public bool IsEmpty { get; }
  • public bool IsUnsetOrDefault { get; }
  • public object Value { get; }
  • public Range ApplyToValue(object value)
• public enum ToleranceMode
  • None = 0
  • Unset = 0
• public abstract class TypeConstraint : Constraint
  • protected Type actualType
  • protected TypeConstraint(Type type)
  • protected TypeConstraint(Type type, string descriptionPrefix)
  • protected abstract bool Matches(object actual)
• public sealed delegate ValueFormatter : MulticastDelegate
  • public ValueFormatter(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(object val, AsyncCallback callback, object object)
  • public virtual string EndInvoke(IAsyncResult result)
  • public virtual string Invoke(object val)
• public sealed delegate ValueFormatterFactory : MulticastDelegate
  • public ValueFormatterFactory(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ValueFormatter next, AsyncCallback callback, object object)
  • public virtual ValueFormatter EndInvoke(IAsyncResult result)
  • public virtual ValueFormatter Invoke(ValueFormatter next)

NUnit.Framework.Interfaces

• public class AssertionResult
  • public string Message { get; }
  • public string StackTrace { get; }
  • public AssertionStatus Status { get; }
  • public AssertionResult(AssertionStatus status, string message, string stackTrace)
• public enum AssertionStatus
  • Error = 4
  • Failed = 3
  • Inconclusive = 0
  • Passed = 1
  • Warning = 2
• public class AttributeDictionary : Dictionary<string, string>
  • public string this[string key] { get; }
  • public AttributeDictionary()
• public enum FailureSite
  • Child = 4
  • Parent = 3
  • SetUp = 1
  • TearDown = 2
  • Test = 0
• public interface IApplyToContext
  • void ApplyToContext(TestExecutionContext context)
• public interface IApplyToTest
  • void ApplyToTest(Test test)
• public interface ICombiningStrategy
  • IEnumerable<ITestCaseData> GetTestCases(IEnumerable[] sources)
• public interface ICommandWrapper
  • TestCommand Wrap(TestCommand command)
• public interface IFixtureBuilder
  • IEnumerable<TestSuite> BuildFrom(ITypeInfo typeInfo)
• public interface IImplyFixture
• public interface IMethodInfo : IReflectionInfo
  • bool ContainsGenericParameters { get; }
  • bool IsAbstract { get; }
  • bool IsGenericMethod { get; }
  • bool IsGenericMethodDefinition { get; }
  • bool IsPublic { get; }
  • MethodInfo MethodInfo { get; }
  • string Name { get; }
  • ITypeInfo ReturnType { get; }
  • ITypeInfo TypeInfo { get; }
  • Type[] GetGenericArguments()
  • IParameterInfo[] GetParameters()
  • object Invoke(object fixture, object[] args)
  • IMethodInfo MakeGenericMethod(Type[] typeArguments)
• public interface IParameterDataProvider
  • IEnumerable GetDataFor(IParameterInfo parameter)
  • bool HasDataFor(IParameterInfo parameter)
• public interface IParameterDataSource
  • IEnumerable GetData(IParameterInfo parameter)
• public interface IParameterInfo : IReflectionInfo
  • bool IsOptional { get; }
  • IMethodInfo Method { get; }
  • ParameterInfo ParameterInfo { get; }
  • Type ParameterType { get; }
• public interface IPropertyBag : IXmlNodeBuilder
  • IList this[string key] { get; set; }
  • ICollection<string> Keys { get; }
  • void Add(string key, object value)
  • bool ContainsKey(string key)
  • object Get(string key)
  • void Set(string key, object value)
• public interface IReflectionInfo
  • T[] GetCustomAttributes<T>(bool inherit)
  • bool IsDefined<T>(bool inherit)
• public interface ISimpleTestBuilder
  • TestMethod BuildFrom(IMethodInfo method, Test suite)
• public interface ISuiteBuilder
  • TestSuite BuildFrom(ITypeInfo typeInfo)
  • bool CanBuildFrom(ITypeInfo typeInfo)
• public interface ITest : IXmlNodeBuilder
  • object[] Arguments { get; }
  • string ClassName { get; }
  • object Fixture { get; }
  • string FullName { get; }
  • bool HasChildren { get; }
  • string Id { get; }
  • bool IsSuite { get; }
  • IMethodInfo Method { get; }
  • string MethodName { get; }
  • string Name { get; }
  • ITest Parent { get; }
  • IPropertyBag Properties { get; }
  • RunState RunState { get; }
  • int TestCaseCount { get; }
  • IList<ITest> Tests { get; }
  • string TestType { get; }
  • ITypeInfo TypeInfo { get; }
• public interface ITestBuilder
  • IEnumerable<TestMethod> BuildFrom(IMethodInfo method, Test suite)
• public interface ITestCaseBuilder
  • Test BuildFrom(IMethodInfo method, Test suite)
  • bool CanBuildFrom(IMethodInfo method, Test suite)
• public interface ITestCaseData : ITestData
  • object ExpectedResult { get; }
  • bool HasExpectedResult { get; }
• public interface ITestData
  • object[] Arguments { get; }
  • IPropertyBag Properties { get; }
  • RunState RunState { get; }
  • string TestName { get; }
• public interface ITestFilter : IXmlNodeBuilder
  • bool IsExplicitMatch(ITest test)
  • bool Pass(ITest test)
• public interface ITestFixtureData : ITestData
  • Type[] TypeArgs { get; }
• public interface ITestListener
  • void TestFinished(ITestResult result)
  • void TestOutput(TestOutput output)
  • void TestStarted(ITest test)
• public interface ITestResult : IXmlNodeBuilder
  • int AssertCount { get; }
  • IList<AssertionResult> AssertionResults { get; }
  • IEnumerable<ITestResult> Children { get; }
  • double Duration { get; }
  • DateTime EndTime { get; }
  • int FailCount { get; }
  • string FullName { get; }
  • bool HasChildren { get; }
  • int InconclusiveCount { get; }
  • string Message { get; }
  • string Name { get; }
  • string Output { get; }
  • int PassCount { get; }
  • ResultState ResultState { get; }
  • int SkipCount { get; }
  • string StackTrace { get; }
  • DateTime StartTime { get; }
  • ITest Test { get; }
  • ICollection<TestAttachment> TestAttachments { get; }
  • int WarningCount { get; }
• public interface ITypeInfo : IReflectionInfo
  • Assembly Assembly { get; }
  • ITypeInfo BaseType { get; }
  • bool ContainsGenericParameters { get; }
  • string FullName { get; }
  • bool IsAbstract { get; }
  • bool IsGenericType { get; }
  • bool IsGenericTypeDefinition { get; }
  • bool IsSealed { get; }
  • bool IsStaticClass { get; }
  • string Name { get; }
  • string Namespace { get; }
  • Type Type { get; }
  • object Construct(object[] args)
  • ConstructorInfo GetConstructor(Type[] argTypes)
  • string GetDisplayName()
  • string GetDisplayName(object[] args)
  • Type GetGenericTypeDefinition()
  • IMethodInfo[] GetMethods(BindingFlags flags)
  • bool HasConstructor(Type[] argTypes)
  • bool HasMethodWithAttribute(Type attrType)
  • bool IsType(Type type)
  • ITypeInfo MakeGenericType(Type[] typeArgs)
• public interface IWrapSetUpTearDown : ICommandWrapper
• public interface IWrapTestMethod : ICommandWrapper
• public interface IXmlNodeBuilder
  • TNode AddToXml(TNode parentNode, bool recursive)
  • TNode ToXml(bool recursive)
• public class NodeList : List<TNode>
  • public NodeList()
• public class ResultState
  • public static readonly ResultState Cancelled
  • public static readonly ResultState ChildFailure
  • public static readonly ResultState Error
  • public static readonly ResultState Explicit
  • public static readonly ResultState Failure
  • public static readonly ResultState Ignored
  • public static readonly ResultState Inconclusive
  • public static readonly ResultState NotRunnable
  • public static readonly ResultState SetUpError
  • public static readonly ResultState SetUpFailure
  • public static readonly ResultState Skipped
  • public static readonly ResultState Success
  • public static readonly ResultState TearDownError
  • public static readonly ResultState Warning
  • public string Label { get; }
  • public FailureSite Site { get; }
  • public TestStatus Status { get; }
  • public ResultState(TestStatus status)
  • public ResultState(TestStatus status, string label)
  • public ResultState(TestStatus status, FailureSite site)
  • public ResultState(TestStatus status, string label, FailureSite site)
  • public bool Matches(ResultState other)
  • public ResultState WithSite(FailureSite site)
• public enum RunState
  • Explicit = 2
  • Ignored = 4
  • NotRunnable = 0
  • Runnable = 1
  • Skipped = 3
• public class TestAttachment
  • public string Description { get; }
  • public string FilePath { get; }
  • public TestAttachment(string filePath, string description)
• public class TestOutput
  • public string Stream { get; }
  • public string TestName { get; }
  • public string Text { get; }
  • public TestOutput(string text, string stream, string testName)
  • public string ToXml()
• public enum TestStatus
  • Failed = 4
  • Inconclusive = 0
  • Passed = 2
  • Skipped = 1
  • Warning = 3
• public class TNode
  • public AttributeDictionary Attributes { get; }
  • public NodeList ChildNodes { get; }
  • public TNode FirstChild { get; }
  • public string Name { get; }
  • public string OuterXml { get; }
  • public string Value { get; set; }
  • public bool ValueIsCDATA { get; }
  • public TNode(string name)
  • public TNode(string name, string value)
  • public TNode(string name, string value, bool valueIsCDATA)
  • public static TNode FromXml(string xmlText)
  • public void AddAttribute(string name, string value)
  • public TNode AddElement(string name)
  • public TNode AddElement(string name, string value)
  • public TNode AddElementWithCDATA(string name, string value)
  • public NodeList SelectNodes(string xpath)
  • public TNode SelectSingleNode(string xpath)
  • public void WriteTo(XmlWriter writer)

NUnit.Framework.Internal

• public static class AssemblyHelper
  • public static AssemblyName GetAssemblyName(Assembly assembly)
  • public static string GetAssemblyPath(Assembly assembly)
  • public static string GetAssemblyPathFromCodeBase(string codeBase)
  • public static string GetDirectoryName(Assembly assembly)
  • public static Assembly Load(string nameOrPath)
• public class CultureDetector
  • public string Reason { get; }
  • public CultureDetector()
  • public CultureDetector(string culture)
  • public bool IsCultureSupported(string[] cultures)
  • public bool IsCultureSupported(CultureAttribute cultureAttribute)
  • public bool IsCultureSupported(string culture)
• public class ExceptionHelper
  • public ExceptionHelper()
  • public static string BuildMessage(Exception exception, bool excludeExceptionNames = false)
  • public static string BuildStackTrace(Exception exception)
  • public static void Rethrow(Exception exception)
• public class GenericMethodHelper
  • public GenericMethodHelper(MethodInfo method)
  • public Type[] GetTypeArguments(object[] argList)
• public interface ILogger
  • void Debug(string message)
  • void Debug(string message, object[] args)
  • void Error(string message)
  • void Error(string message, object[] args)
  • void Info(string message)
  • void Info(string message, object[] args)
  • void Warning(string message)
  • void Warning(string message, object[] args)
• public static class InternalTrace
  • public static bool Initialized { get; }
  • public static Logger GetLogger(string name)
  • public static Logger GetLogger(Type type)
  • public static void Initialize(string logName, InternalTraceLevel level)
  • public static void Initialize(TextWriter writer, InternalTraceLevel level)
• public enum InternalTraceLevel
  • Debug = 5
  • Default = 0
  • Error = 2
  • Info = 4
  • Off = 1
  • Verbose = 5
  • Warning = 3
• public class InternalTraceWriter : TextWriter
  • public InternalTraceWriter(string logPath)
  • public InternalTraceWriter(TextWriter writer)
• public class InvalidDataSourceException : Exception
  • public InvalidDataSourceException()
  • public InvalidDataSourceException(string message)
  • public InvalidDataSourceException(string message, Exception inner)
  • protected InvalidDataSourceException(SerializationInfo info, StreamingContext context)
• public class InvalidTestFixtureException : Exception
  • public InvalidTestFixtureException()
  • public InvalidTestFixtureException(string message)
  • public InvalidTestFixtureException(string message, Exception inner)
  • protected InvalidTestFixtureException(SerializationInfo info, StreamingContext context)
• public class Logger : ILogger
  • public Logger(string name, InternalTraceLevel level, TextWriter writer)
  • public void Debug(string message)
  • public void Debug(string message, object[] args)
  • public void Error(string message)
  • public void Error(string message, object[] args)
  • public void Info(string message)
  • public void Info(string message, object[] args)
  • public void Warning(string message)
  • public void Warning(string message, object[] args)
• public class MethodWrapper : IMethodInfo, IReflectionInfo
  • public bool ContainsGenericParameters { get; }
  • public bool IsAbstract { get; }
  • public bool IsGenericMethod { get; }
  • public bool IsGenericMethodDefinition { get; }
  • public bool IsPublic { get; }
  • public MethodInfo MethodInfo { get; }
  • public string Name { get; }
  • public ITypeInfo ReturnType { get; }
  • public ITypeInfo TypeInfo { get; }
  • public MethodWrapper(Type type, MethodInfo method)
  • public MethodWrapper(Type type, string methodName)
  • public T[] GetCustomAttributes<T>(bool inherit)
  • public Type[] GetGenericArguments()
  • public IParameterInfo[] GetParameters()
  • public object Invoke(object fixture, object[] args)
  • public bool IsDefined<T>(bool inherit)
  • public IMethodInfo MakeGenericMethod(Type[] typeArguments)
• public class NUnitException : Exception
  • public NUnitException()
  • public NUnitException(string message)
  • public NUnitException(string message, Exception inner)
  • protected NUnitException(SerializationInfo info, StreamingContext context)
• public class OSPlatform
  • public enum ProductType
  • public static readonly PlatformID MacOSXPlatformID
  • public static readonly PlatformID UnixPlatformID_Microsoft
  • public static readonly PlatformID UnixPlatformID_Mono
  • public static readonly PlatformID XBoxPlatformID
  • public static OSPlatform CurrentPlatform { get; }
  • public bool IsMacOSX { get; }
  • public bool IsNT3 { get; }
  • public bool IsNT4 { get; }
  • public bool IsNT5 { get; }
  • public bool IsNT6 { get; }
  • public bool IsNT60 { get; }
  • public bool IsNT61 { get; }
  • public bool IsNT62 { get; }
  • public bool IsNT63 { get; }
  • public bool IsUnix { get; }
  • public bool IsVista { get; }
  • public bool IsWin2003Server { get; }
  • public bool IsWin2008Server { get; }
  • public bool IsWin2008ServerR1 { get; }
  • public bool IsWin2008ServerR2 { get; }
  • public bool IsWin2012Server { get; }
  • public bool IsWin2012ServerR1 { get; }
  • public bool IsWin2012ServerR2 { get; }
  • public bool IsWin2K { get; }
  • public bool IsWin32NT { get; }
  • public bool IsWin32S { get; }
  • public bool IsWin32Windows { get; }
  • public bool IsWin95 { get; }
  • public bool IsWin98 { get; }
  • public bool IsWinCE { get; }
  • public bool IsWindows { get; }
  • public bool IsWindows10 { get; }
  • public bool IsWindows7 { get; }
  • public bool IsWindows8 { get; }
  • public bool IsWindows81 { get; }
  • public bool IsWindowsServer10 { get; }
  • public bool IsWinME { get; }
  • public bool IsWinXP { get; }
  • public bool IsXbox { get; }
  • public PlatformID Platform { get; }
  • public ProductType Product { get; }
  • public Version Version { get; }
  • public OSPlatform(PlatformID platform, Version version)
  • public OSPlatform(PlatformID platform, Version version, ProductType product)
• public class ParameterizedFixtureSuite : TestSuite
  • public ParameterizedFixtureSuite(ITypeInfo typeInfo)
• public class ParameterizedMethodSuite : TestSuite
  • public ParameterizedMethodSuite(IMethodInfo method)
• public class ParameterWrapper : IParameterInfo, IReflectionInfo
  • public bool IsOptional { get; }
  • public IMethodInfo Method { get; }
  • public ParameterInfo ParameterInfo { get; }
  • public Type ParameterType { get; }
  • public ParameterWrapper(IMethodInfo method, ParameterInfo parameterInfo)
  • public T[] GetCustomAttributes<T>(bool inherit)
  • public bool IsDefined<T>(bool inherit)
• public class PlatformHelper
  • public const string OSPlatforms = "Win,Win32,Win32S,Win32NT,Win32Windows,Win95,Win98,WinMe,NT3,NT4,NT5,NT6,Win2008Server,Win2008ServerR2,Win2012Server,Win2012ServerR2,Win2K,WinXP,Win2003Server,Vista,Win7,Windows7,Win8,Windows8,Win8.1,Windows8.1,Win10,Windows10,WindowsServer10,Unix,Linux,Xbox,MacOSX"
  • public static readonly string RuntimePlatforms
  • public string Reason { get; }
  • public PlatformHelper()
  • public PlatformHelper(OSPlatform os, RuntimeFramework rt)
  • public bool IsPlatformSupported(string[] platforms)
  • public bool IsPlatformSupported(PlatformAttribute platformAttribute)
  • public bool IsPlatformSupported(TestCaseAttribute testCaseAttribute)
  • public bool IsPlatformSupported(string platform)
• public class PropertyBag : IPropertyBag, IXmlNodeBuilder
  • public IList this[string key] { get; set; }
  • public ICollection<string> Keys { get; }
  • public PropertyBag()
  • public void Add(string key, object value)
  • public TNode AddToXml(TNode parentNode, bool recursive)
  • public bool ContainsKey(string key)
  • public object Get(string key)
  • public void Set(string key, object value)
  • public TNode ToXml(bool recursive)
• public class PropertyNames
  • public const string ApartmentState = "ApartmentState"
  • public const string AppDomain = "_APPDOMAIN"
  • public const string Author = "Author"
  • public const string Category = "Category"
  • public const string Description = "Description"
  • public const string IgnoreUntilDate = "IgnoreUntilDate"
  • public const string JoinType = "_JOINTYPE"
  • public const string LevelOfParallelism = "LevelOfParallelism"
  • public const string MaxTime = "MaxTime"
  • public const string Order = "Order"
  • public const string ParallelScope = "ParallelScope"
  • public const string ProcessID = "_PID"
  • public const string ProviderStackTrace = "_PROVIDERSTACKTRACE"
  • public const string RepeatCount = "Repeat"
  • public const string RequiresThread = "RequiresThread"
  • public const string SetCulture = "SetCulture"
  • public const string SetUICulture = "SetUICulture"
  • public const string SkipReason = "_SKIPREASON"
  • public const string TestOf = "TestOf"
  • public const string Timeout = "Timeout"
  • public PropertyNames()
• public class Randomizer : Random
  • public const string DefaultStringChars = "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZ0123456789_"
  • public static int InitialSeed { get; set; }
  • public Randomizer()
  • public Randomizer(int seed)
  • public static Randomizer CreateRandomizer()
  • public static Randomizer GetRandomizer(MemberInfo member)
  • public static Randomizer GetRandomizer(ParameterInfo parameter)
  • public string GetString(int outputLength, string allowedChars)
  • public string GetString(int outputLength)
  • public string GetString()
  • public bool NextBool()
  • public bool NextBool(double probability)
  • public byte NextByte()
  • public byte NextByte(byte max)
  • public byte NextByte(byte min, byte max)
  • public decimal NextDecimal()
  • public decimal NextDecimal(decimal max)
  • public decimal NextDecimal(decimal min, decimal max)
  • public double NextDouble(double max)
  • public double NextDouble(double min, double max)
  • public object NextEnum(Type type)
  • public T NextEnum<T>()
  • public float NextFloat()
  • public float NextFloat(float max)
  • public float NextFloat(float min, float max)
  • public Guid NextGuid()
  • public long NextLong()
  • public long NextLong(long max)
  • public long NextLong(long min, long max)
  • public sbyte NextSByte()
  • public sbyte NextSByte(sbyte max)
  • public sbyte NextSByte(sbyte min, sbyte max)
  • public short NextShort()
  • public short NextShort(short max)
  • public short NextShort(short min, short max)
  • public uint NextUInt()
  • public uint NextUInt(uint max)
  • public uint NextUInt(uint min, uint max)
  • public ulong NextULong()
  • public ulong NextULong(ulong max)
  • public ulong NextULong(ulong min, ulong max)
  • public ushort NextUShort()
  • public ushort NextUShort(ushort max)
  • public ushort NextUShort(ushort min, ushort max)
• public static class Reflect
  • public static object Construct(Type type)
  • public static object Construct(Type type, object[] arguments)
  • public static MethodInfo[] GetMethodsWithAttribute(Type fixtureType, Type attributeType, bool inherit)
  • public static bool HasMethodWithAttribute(Type fixtureType, Type attributeType)
  • public static object InvokeMethod(MethodInfo method, object fixture)
  • public static object InvokeMethod(MethodInfo method, object fixture, object[] args)
• public sealed class RuntimeFramework
  • public static readonly Version DefaultVersion
  • public static RuntimeFramework CurrentFramework { get; }
  • public bool AllowAnyVersion { get; }
  • public Version ClrVersion { get; }
  • public string DisplayName { get; }
  • public Version FrameworkVersion { get; }
  • public RuntimeType Runtime { get; }
  • public RuntimeFramework(RuntimeType runtime, Version version)
  • public static RuntimeFramework Parse(string s)
  • public bool Supports(RuntimeFramework target)
• public enum RuntimeType
  • Any = 0
  • Mono = 3
  • MonoTouch = 4
  • Net = 1
  • SSCLI = 2
• public class SetUpFixture : TestSuite, IDisposableFixture
  • public SetUpFixture(ITypeInfo type)
• public class StackFilter
  • public static StackFilter DefaultFilter
  • public StackFilter(string topOfStackPattern, string bottomOfStackPattern)
  • public StackFilter(string topOfStackPattern)
  • public StackFilter()
  • public string Filter(string rawTrace)
• public class StringUtil
  • public StringUtil()
  • public static int Compare(string strA, string strB, bool ignoreCase)
  • public static bool StringsEqual(string strA, string strB, bool ignoreCase)
• public abstract class Test : ITest, IXmlNodeBuilder, IComparable
  • protected ITypeInfo DeclaringTypeInfo
  • public static string IdPrefix { get; set; }
  • public abstract object[] Arguments { get; }
  • public string ClassName { get; }
  • public virtual object Fixture { get; set; }
  • public string FullName { get; set; }
  • public abstract bool HasChildren { get; }
  • public string Id { get; set; }
  • public bool IsSuite { get; }
  • public IMethodInfo Method { get; set; }
  • public virtual string MethodName { get; }
  • public string Name { get; set; }
  • public ITest Parent { get; set; }
  • public IPropertyBag Properties { get; }
  • public RunState RunState { get; set; }
  • public int Seed { get; set; }
  • public MethodInfo[] SetUpMethods { get; protected set; }
  • public MethodInfo[] TearDownMethods { get; protected set; }
  • public virtual int TestCaseCount { get; }
  • public abstract IList<ITest> Tests { get; }
  • public virtual string TestType { get; }
  • public ITypeInfo TypeInfo { get; }
  • public abstract string XmlElementName { get; }
  • protected Test(string name)
  • protected Test(string pathName, string name)
  • protected Test(ITypeInfo typeInfo)
  • protected Test(IMethodInfo method)
  • public abstract TNode AddToXml(TNode parentNode, bool recursive)
  • public void ApplyAttributesToTest(ICustomAttributeProvider provider)
  • public int CompareTo(object obj)
  • public virtual TAttr[] GetCustomAttributes<TAttr>(bool inherit)
  • public void MakeInvalid(string reason)
  • public abstract TestResult MakeTestResult()
  • protected void PopulateTestNode(TNode thisNode, bool recursive)
  • public TNode ToXml(bool recursive)
• public class TestAssembly : TestSuite
  • public Assembly Assembly { get; }
  • public TestAssembly(Assembly assembly, string path)
  • public TestAssembly(string path)
  • public TestAssembly(TestAssembly assembly, ITestFilter filter)
• public class TestCaseParameters : TestParameters, ITestCaseData, ITestData, IApplyToTest
  • public object ExpectedResult { get; set; }
  • public bool HasExpectedResult { get; set; }
  • public TestCaseParameters()
  • public TestCaseParameters(Exception exception)
  • public TestCaseParameters(object[] args)
  • public TestCaseParameters(ITestCaseData data)
• public class TestCaseResult : TestResult
  • public TestCaseResult(TestMethod test)
• public class TestCaseTimeoutException : Exception
  • public TestCaseTimeoutException()
  • public TestCaseTimeoutException(string message)
  • public TestCaseTimeoutException(string message, Exception inner)
  • protected TestCaseTimeoutException(SerializationInfo info, StreamingContext context)
• public class TestExecutionContext : LongLivedMarshalByRefObject, ILogicalThreadAffinative
  • public class AdhocContext : TestExecutionContext
  • public class IsolatedContext : IDisposable
  • public static TestExecutionContext CurrentContext { get; }
  • public CultureInfo CurrentCulture { get; set; }
  • public IPrincipal CurrentPrincipal { get; set; }
  • public TestResult CurrentResult { get; set; }
  • public Test CurrentTest { get; set; }
  • public CultureInfo CurrentUICulture { get; set; }
  • public ValueFormatter CurrentValueFormatter { get; }
  • public Tolerance DefaultFloatingPointTolerance { get; set; }
  • public IWorkItemDispatcher Dispatcher { get; set; }
  • public TestExecutionStatus ExecutionStatus { get; set; }
  • public bool IsSingleThreaded { get; set; }
  • public TextWriter OutWriter { get; }
  • public ParallelScope ParallelScope { get; set; }
  • public Randomizer RandomGenerator { get; }
  • public long StartTicks { get; set; }
  • public DateTime StartTime { get; set; }
  • public bool StopOnError { get; set; }
  • public int TestCaseTimeout { get; set; }
  • public object TestObject { get; set; }
  • public TestWorker TestWorker { get; }
  • public List<ITestAction> UpstreamActions { get; }
  • public TestExecutionContext()
  • public TestExecutionContext(TestExecutionContext other)
  • public void AddFormatter(ValueFormatterFactory formatterFactory)
  • public void EstablishExecutionEnvironment()
  • public void IncrementAssertCount()
  • public void IncrementAssertCount(int count)
  • public void UpdateContextFromEnvironment()
• public enum TestExecutionStatus
  • AbortRequested = 2
  • Running = 0
  • StopRequested = 1
• public abstract class TestFilter : ITestFilter, IXmlNodeBuilder
  • public static readonly TestFilter Empty
  • public bool IsEmpty { get; }
  • public bool TopLevel { get; set; }
  • protected TestFilter()
  • public static TestFilter FromXml(string xmlText)
  • public static TestFilter FromXml(TNode node)
  • public abstract TNode AddToXml(TNode parentNode, bool recursive)
  • public virtual bool IsExplicitMatch(ITest test)
  • public abstract bool Match(ITest test)
  • protected virtual bool MatchDescendant(ITest test)
  • public bool MatchParent(ITest test)
  • public virtual bool Pass(ITest test)
  • public TNode ToXml(bool recursive)
• public class TestFixture : TestSuite, IDisposableFixture
  • public TestFixture(ITypeInfo fixtureType, object[] arguments = null)
• public class TestFixtureParameters : TestParameters, ITestFixtureData, ITestData
  • public Type[] TypeArgs { get; }
  • public TestFixtureParameters()
  • public TestFixtureParameters(Exception exception)
  • public TestFixtureParameters(object[] args)
  • public TestFixtureParameters(ITestFixtureData data)
• public class TestListener : ITestListener
  • public static ITestListener NULL { get; }
  • public void TestFinished(ITestResult result)
  • public void TestOutput(TestOutput output)
  • public void TestStarted(ITest test)
• public class TestMethod : Test
  • public TestMethod(IMethodInfo method)
  • public TestMethod(IMethodInfo method, Test parentSuite)
• public class TestNameGenerator
  • public static string DefaultTestNamePattern
  • public TestNameGenerator()
  • public TestNameGenerator(string pattern)
  • public string GetDisplayName(TestMethod testMethod)
  • public string GetDisplayName(TestMethod testMethod, object[] args)
• public abstract class TestParameters : ITestData, IApplyToTest
  • public object[] Arguments { get; }
  • public object[] OriginalArguments { get; }
  • public IPropertyBag Properties { get; }
  • public RunState RunState { get; set; }
  • public string TestName { get; set; }
  • public TestParameters()
  • public TestParameters(object[] args)
  • public TestParameters(Exception exception)
  • public TestParameters(ITestData data)
  • public void ApplyToTest(Test test)
• public class TestProgressReporter : ITestListener
  • public TestProgressReporter(ICallbackEventHandler handler)
  • public void TestFinished(ITestResult result)
  • public void TestOutput(TestOutput output)
  • public void TestStarted(ITest test)
• public abstract class TestResult : ITestResult, IXmlNodeBuilder
  • protected int InternalAssertCount
  • protected ReaderWriterLock RwLock
  • public int AssertCount { get; }
  • public IList<AssertionResult> AssertionResults { get; }
  • public abstract IEnumerable<ITestResult> Children { get; }
  • public double Duration { get; set; }
  • public DateTime EndTime { get; set; }
  • public abstract int FailCount { get; }
  • public virtual string FullName { get; }
  • public abstract bool HasChildren { get; }
  • public abstract int InconclusiveCount { get; }
  • public string Message { get; }
  • public virtual string Name { get; }
  • public string Output { get; }
  • public TextWriter OutWriter { get; }
  • public abstract int PassCount { get; }
  • public int PendingFailures { get; }
  • public ResultState ResultState { get; }
  • public abstract int SkipCount { get; }
  • public virtual string StackTrace { get; }
  • public DateTime StartTime { get; set; }
  • public ITest Test { get; }
  • public ICollection<TestAttachment> TestAttachments { get; }
  • public abstract int WarningCount { get; }
  • public AssertionStatus WorstAssertionStatus { get; }
  • public TestResult(ITest test)
  • public virtual TNode AddToXml(TNode parentNode, bool recursive)
  • public void RecordAssertion(AssertionResult assertion)
  • public void RecordAssertion(AssertionStatus status, string message, string stackTrace)
  • public void RecordAssertion(AssertionStatus status, string message)
  • public void RecordException(Exception ex)
  • public void RecordException(Exception ex, FailureSite site)
  • public void RecordTearDownException(Exception ex)
  • public void RecordTestCompletion()
  • public void SetResult(ResultState resultState)
  • public void SetResult(ResultState resultState, string message)
  • public void SetResult(ResultState resultState, string message, string stackTrace)
  • public TNode ToXml(bool recursive)
• public class TestSuite : Test
  • protected bool MaintainTestOrder { get; protected set; }
  • public MethodInfo[] OneTimeSetUpMethods { get; protected set; }
  • public MethodInfo[] OneTimeTearDownMethods { get; protected set; }
  • public TestSuite(string name)
  • public TestSuite(string parentSuiteName, string name)
  • public TestSuite(ITypeInfo fixtureType, object[] arguments = null)
  • public TestSuite(Type fixtureType)
  • public TestSuite(TestSuite suite, ITestFilter filter)
  • public void Add(Test test)
  • protected void CheckSetUpTearDownMethods(MethodInfo[] methods)
  • public void Sort()
• public class TestSuiteResult : TestResult
  • public TestSuiteResult(TestSuite suite)
  • public virtual void AddResult(ITestResult result)
• public class TextMessageWriter : MessageWriter
  • public static readonly string Pfx_Actual
  • public static readonly string Pfx_Expected
  • public static readonly int PrefixLength
  • public TextMessageWriter()
  • public TextMessageWriter(string userMessage, object[] args)
• public static class ThreadUtility
  • public static void Abort(Thread thread, int nativeId = 0)
  • public static void Delay(int milliseconds, WaitCallback threadPoolWork, object state = null)
  • public static int GetCurrentThreadNativeId()
  • public static void Kill(Thread thread, int nativeId = 0)
  • public static void Kill(Thread thread, object stateInfo, int nativeId = 0)
• public class TypeHelper
  • public static readonly Type NonmatchingType
  • public TypeHelper()
  • public static Type BestCommonType(Type type1, Type type2)
  • public static bool CanDeduceTypeArgsFromArgs(Type type, object[] arglist, ref Type typeArgsOut)
  • public static void ConvertArgumentList(object[] arglist, IParameterInfo[] parameters)
  • public static Type[] GetDeclaredInterfaces(Type type)
  • public static string GetDisplayName(Type type)
  • public static string GetDisplayName(Type type, object[] arglist)
  • public static bool IsNumeric(Type type)
• public class TypeWrapper : ITypeInfo, IReflectionInfo
  • public Assembly Assembly { get; }
  • public ITypeInfo BaseType { get; }
  • public bool ContainsGenericParameters { get; }
  • public string FullName { get; }
  • public bool IsAbstract { get; }
  • public bool IsGenericType { get; }
  • public bool IsGenericTypeDefinition { get; }
  • public bool IsSealed { get; }
  • public bool IsStaticClass { get; }
  • public string Name { get; }
  • public string Namespace { get; }
  • public Type Type { get; }
  • public TypeWrapper(Type type)
  • public object Construct(object[] args)
  • public ConstructorInfo GetConstructor(Type[] argTypes)
  • public T[] GetCustomAttributes<T>(bool inherit)
  • public string GetDisplayName()
  • public string GetDisplayName(object[] args)
  • public Type GetGenericTypeDefinition()
  • public IMethodInfo[] GetMethods(BindingFlags flags)
  • public bool HasConstructor(Type[] argTypes)
  • public bool HasMethodWithAttribute(Type attributeType)
  • public bool IsDefined<T>(bool inherit)
  • public bool IsType(Type type)
  • public ITypeInfo MakeGenericType(Type[] typeArgs)

NUnit.Framework.Internal.Builders

• public class CombinatorialStrategy : ICombiningStrategy
  • public CombinatorialStrategy()
  • public IEnumerable<ITestCaseData> GetTestCases(IEnumerable[] sources)
• public class DatapointProvider : IParameterDataProvider
  • public DatapointProvider()
  • public IEnumerable GetDataFor(IParameterInfo parameter)
  • public bool HasDataFor(IParameterInfo parameter)
• public class DefaultSuiteBuilder : ISuiteBuilder
  • public DefaultSuiteBuilder()
  • public TestSuite BuildFrom(ITypeInfo typeInfo)
  • public bool CanBuildFrom(ITypeInfo typeInfo)
• public class DefaultTestCaseBuilder : ITestCaseBuilder
  • public DefaultTestCaseBuilder()
  • public Test BuildFrom(IMethodInfo method)
  • public Test BuildFrom(IMethodInfo method, Test parentSuite)
  • public bool CanBuildFrom(IMethodInfo method)
  • public bool CanBuildFrom(IMethodInfo method, Test parentSuite)
• public class NamespaceTreeBuilder
  • public TestSuite RootSuite { get; }
  • public NamespaceTreeBuilder(TestSuite rootSuite)
  • public void Add(IList<Test> fixtures)
  • public void Add(TestSuite fixture)
• public class NUnitTestCaseBuilder
  • public NUnitTestCaseBuilder()
  • public TestMethod BuildTestMethod(IMethodInfo method, Test parentSuite, TestCaseParameters parms)
• public class NUnitTestFixtureBuilder
  • public NUnitTestFixtureBuilder()
  • public TestSuite BuildFrom(ITypeInfo typeInfo)
  • public TestSuite BuildFrom(ITypeInfo typeInfo, ITestFixtureData testFixtureData)
• public class PairwiseStrategy : ICombiningStrategy
  • public PairwiseStrategy()
  • public IEnumerable<ITestCaseData> GetTestCases(IEnumerable[] sources)
• public class ParameterDataProvider : IParameterDataProvider
  • public ParameterDataProvider(IParameterDataProvider[] providers)
  • public IEnumerable GetDataFor(IParameterInfo parameter)
  • public bool HasDataFor(IParameterInfo parameter)
• public class ParameterDataSourceProvider : IParameterDataProvider
  • public ParameterDataSourceProvider()
  • public IEnumerable GetDataFor(IParameterInfo parameter)
  • public bool HasDataFor(IParameterInfo parameter)
• public class SequentialStrategy : ICombiningStrategy
  • public SequentialStrategy()
  • public IEnumerable<ITestCaseData> GetTestCases(IEnumerable[] sources)

NUnit.Framework.Internal.Commands

• public class AfterTestActionCommand : AfterTestCommand
  • public AfterTestActionCommand(TestCommand innerCommand, TestActionItem action)
• public abstract class AfterTestCommand : DelegatingTestCommand
  • protected Action<TestExecutionContext> AfterTest
  • public AfterTestCommand(TestCommand innerCommand)
• public abstract class BeforeAndAfterTestCommand : DelegatingTestCommand
  • protected Action<TestExecutionContext> AfterTest
  • protected Action<TestExecutionContext> BeforeTest
  • public BeforeAndAfterTestCommand(TestCommand innerCommand)
• public class BeforeTestActionCommand : BeforeTestCommand
  • public BeforeTestActionCommand(TestCommand innerCommand, TestActionItem action)
• public abstract class BeforeTestCommand : DelegatingTestCommand
  • protected Action<TestExecutionContext> BeforeTest
  • public BeforeTestCommand(TestCommand innerCommand)
• public class ConstructFixtureCommand : BeforeTestCommand
  • public ConstructFixtureCommand(TestCommand innerCommand)
• public abstract class DelegatingTestCommand : TestCommand
  • protected TestCommand innerCommand
  • protected DelegatingTestCommand(TestCommand innerCommand)
• public class DisposeFixtureCommand : AfterTestCommand
  • public DisposeFixtureCommand(TestCommand innerCommand)
• public class EmptyTestCommand : TestCommand
  • public EmptyTestCommand(Test test)
• public class MaxTimeCommand : AfterTestCommand
  • public MaxTimeCommand(TestCommand innerCommand, int maxTime)
• public class OneTimeSetUpCommand : BeforeTestCommand
  • public OneTimeSetUpCommand(TestCommand innerCommand, SetUpTearDownItem setUpTearDown)
• public class OneTimeTearDownCommand : AfterTestCommand
  • public OneTimeTearDownCommand(TestCommand innerCommand, SetUpTearDownItem setUpTearDownItem)
• public class SetUpTearDownCommand : BeforeAndAfterTestCommand
  • public SetUpTearDownCommand(TestCommand innerCommand, SetUpTearDownItem setUpTearDown)
• public class SetUpTearDownItem
  • public bool HasMethods { get; }
  • public SetUpTearDownItem(IList<MethodInfo> setUpMethods, IList<MethodInfo> tearDownMethods)
  • public void RunSetUp(TestExecutionContext context)
  • public void RunTearDown(TestExecutionContext context)
• public class SkipCommand : TestCommand
  • public SkipCommand(Test test)
• public class TestActionCommand : BeforeAndAfterTestCommand
  • public TestActionCommand(TestCommand innerCommand, ITestAction action)
• public class TestActionItem
  • public bool BeforeTestWasRun { get; }
  • public TestActionItem(ITestAction action)
  • public void AfterTest(ITest test)
  • public void BeforeTest(ITest test)
• public abstract class TestCommand
  • public Test Test { get; }
  • public TestCommand(Test test)
  • public abstract TestResult Execute(TestExecutionContext context)
• public class TestMethodCommand : TestCommand
  • public TestMethodCommand(TestMethod testMethod)
• public class TheoryResultCommand : AfterTestCommand
  • public TheoryResultCommand(TestCommand command)
• public class TimeoutCommand : BeforeAndAfterTestCommand
  • public TimeoutCommand(TestCommand innerCommand, int timeout)

NUnit.Framework.Internal.Execution

• public class CompositeWorkItem : WorkItem
  • public class OneTimeTearDownWorkItem : WorkItem
  • public List<WorkItem> Children { get; }
  • public CompositeWorkItem(TestSuite suite, ITestFilter childFilter)
• public class CountdownEvent
  • public int CurrentCount { get; }
  • public int InitialCount { get; }
  • public CountdownEvent(int initialCount)
  • public void Signal()
  • public void Signal(int signalCount)
  • public void Wait()
• public abstract class Event
  • protected Event()
  • public abstract void Send(ITestListener listener)
• public class EventListenerTextWriter : TextWriter
  • public EventListenerTextWriter(string streamName, TextWriter defaultWriter)
• public class EventPump : IDisposable
  • public string Name { get; set; }
  • public EventPumpState PumpState { get; }
  • public EventPump(ITestListener eventListener, EventQueue events)
  • public void Dispose()
  • public void Start()
  • public void Stop()
• public enum EventPumpState
  • Pumping = 1
  • Stopped = 0
  • Stopping = 2
• public class EventQueue
  • public int Count { get; }
  • public EventQueue()
  • public Event Dequeue(bool blockWhenEmpty)
  • public void Enqueue(Event e)
  • public void Stop()
• public interface IWorkItemDispatcher
  • void CancelRun(bool force)
  • void Dispatch(WorkItem work)
  • void Start(WorkItem topLevelWorkItem)
• public enum ParallelExecutionStrategy
  • Direct = 0
  • NonParallel = 2
  • Parallel = 1
• public class ParallelWorkItemDispatcher : IWorkItemDispatcher
  • public IEnumerable<WorkItemQueue> Queues { get; }
  • public IEnumerable<WorkShift> Shifts { get; }
  • public ParallelWorkItemDispatcher(int levelOfParallelism)
  • public void CancelRun(bool force)
  • public void Dispatch(WorkItem work)
  • public void Start(WorkItem topLevelWorkItem)
• public class QueuingEventListener : ITestListener
  • public EventQueue Events { get; }
  • public QueuingEventListener()
  • public void TestFinished(ITestResult result)
  • public void TestOutput(TestOutput output)
  • public void TestStarted(ITest test)
• public class SimpleWorkItem : WorkItem
  • public SimpleWorkItem(TestMethod test, ITestFilter filter)
• public class SimpleWorkItemDispatcher : IWorkItemDispatcher
  • public SimpleWorkItemDispatcher()
  • public void CancelRun(bool force)
  • public void Dispatch(WorkItem work)
  • public void Start(WorkItem topLevelWorkItem)
• public class TestFinishedEvent : Event
  • public TestFinishedEvent(ITestResult result)
• public class TestOutputEvent : Event
  • public TestOutputEvent(TestOutput output)
• public class TestStartedEvent : Event
  • public TestStartedEvent(ITest test)
• public class TestWorker
  • public sealed delegate TestWorkerEventHandler : MulticastDelegate
  • public bool IsAlive { get; }
  • public string Name { get; }
  • public WorkItemQueue WorkQueue { get; }
  • public event TestWorkerEventHandler Busy
  • public event TestWorkerEventHandler Idle
  • public TestWorker(WorkItemQueue queue, string name)
  • public void Cancel(bool force)
  • public void Start()
• public class TextCapture : TextWriter
  • public TextCapture(TextWriter defaultWriter)
• public abstract class WorkItem
  • public TestExecutionContext Context { get; }
  • public virtual ParallelExecutionStrategy ExecutionStrategy { get; }
  • public ITestFilter Filter { get; }
  • public virtual string Name { get; }
  • public ParallelScope ParallelScope { get; }
  • public TestResult Result { get; protected set; }
  • public WorkItemState State { get; }
  • public Test Test { get; }
  • public TestWorker TestWorker { get; }
  • public event EventHandler Completed
  • public WorkItem(Test test, ITestFilter filter)
  • public WorkItem(WorkItem wrappedItem)
  • protected List<SetUpTearDownItem> BuildSetUpTearDownList(MethodInfo[] setUpMethods, MethodInfo[] tearDownMethods)
  • public virtual void Cancel(bool force)
  • protected void ChangeResult(ResultState resultState, string message)
  • public virtual void Execute()
  • public void InitializeContext(TestExecutionContext context)
  • public void MarkNotRunnable(string reason)
  • protected abstract void PerformWork()
  • protected void WorkItemComplete()
• public static class WorkItemBuilder
  • public static WorkItem CreateWorkItem(ITest test, ITestFilter filter, bool recursive = false)
• public class WorkItemQueue
  • public bool IsEmpty { get; }
  • public bool IsParallelQueue { get; }
  • public int ItemsProcessed { get; }
  • public string Name { get; }
  • public WorkItemQueueState State { get; }
  • public ApartmentState TargetApartment { get; }
  • public WorkItemQueue(string name, bool isParallel, ApartmentState apartment)
  • public WorkItem Dequeue()
  • public void Enqueue(WorkItem work)
  • public void Pause()
  • public void Start()
  • public void Stop()
• public enum WorkItemQueueState
  • Paused = 0
  • Running = 1
  • Stopped = 2
• public enum WorkItemState
  • Complete = 2
  • Ready = 0
  • Running = 1
• public class WorkShift
  • public bool HasWork { get; }
  • public bool IsActive { get; }
  • public string Name { get; }
  • public IList<WorkItemQueue> Queues { get; }
  • public IList<TestWorker> Workers { get; }
  • public event EventHandler EndOfShift
  • public WorkShift(string name)
  • public void AddQueue(WorkItemQueue queue)
  • public void Assign(TestWorker worker)
  • public void Cancel(bool force)
  • public void EndShift()
  • public void ShutDown()
  • public void Start()

NUnit.Framework.Internal.Filters

• public class AndFilter : CompositeFilter
  • public AndFilter()
  • public AndFilter(ITestFilter[] filters)
• public class CategoryFilter : ValueMatchFilter
  • public CategoryFilter(string name)
• public class ClassNameFilter : ValueMatchFilter
  • public ClassNameFilter(string expectedValue)
• public abstract class CompositeFilter : TestFilter
  • protected abstract string ElementName { get; }
  • public IList<ITestFilter> Filters { get; }
  • public CompositeFilter()
  • public CompositeFilter(ITestFilter[] filters)
  • public void Add(ITestFilter filter)
  • public abstract bool IsExplicitMatch(ITest test)
  • public abstract bool Match(ITest test)
  • public abstract bool Pass(ITest test)
• public class FullNameFilter : ValueMatchFilter
  • public FullNameFilter(string expectedValue)
• public class IdFilter : ValueMatchFilter
  • public IdFilter(string id)
• public class MethodNameFilter : ValueMatchFilter
  • public MethodNameFilter(string expectedValue)
• public class NamespaceFilter : ValueMatchFilter
  • public NamespaceFilter(string expectedValue)
• public class NotFilter : TestFilter
  • public TestFilter BaseFilter { get; }
  • public NotFilter(TestFilter baseFilter)
• public class OrFilter : CompositeFilter
  • public OrFilter()
  • public OrFilter(ITestFilter[] filters)
• public class PropertyFilter : ValueMatchFilter
  • public PropertyFilter(string propertyName, string expectedValue)
• public class TestNameFilter : ValueMatchFilter
  • public TestNameFilter(string expectedValue)
• public abstract class ValueMatchFilter : TestFilter
  • protected abstract string ElementName { get; }
  • public string ExpectedValue { get; }
  • public bool IsRegex { get; set; }
  • public ValueMatchFilter(string expectedValue)
  • protected bool Match(string input)

System

• public sealed delegate Action : MulticastDelegate
  • public Action(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke()
• public sealed delegate Action<T1, T2> : MulticastDelegate
  • public Action(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(T1 arg1, T2 arg2)
• public sealed delegate Action<T1, T2, T3> : MulticastDelegate
  • public Action(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(T1 arg1, T2 arg2, T3 arg3)
• public sealed delegate Action<T1, T2, T3, T4> : MulticastDelegate
  • public Action(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
• public sealed delegate Func<TResult> : MulticastDelegate
  • public Func(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object object)
  • public virtual TResult EndInvoke(IAsyncResult result)
  • public virtual TResult Invoke()
• public sealed delegate Func<T, TResult> : MulticastDelegate
  • public Func(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(T arg, AsyncCallback callback, object object)
  • public virtual TResult EndInvoke(IAsyncResult result)
  • public virtual TResult Invoke(T arg)
• public sealed delegate Func<T1, T2, TResult> : MulticastDelegate
  • public Func(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, AsyncCallback callback, object object)
  • public virtual TResult EndInvoke(IAsyncResult result)
  • public virtual TResult Invoke(T1 arg1, T2 arg2)
• public sealed delegate Func<T1, T2, T3, TResult> : MulticastDelegate
  • public Func(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, AsyncCallback callback, object object)
  • public virtual TResult EndInvoke(IAsyncResult result)
  • public virtual TResult Invoke(T1 arg1, T2 arg2, T3 arg3)
• public sealed delegate Func<T1, T2, T3, T4, TResult> : MulticastDelegate
  • public Func(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, AsyncCallback callback, object object)
  • public virtual TResult EndInvoke(IAsyncResult result)
  • public virtual TResult Invoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4)

System.Collections.Generic

• public class HashSet<T> : ICollection<T>, IEnumerable<T>, IEnumerable, ISerializable, IDeserializationCallback
  • public struct Enumerator<T> : IEnumerator<T>, IDisposable, IEnumerator
  • public IEqualityComparer<T> Comparer { get; }
  • public int Count { get; }
  • public HashSet()
  • public HashSet(IEqualityComparer<T> comparer)
  • public HashSet(IEnumerable<T> collection)
  • public HashSet(IEnumerable<T> collection, IEqualityComparer<T> comparer)
  • protected HashSet(SerializationInfo info, StreamingContext context)
  • public static IEqualityComparer<HashSet<T>> CreateSetComparer()
  • public bool Add(T item)
  • public void Clear()
  • public bool Contains(T item)
  • public void CopyTo(T[] array)
  • public void CopyTo(T[] array, int arrayIndex)
  • public void CopyTo(T[] array, int arrayIndex, int count)
  • public void ExceptWith(IEnumerable<T> other)
  • public Enumerator<T> GetEnumerator()
  • public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
  • public void IntersectWith(IEnumerable<T> other)
  • public bool IsProperSubsetOf(IEnumerable<T> other)
  • public bool IsProperSupersetOf(IEnumerable<T> other)
  • public bool IsSubsetOf(IEnumerable<T> other)
  • public bool IsSupersetOf(IEnumerable<T> other)
  • public virtual void OnDeserialization(object sender)
  • public bool Overlaps(IEnumerable<T> other)
  • public bool Remove(T item)
  • public int RemoveWhere(Predicate<T> match)
  • public bool SetEquals(IEnumerable<T> other)
  • public void SymmetricExceptWith(IEnumerable<T> other)
  • public void TrimExcess()
  • public void UnionWith(IEnumerable<T> other)

System.Linq

• public static class Enumerable
  • public static TSource Aggregate<TSource>(this IEnumerable<TSource> source, Func<TSource, TSource, TSource> func)
  • public static TAccumulate Aggregate<TSource, TAccumulate>(this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func)
  • public static TResult Aggregate<TSource, TAccumulate, TResult>(this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func, Func<TAccumulate, TResult> resultSelector)
  • public static bool All<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
  • public static bool Any<TSource>(this IEnumerable<TSource> source)
  • public static bool Any<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
  • public static IEnumerable<TSource> AsEnumerable<TSource>(this IEnumerable<TSource> source)
  • public static double Average(this IEnumerable<int> source)
  • public static double Average(this IEnumerable<long> source)
  • public static double Average(this IEnumerable<double> source)
  • public static float Average(this IEnumerable<float> source)
  • public static decimal Average(this IEnumerable<decimal> source)
  • public static double? Average(this IEnumerable<int?> source)
  • public static double? Average(this IEnumerable<long?> source)
  • public static double? Average(this IEnumerable<double?> source)
  • public static decimal? Average(this IEnumerable<decimal?> source)
  • public static float? Average(this IEnumerable<float?> source)
  • public static double Average<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector)
  • public static double? Average<TSource>(this IEnumerable<TSource> source, Func<TSource, int?> selector)
  • public static double Average<TSource>(this IEnumerable<TSource> source, Func<TSource, long> selector)
  • public static double? Average<TSource>(this IEnumerable<TSource> source, Func<TSource, long?> selector)
  • public static double Average<TSource>(this IEnumerable<TSource> source, Func<TSource, double> selector)
  • public static double? Average<TSource>(this IEnumerable<TSource> source, Func<TSource, double?> selector)
  • public static float Average<TSource>(this IEnumerable<TSource> source, Func<TSource, float> selector)
  • public static float? Average<TSource>(this IEnumerable<TSource> source, Func<TSource, float?> selector)
  • public static decimal Average<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal> selector)
  • public static decimal? Average<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
  • public static IEnumerable<TResult> Cast<TResult>(this IEnumerable source)
  • public static IEnumerable<TSource> Concat<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
  • public static bool Contains<TSource>(this IEnumerable<TSource> source, TSource value)
  • public static bool Contains<TSource>(this IEnumerable<TSource> source, TSource value, IEqualityComparer<TSource> comparer)
  • public static int Count<TSource>(this IEnumerable<TSource> source)
  • public static int Count<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
  • public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this IEnumerable<TSource> source)
  • public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this IEnumerable<TSource> source, TSource defaultValue)
  • public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source)
  • public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
  • public static TSource ElementAt<TSource>(this IEnumerable<TSource> source, int index)
  • public static TSource ElementAtOrDefault<TSource>(this IEnumerable<TSource> source, int index)
  • public static IEnumerable<TResult> Empty<TResult>()
  • public static IEnumerable<TSource> Except<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
  • public static IEnumerable<TSource> Except<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
  • public static TSource First<TSource>(this IEnumerable<TSource> source)
  • public static TSource First<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
  • public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source)
  • public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
  • public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
  • public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
  • public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
  • public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
  • public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector)
  • public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector, IEqualityComparer<TKey> comparer)
  • public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector)
  • public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector, IEqualityComparer<TKey> comparer)
  • public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector)
  • public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector, IEqualityComparer<TKey> comparer)
  • public static IEnumerable<TSource> Intersect<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
  • public static IEnumerable<TSource> Intersect<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
  • public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector, IEqualityComparer<TKey> comparer)
  • public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector)
  • public static TSource Last<TSource>(this IEnumerable<TSource> source)
  • public static TSource Last<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
  • public static TSource LastOrDefault<TSource>(this IEnumerable<TSource> source)
  • public static TSource LastOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
  • public static long LongCount<TSource>(this IEnumerable<TSource> source)
  • public static long LongCount<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
  • public static int Max(this IEnumerable<int> source)
  • public static long Max(this IEnumerable<long> source)
  • public static double Max(this IEnumerable<double> source)
  • public static float Max(this IEnumerable<float> source)
  • public static decimal Max(this IEnumerable<decimal> source)
  • public static int? Max(this IEnumerable<int?> source)
  • public static long? Max(this IEnumerable<long?> source)
  • public static double? Max(this IEnumerable<double?> source)
  • public static float? Max(this IEnumerable<float?> source)
  • public static decimal? Max(this IEnumerable<decimal?> source)
  • public static TSource Max<TSource>(this IEnumerable<TSource> source)
  • public static int Max<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector)
  • public static long Max<TSource>(this IEnumerable<TSource> source, Func<TSource, long> selector)
  • public static double Max<TSource>(this IEnumerable<TSource> source, Func<TSource, double> selector)
  • public static float Max<TSource>(this IEnumerable<TSource> source, Func<TSource, float> selector)
  • public static decimal Max<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal> selector)
  • public static int? Max<TSource>(this IEnumerable<TSource> source, Func<TSource, int?> selector)
  • public static long? Max<TSource>(this IEnumerable<TSource> source, Func<TSource, long?> selector)
  • public static double? Max<TSource>(this IEnumerable<TSource> source, Func<TSource, double?> selector)
  • public static float? Max<TSource>(this IEnumerable<TSource> source, Func<TSource, float?> selector)
  • public static decimal? Max<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
  • public static TResult Max<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)
  • public static int Min(this IEnumerable<int> source)
  • public static long Min(this IEnumerable<long> source)
  • public static double Min(this IEnumerable<double> source)
  • public static float Min(this IEnumerable<float> source)
  • public static decimal Min(this IEnumerable<decimal> source)
  • public static int? Min(this IEnumerable<int?> source)
  • public static long? Min(this IEnumerable<long?> source)
  • public static double? Min(this IEnumerable<double?> source)
  • public static float? Min(this IEnumerable<float?> source)
  • public static decimal? Min(this IEnumerable<decimal?> source)
  • public static TSource Min<TSource>(this IEnumerable<TSource> source)
  • public static int Min<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector)
  • public static long Min<TSource>(this IEnumerable<TSource> source, Func<TSource, long> selector)
  • public static double Min<TSource>(this IEnumerable<TSource> source, Func<TSource, double> selector)
  • public static float Min<TSource>(this IEnumerable<TSource> source, Func<TSource, float> selector)
  • public static decimal Min<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal> selector)
  • public static int? Min<TSource>(this IEnumerable<TSource> source, Func<TSource, int?> selector)
  • public static long? Min<TSource>(this IEnumerable<TSource> source, Func<TSource, long?> selector)
  • public static float? Min<TSource>(this IEnumerable<TSource> source, Func<TSource, float?> selector)
  • public static double? Min<TSource>(this IEnumerable<TSource> source, Func<TSource, double?> selector)
  • public static decimal? Min<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
  • public static TResult Min<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)
  • public static IEnumerable<TResult> OfType<TResult>(this IEnumerable source)
  • public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
  • public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
  • public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
  • public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
  • public static IEnumerable<int> Range(int start, int count)
  • public static IEnumerable<TResult> Repeat<TResult>(TResult element, int count)
  • public static IEnumerable<TSource> Reverse<TSource>(this IEnumerable<TSource> source)
  • public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)
  • public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, int, TResult> selector)
  • public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)
  • public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector)
  • public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
  • public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
  • public static bool SequenceEqual<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
  • public static bool SequenceEqual<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
  • public static TSource Single<TSource>(this IEnumerable<TSource> source)
  • public static TSource Single<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
  • public static TSource SingleOrDefault<TSource>(this IEnumerable<TSource> source)
  • public static TSource SingleOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
  • public static IEnumerable<TSource> Skip<TSource>(this IEnumerable<TSource> source, int count)
  • public static IEnumerable<TSource> SkipWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
  • public static IEnumerable<TSource> SkipWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
  • public static int Sum(this IEnumerable<int> source)
  • public static int? Sum(this IEnumerable<int?> source)
  • public static int Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector)
  • public static int? Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, int?> selector)
  • public static long Sum(this IEnumerable<long> source)
  • public static long? Sum(this IEnumerable<long?> source)
  • public static long Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, long> selector)
  • public static long? Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, long?> selector)
  • public static double Sum(this IEnumerable<double> source)
  • public static double? Sum(this IEnumerable<double?> source)
  • public static double Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, double> selector)
  • public static double? Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, double?> selector)
  • public static float Sum(this IEnumerable<float> source)
  • public static float? Sum(this IEnumerable<float?> source)
  • public static float Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, float> selector)
  • public static float? Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, float?> selector)
  • public static decimal Sum(this IEnumerable<decimal> source)
  • public static decimal? Sum(this IEnumerable<decimal?> source)
  • public static decimal Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal> selector)
  • public static decimal? Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
  • public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> source, int count)
  • public static IEnumerable<TSource> TakeWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
  • public static IEnumerable<TSource> TakeWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
  • public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector)
  • public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
  • public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector)
  • public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
  • public static TSource[] ToArray<TSource>(this IEnumerable<TSource> source)
  • public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
  • public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
  • public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
  • public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
  • public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source)
  • public static ILookup<TKey, TSource> ToLookup<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
  • public static ILookup<TKey, TSource> ToLookup<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
  • public static ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
  • public static ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
  • public static IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
  • public static IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
  • public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
  • public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
• public interface IGrouping<TKey, TElement> : IEnumerable<TElement>, IEnumerable
  • TKey Key { get; }
• public interface ILookup<TKey, TElement> : IEnumerable<IGrouping<TKey, TElement>>, IEnumerable
  • int Count { get; }
  • IEnumerable<TElement> this[TKey key] { get; }
  • bool Contains(TKey key)
• public interface IOrderedEnumerable<TElement> : IEnumerable<TElement>, IEnumerable
  • IOrderedEnumerable<TElement> CreateOrderedEnumerable<TKey>(Func<TElement, TKey> keySelector, IComparer<TKey> comparer, bool descending)
• public class Lookup<TKey, TElement> : IEnumerable<IGrouping<TKey, TElement>>, IEnumerable, ILookup<TKey, TElement>
  • public int Count { get; }
  • public IEnumerable<TElement> this[TKey key] { get; }
  • public IEnumerable<TResult> ApplyResultSelector<TResult>(Func<TKey, IEnumerable<TElement>, TResult> resultSelector)
  • public bool Contains(TKey key)
  • public IEnumerator<IGrouping<TKey, TElement>> GetEnumerator()

System.Runtime.CompilerServices

• public sealed class ExtensionAttribute : Attribute
  • public ExtensionAttribute()