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

---

API Differences between 4.3.0 and 4.0.1

171 Additions 17 Removals

NUnit

• public static class FrameworkPackageSettings
  • public const string ThrowOnEachFailureUnderDebugger = "ThrowOnEachFailureUnderDebugger"

NUnit.Framework

• public abstract class Assert : AssertBase
  • public static IDisposable EnterMultipleScope()
• public static class EqualNumericWithoutUsingConstraintExtensions
  • public static EqualNumericWithoutUsingConstraint<double> Within(this EqualNumericWithoutUsingConstraint<int> constraint, double amount)
  • public static EqualNumericWithoutUsingConstraint<double> Within(this EqualNumericWithoutUsingConstraint<float> constraint, double amount)
• public interface IEqualWithUsingConstraint<T>
  • T Expected { get; }
• public static class IEqualWithUsingConstraintExtensions
  • public static EqualUsingConstraint<TExpected> Using<TExpected>(this IEqualWithUsingConstraint<TExpected> constraint, Func<TExpected, TExpected, bool> comparer)
  • public static EqualUsingConstraint<TExpected> Using<TExpected>(this IEqualWithUsingConstraint<TExpected> constraint, IEqualityComparer<TExpected> comparer)
  • public static EqualUsingConstraint<TExpected> Using<TExpected>(this IEqualWithUsingConstraint<TExpected> constraint, IComparer<TExpected> comparer)
  • public static EqualUsingConstraint<TExpected> Using<TExpected>(this IEqualWithUsingConstraint<TExpected> constraint, Comparison<TExpected> comparer)
  • public static EqualUsingConstraint<TExpected> Using<TActual, TExpected>(this IEqualWithUsingConstraint<TExpected> constraint, Func<TActual, TExpected, bool> comparer)
  • public static EqualUsingConstraint<TExpected> Using<TActual, TExpected>(this IEqualWithUsingConstraint<TExpected> constraint, IComparer<TActual> comparer)
  • public static EqualUsingConstraint<TExpected> Using<TExpected>(this IEqualWithUsingConstraint<TExpected> constraint, IEqualityComparer comparer)
  • public static EqualUsingConstraint<TExpected> Using<TExpected>(this IEqualWithUsingConstraint<TExpected> constraint, IComparer comparer)
• public class IgnoreAttribute : NUnitAttribute, IApplyToTest
  • public string Reason { get; }
• public abstract class Is
  • public static WhiteSpaceConstraint WhiteSpace { get; }
  • public static EqualConstraint EqualTo<T>(IEnumerable<T> expected)
  • public static EqualStringConstraint EqualTo(string expected)
  • public static EqualDateTimeOffsetConstraint EqualTo(DateTimeOffset expected)
  • public static EqualTimeBaseConstraint<DateTime> EqualTo(DateTime expected)
  • public static EqualTimeBaseConstraint<TimeSpan> EqualTo(TimeSpan expected)
  • public static EqualNumericConstraint<T> EqualTo<T>(T expected) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType), IConvertible, IEquatable<T>
  • public static CollectionEquivalentConstraint EquivalentTo<T>(IEnumerable<T> expected)
  • public static CollectionSubsetConstraint SubsetOf<T>(IEnumerable<T> expected)
  • public static CollectionSupersetConstraint SupersetOf<T>(IEnumerable<T> expected)
• public class NetPlatformAttribute : IncludeExcludeAttribute, IApplyToTest
  • public NetPlatformAttribute()
  • public NetPlatformAttribute(string platforms)
  • public void ApplyToTest(Test test)
• public class RepeatAttribute : PropertyAttribute, IRepeatTest, ICommandWrapper
  • public bool StopOnFailure { get; set; }
  • public RepeatAttribute(int count, bool stopOnFailure)
• public class TestCaseAttribute : NUnitAttribute, ITestBuilder, ITestCaseData, ITestData, IImplyFixture
  • public Type[] TypeArgs { get; set; }
• public class TestCaseAttribute<T> : TestCaseAttribute
  • public TestCaseAttribute(T argument)
• public class TestCaseAttribute<T1, T2> : TestCaseAttribute
  • public TestCaseAttribute(T1 argument1, T2 argument2)
• public class TestCaseAttribute<T1, T2, T3> : TestCaseAttribute
  • public TestCaseAttribute(T1 argument1, T2 argument2, T3 argument3)
• public class TestCaseAttribute<T1, T2, T3, T4> : TestCaseAttribute
  • public TestCaseAttribute(T1 argument1, T2 argument2, T3 argument3, T4 argument4)
• public class TestCaseAttribute<T1, T2, T3, T4, T5> : TestCaseAttribute
  • public TestCaseAttribute(T1 argument1, T2 argument2, T3 argument3, T4 argument4, T5 argument5)
• public class TestCaseData<T> : TestCaseData
  • public TestCaseData(T argument)
• public class TestCaseData<T1, T2> : TestCaseData
  • public TestCaseData(T1 argument1, T2 argument2)
• public class TestCaseData<T1, T2, T3> : TestCaseData
  • public TestCaseData(T1 argument1, T2 argument2, T3 argument3)
• public class TestCaseData<T1, T2, T3, T4> : TestCaseData
  • public TestCaseData(T1 argument1, T2 argument2, T3 argument3, T4 argument4)
• public class TestCaseData<T1, T2, T3, T4, T5> : TestCaseData
  • public TestCaseData(T1 argument1, T2 argument2, T3 argument3, T4 argument4, T5 argument5)
• public class TestContext
  • public class PropertyHierachyItem
  • public class PropertyValueHierarchyItem

NUnit.Framework.Constraints

• public class AnyOfConstraint : Constraint
  • public AnyOfConstraint IgnoreWhiteSpace { get; }
  • public AnyOfConstraint UsingPropertiesComparer()
• public class CollectionEquivalentConstraint : CollectionItemsEqualConstraint
  • public CollectionEquivalentConstraint Using<TActual, TExpected>(Func<TActual, TExpected, bool> comparison)
  • public CollectionEquivalentConstraint Using<TActualElement, TExpectedElement>(Func<TActualElement, TExpectedElement, bool> comparison)
• public abstract class CollectionItemsEqualConstraint : CollectionConstraint
  • public CollectionItemsEqualConstraint IgnoreWhiteSpace { get; }
  • protected bool IgnoringWhiteSpace { get; }
  • public CollectionItemsEqualConstraint UsingPropertiesComparer()
• public class CollectionSubsetConstraint : CollectionItemsEqualConstraint
  • public CollectionSubsetConstraint Using<TSubsetType, TSupersetType>(Func<TSubsetType, TSupersetType, bool> comparison)
  • public CollectionSubsetConstraint Using<TSubsetElement, TSupersetElement>(Func<TSubsetElement, TSupersetElement, bool> comparison)
• public class CollectionSupersetConstraint : CollectionItemsEqualConstraint
  • public CollectionSupersetConstraint Using<TSupersetType, TSubsetType>(Func<TSupersetType, TSubsetType, bool> comparison)
  • public CollectionSupersetConstraint Using<TSupersetElement, TSubsetElement>(Func<TSupersetElement, TSubsetElement, bool> comparison)
• public abstract class Constraint : IAsyncConstraint, IConstraint, IResolveConstraint
  • public virtual Task<ConstraintResult> ApplyToAsync<TActual>(Func<Task<TActual>> taskDel)
• public sealed class ConstraintBuilder : IResolveConstraint
  • public void Replace(Constraint constraint)
• public class ConstraintExpression
  • public WhiteSpaceConstraint WhiteSpace { get; }
  • public T Append<T>(T constraint) where T : Constraint
  • public EqualStringConstraint EqualTo(string expected)
  • public EqualDateTimeOffsetConstraint EqualTo(DateTimeOffset expected)
  • public EqualTimeBaseConstraint<DateTime> EqualTo(DateTime expected)
  • public EqualTimeBaseConstraint<TimeSpan> EqualTo(TimeSpan expected)
  • public EqualNumericConstraint<T> EqualTo<T>(T expected) where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType), IConvertible, IEquatable<T>
• public class ContainsConstraint : Constraint
  • public ContainsConstraint IgnoreWhiteSpace { get; }
• public class DictionaryContainsValueConstraint : CollectionItemsEqualConstraint
  • public DictionaryContainsValueConstraint Using<TCollectionType, TMemberType>(Func<TCollectionType, TMemberType, bool> comparison)
  • public DictionaryContainsValueConstraint Using<TActualValueElement, TExpected>(Func<TActualValueElement, TExpected, bool> comparison)
• public class EqualConstraint : Constraint
  • public bool ComparingProperties { get; }
  • public bool HasFailurePoints { get; }
  • public EqualConstraint IgnoreWhiteSpace { get; }
  • public bool IgnoringWhiteSpace { get; }
  • public EqualConstraint Using<TCollectionType, TMemberType>(Func<TCollectionType, TMemberType, bool> comparison)
  • public EqualConstraint Using<TActual, TExpected>(Func<TActual, TExpected, bool> comparison)
  • public EqualConstraint UsingPropertiesComparer()
• public class EqualConstraintResult : ConstraintResult
  • public EqualConstraintResult(Constraint constraint, object actual, Tolerance tolerance, bool hasSucceeded)
  • public EqualConstraintResult(Constraint constraint, object actual, bool hasSucceeded)
  • public EqualConstraintResult(EqualStringWithoutUsingConstraint constraint, object actual, bool caseInsensitive, bool ignoringWhiteSpace, bool clipStrings, bool hasSucceeded)
• public class EqualDateTimeOffsetConstraint : EqualTimeBaseConstraint<DateTimeOffset>
  • public EqualDateTimeOffsetConstraintWithSameOffset WithSameOffset { get; }
  • public EqualDateTimeOffsetConstraint(DateTimeOffset expected)
• public class EqualDateTimeOffsetConstraintWithSameOffset : Constraint
  • public EqualDateTimeOffsetConstraintWithSameOffset(DateTimeOffset expected)
  • public ConstraintResult ApplyTo(DateTimeOffset actual)
• public class EqualNumericConstraint<T> : EqualNumericWithoutUsingConstraint<T>, IEqualWithUsingConstraint<T> where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType), IConvertible, IEquatable<T>
  • public EqualNumericConstraint(T expected)
• public class EqualNumericWithoutUsingConstraint<T> : Constraint where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType), IConvertible, IEquatable<T>
  • public T Expected { get; }
  • public EqualNumericWithoutUsingConstraint<T> Percent { get; }
  • public Tolerance Tolerance { get; }
  • public EqualNumericWithoutUsingConstraint<T> Ulps { get; }
  • public EqualNumericWithoutUsingConstraint(T expected)
  • public ConstraintResult ApplyTo(T actual)
  • public EqualNumericWithoutUsingConstraint<T> Within(T amount)
• public class EqualStringConstraint : EqualStringWithoutUsingConstraint, IEqualWithUsingConstraint<string>
  • public EqualStringConstraint(string expected)
  • public EqualUsingConstraint<string> Using(StringComparer comparer)
• public class EqualStringWithoutUsingConstraint : Constraint
  • public string Expected { get; }
  • public EqualStringWithoutUsingConstraint IgnoreCase { get; }
  • public EqualStringWithoutUsingConstraint IgnoreWhiteSpace { get; }
  • public EqualStringWithoutUsingConstraint NoClip { get; }
  • public EqualStringWithoutUsingConstraint(string expected)
  • public ConstraintResult ApplyTo(string actual)
• public class EqualTimeBaseConstraint<T> : Constraint where T : struct, IEquatable<T>, IComparable<T>
  • public T Expected { get; }
  • public EqualTimeBaseConstraint(T expected, Func<T, long> getTicks)
  • public virtual ConstraintResult ApplyTo(T actual)
  • public EqualTimeBasedConstraintWithTimeSpanTolerance<T> Within(TimeSpan amount)
  • public EqualTimeBasedConstraintWithNumericTolerance<T> Within(double amount)
• public class EqualTimeBasedConstraintWithNumericTolerance<T> where T : IEquatable<T>, IComparable<T>
  • public ConstraintBuilder Builder { get; set; }
  • public EqualTimeBasedConstraintWithTimeSpanTolerance<T> Days { get; }
  • public EqualTimeBasedConstraintWithTimeSpanTolerance<T> Hours { get; }
  • public EqualTimeBasedConstraintWithTimeSpanTolerance<T> Milliseconds { get; }
  • public EqualTimeBasedConstraintWithTimeSpanTolerance<T> Minutes { get; }
  • public EqualTimeBasedConstraintWithTimeSpanTolerance<T> Seconds { get; }
  • public EqualTimeBasedConstraintWithTimeSpanTolerance<T> Ticks { get; }
  • public EqualTimeBasedConstraintWithNumericTolerance(T expected, Func<T, long> getTicks, double tolerance)
• public class EqualTimeBasedConstraintWithTimeSpanTolerance<T> : Constraint where T : IEquatable<T>, IComparable<T>
  • public EqualTimeBasedConstraintWithTimeSpanTolerance(T expected, Func<T, long> getTicks, TimeSpan tolerance)
  • public ConstraintResult ApplyTo(T actual)
• public class EqualUsingConstraint<T> : Constraint
  • public EqualUsingConstraint(T expected, Func<T, T, bool> comparer)
  • public EqualUsingConstraint(T expected, Func<object, object, bool> comparer)
  • public EqualUsingConstraint(T expected, IEqualityComparer<T> comparer)
  • public EqualUsingConstraint(T expected, IComparer<T> comparer)
  • public EqualUsingConstraint(T expected, Comparison<T> comparer)
  • public EqualUsingConstraint(T expected, IEqualityComparer comparer)
  • public EqualUsingConstraint(T expected, IComparer comparer)
  • public virtual ConstraintResult ApplyTo(T actual)
• public class InsteadOperator : BinaryOperator
  • public InsteadOperator()
• public abstract class MessageWriter : StringWriter
  • public virtual void DisplayStringDifferences(string expected, string actual, int mismatchExpected, int mismatchActual, bool ignoreCase, bool ignoreWhiteSpace, bool clipping)
• public sealed class NUnitEqualityComparer
  • public bool CompareProperties { get; set; }
  • public bool HasFailurePoints { get; }
  • public bool IgnoreWhiteSpace { get; set; }
• public abstract class PathConstraint : StringConstraint
  • protected StringComparison DetermineComparisonType()
• public class SomeItemsConstraint : PrefixConstraint
  • public SomeItemsConstraint Using<TCollectionType, TMemberType>(Func<TCollectionType, TMemberType, bool> comparison)
  • public SomeItemsConstraint Using<TActualCollectionElement, TExpected>(Func<TActualCollectionElement, TExpected, bool> comparison)
  • public SomeItemsConstraint UsingPropertiesComparer()
• public class WhiteSpaceConstraint : StringConstraint
  • public WhiteSpaceConstraint()

NUnit.Framework.Diagnostics

• public class ProgressTraceListener : TextWriterTraceListener
  • public ProgressTraceListener()

NUnit.Framework.Internal

• public static class NetPlatformHelper
  • public static bool IsPlatformSupported(string[] platforms)
  • public static bool IsPlatformSupported(string platform)
• public static class StringUtil
• public abstract class Test : ITest, IXmlNodeBuilder, IComparable, IComparable<Test>
  • public void ApplyAttributesToTest(IEnumerable<IApplyToTest> attributes)
• public class TestCaseParameters : TestParameters, ITestCaseData, ITestData, IApplyToTest
  • public Type[] TypeArgs { get; set; }

NUnit.Framework.Internal.Execution

• public sealed class EventPump : EventPump<Event, ITestListener>, 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 EventPump(ITestListener eventListener, EventQueue<Event> events)
• public abstract class EventPump<TEvent, TListener> : IDisposable where TEvent : IEvent<TListener>
  • public string Name { get; set; }
  • public EventPumpState PumpState { get; }
  • protected EventPump(TListener eventListener, EventQueue<TEvent> events, string name = "Standard")
  • public void Dispose()
  • public void Start()
  • public void Stop()
• public sealed class EventQueue : EventQueue<Event>
  • public int Count { get; }
  • public Event Dequeue(bool blockWhenEmpty)
  • public void Enqueue(Event e)
  • public void Stop()
• public abstract class EventQueue<T>
  • public int Count { get; }
  • protected EventQueue()
  • public T Dequeue(bool blockWhenEmpty)
  • public void Enqueue(T e)
  • public void Stop()
• public interface IEvent<TListener>
  • void Send(TListener listener)