NFluent by Thomas PIERRAIN, Cyrille DUPUYDAUBY, Rui CARVALHO, Marc-Antoine LATOUR

<PackageReference Include="NFluent" Version="1.2.0" />

---

API Diff between 1.2.0 and 3.0.0.269-beta

189 Additions 261 Removals

NFluent

• public static class Assuming
• public static class ByteCheckExtensions
  • public static INullableOrNumberCheckLink<byte> HasAValue(this ICheck<byte?> check)
  • public static void HasNoValue(this ICheck<byte?> check)
  • public static ICheckLink<ICheck<byte>> IsGreaterOrEqualThan(this ICheck<byte> check, byte givenValue)
  • public static ICheckLink<ICheck<byte>> IsLessOrEqualThan(this ICheck<byte> check, byte givenValue)
  • public static ICheckLink<ICheck<byte>> IsGreaterThan(this ICheck<byte> check, byte comparand)
  • public static ICheckLink<ICheck<byte>> IsLessThan(this ICheck<byte> check, byte comparand)
  • public static ICheckLink<ICheck<byte>> IsStrictlyGreaterThan(this ICheck<byte> check, byte comparand)
  • public static ICheckLink<ICheck<byte>> IsStrictlyLessThan(this ICheck<byte> check, byte comparand)
• public static class Check
  • public static EqualityMode EqualMode { get; set; }
  • public static IErrorReporter Reporter { get; set; }
  • public static int StringTruncationLength { get; set; }
  • public static IDisposable ChangeReporterForScope(IErrorReporter newReporter)
  • public static MacroCheck<T, T1, T2> DeclareMacro<T, T1, T2>(Action<T, T1, T2> function, string errorMessage)
  • public static MacroCheck<T, T1> DeclareMacro<T, T1>(Action<T, T1> function, string errorMessage)
  • public static IEqualityComparer RegisterComparer<T>(IEqualityComparer comparer)
  • public static IDisposable RegisterLocalComparer<T>(IEqualityComparer comparer)
  • public static IDisposable StartBatch(string message = null)
  • public static ICheck<Type> That<T>()
  • public static ICheck<RunTrace> ThatAsyncCode(Func<Task> awaitableMethod)
  • public static ICheck<RunTraceResult<TResult>> ThatAsyncCode<TResult>(Func<Task<TResult>> awaitableFunction)
  • public static ICheck<RunTrace> ThatCode(Action value)
  • public static ICheck<RunTraceResult<TU>> ThatCode<TU>(Func<TU> value)
  • public static ICheck<RunTrace> ThatCode(Func<Task> awaitableFunc)
  • public static ICheck<RunTraceResult<TU>> ThatCode<TU>(Func<Task<TU>> awaitableFunc)
  • public static FluentDynamicCheck ThatDynamic(object value)
  • public static NFluentEntryPoint WithCustomMessage(string message)
  • public static ILambdaCheck That(Action value)
  • public static ILambdaCheck That<T>(Func<T> value)
  • public static ICodeCheck<RunTrace> ThatCode(Action value)
  • public static ICodeCheck<RunTraceResult<U>> ThatCode<U>(Func<U> value)
  • public static IStructCheck<T> ThatEnum<T>(T value) where T : struct
• public class CheckMember<T, TM> : IErrorReporter
• public static class CodeCheckExtensions
  • public static ICheckLink<ICheck<T>> ConsumesLessThan<T>(this ICheck<T> check, double threshold, TimeUnit timeUnit) where T : RunTrace
  • public static ICheckLink<ICheck<T>> DoesNotThrow<T>(this ICheck<T> check) where T : RunTrace
  • public static ICheckLink<ICheck<T>> LastsLessThan<T>(this ICheck<T> check, double threshold, TimeUnit timeUnit) where T : RunTrace
  • public static ILambdaExceptionCheck<T> Throws<T>(this ICheck<RunTrace> check) where T : Exception
  • public static ILambdaExceptionCheck<Exception> ThrowsAny(this ICheck<RunTrace> check)
  • public static ILambdaExceptionCheck<Exception> ThrowsType(this ICheck<RunTrace> check, Type exceptionType)
  • public static ICheck<T> WhichResult<T>(this ICheck<RunTraceResult<T>> check)
  • public static ICheckLink<ICodeCheck<T>> ConsumesLessThan<T>(this ICodeCheck<T> check, double threshold, TimeUnit timeUnit) where T : RunTrace
  • public static ICheckLink<ICodeCheck<T>> DoesNotThrow<T>(this ICodeCheck<T> check) where T : RunTrace
  • public static ICheckLink<ICodeCheck<T>> LastsLessThan<T>(this ICodeCheck<T> check, double threshold, TimeUnit timeUnit) where T : RunTrace
  • public static ILambdaExceptionCheck<RunTrace> Throws<T>(this ICodeCheck<RunTrace> check)
  • public static ILambdaExceptionCheck<RunTrace> ThrowsAny(this ICodeCheck<RunTrace> check)
  • public static ICheck<T> WhichResult<T>(this ICodeCheck<RunTraceResult<T>> check)
• public class Criteria
• public static class DateTimeCheckExtensions
  • public static ICheckLink<ICheck<DateTime>> IsCloseTo(this ICheck<DateTime> check, DateTime expected, Duration within)
  • public static ICheckLink<ICheck<DateTime>> IsCloseTo(this ICheck<DateTime> check, DateTime expected, TimeSpan within)
• public static class DateTimeOffsetCheckExtensions
• public static class DecimalCheck
• public static class DecimalCheckExtensions
  • public static INullableOrNumberCheckLink<decimal> HasAValue(this ICheck<decimal?> check)
  • public static void HasNoValue(this ICheck<decimal?> check)
  • public static ICheckLink<ICheck<decimal>> IsGreaterOrEqualThan(this ICheck<decimal> check, decimal givenValue)
  • public static ICheckLink<ICheck<decimal>> IsLessOrEqualThan(this ICheck<decimal> check, decimal givenValue)
  • public static ICheckLink<ICheck<decimal>> IsGreaterThan(this ICheck<decimal> check, decimal comparand)
  • public static ICheckLink<ICheck<decimal>> IsLessThan(this ICheck<decimal> check, decimal comparand)
  • public static ICheckLink<ICheck<decimal>> IsStrictlyGreaterThan(this ICheck<decimal> check, decimal comparand)
  • public static ICheckLink<ICheck<decimal>> IsStrictlyLessThan(this ICheck<decimal> check, decimal comparand)
• public static class DecimalSignedCheckExtensions
  • public static ICheckLink<ICheck<decimal>> IsNegativeOrZero(this ICheck<decimal> check)
  • public static ICheckLink<ICheck<decimal>> IsPositiveOrZero(this ICheck<decimal> check)
  • public static ICheckLink<ICheck<decimal>> IsStrictlyNegative(this ICheck<decimal> check)
  • public static ICheckLink<ICheck<decimal>> IsStrictlyPositive(this ICheck<decimal> check)
  • public static ICheckLink<ICheck<decimal>> IsNegative(this ICheck<decimal> check)
  • public static ICheckLink<ICheck<decimal>> IsPositive(this ICheck<decimal> check)
• public static class DictionaryCheckExtensions
  • public static ICheckLink<ICheck<IEnumerable<KeyValuePair<TK, TU>>>> ContainsKey<TK, TU>(this ICheck<IEnumerable<KeyValuePair<TK, TU>>> check, TK key)
  • public static ICheckLink<ICheck<Hashtable>> ContainsKey(this ICheck<Hashtable> check, object key)
  • public static ICheckLink<ICheck<IEnumerable<KeyValuePair<TK, TU>>>> ContainsPair<TK, TU>(this ICheck<IEnumerable<KeyValuePair<TK, TU>>> check, TK expectedKey, TU expectedValue)
  • public static ICheckLink<ICheck<Hashtable>> ContainsPair(this ICheck<Hashtable> check, object expectedKey, object expectedValue)
  • public static ICheckLink<ICheck<IEnumerable<KeyValuePair<TK, TU>>>> ContainsValue<TK, TU>(this ICheck<IEnumerable<KeyValuePair<TK, TU>>> check, TU expectedValue)
  • public static ICheckLink<ICheck<Hashtable>> ContainsValue(this ICheck<Hashtable> check, object expectedValue)
  • public static ICheckLink<ICheck<IEnumerable<KeyValuePair<TK, TU>>>> IsEquivalentTo<TK, TU>(this ICheck<IEnumerable<KeyValuePair<TK, TU>>> check, IEnumerable<KeyValuePair<TK, TU>> other)
  • public static ICheckLink<ICheck<IDictionary>> ContainsKey<K>(this ICheck<IDictionary> check, K key)
  • public static ICheckLink<ICheck<IDictionary>> ContainsValue<K>(this ICheck<IDictionary> check, K expectedValue)
• public static class DoubleCheckExtensions
  • public static INullableOrNumberCheckLink<double> HasAValue(this ICheck<double?> check)
  • public static void HasNoValue(this ICheck<double?> check)
  • public static ICheckLink<ICheck<double>> IsGreaterOrEqualThan(this ICheck<double> check, double givenValue)
  • public static ICheckLink<ICheck<double>> IsLessOrEqualThan(this ICheck<double> check, double givenValue)
  • public static ICheckLink<ICheck<double>> IsGreaterThan(this ICheck<double> check, double comparand)
  • public static ICheckLink<ICheck<double>> IsLessThan(this ICheck<double> check, double comparand)
  • public static ICheckLink<ICheck<double>> IsStrictlyGreaterThan(this ICheck<double> check, double comparand)
  • public static ICheckLink<ICheck<double>> IsStrictlyLessThan(this ICheck<double> check, double comparand)
• public static class DoubleSignedCheckExtensions
  • public static ICheckLink<ICheck<double>> IsNegativeOrZero(this ICheck<double> check)
  • public static ICheckLink<ICheck<double>> IsPositiveOrZero(this ICheck<double> check)
  • public static ICheckLink<ICheck<double>> IsStrictlyNegative(this ICheck<double> check)
  • public static ICheckLink<ICheck<double>> IsStrictlyPositive(this ICheck<double> check)
  • public static ICheckLink<ICheck<double>> IsNegative(this ICheck<double> check)
  • public static ICheckLink<ICheck<double>> IsPositive(this ICheck<double> check)
• public static class DoubleSpecificCheckExtensions
  • public static ICheckLink<ICheck<double>> IsCloseTo(this ICheck<double> check, double expected, double within)
• public class DynamicCheckLink
• public static class EnumCheckExtensions
• public static class EnumerableCheckExtensions
  • public static ExtendableCheckLink<ICheck<IEnumerable<T>>, IEnumerable<T>> Contains<T>(this ICheck<IEnumerable<T>> check, T[] expectedValues)
  • public static ExtendableCheckLink<ICheck<IEnumerable<T>>, IEnumerable<T>> Contains<T>(this ICheck<IEnumerable<T>> check, IEnumerable<T> expectedValues)
  • public static ExtendableCheckLink<ICheck<IEnumerable>, IEnumerable> Contains(this ICheck<IEnumerable> check, object[] otherEnumerable)
  • public static ICheckLink<ICheck<IEnumerable<T>>> ContainsExactly<T>(this ICheck<IEnumerable<T>> check, IEnumerable<T> expectedValues)
  • public static ICheckLink<ICheck<IEnumerable<T>>> ContainsExactly<T>(this ICheck<IEnumerable<T>> check, T[] expectedValues)
  • public static ICheckLink<ICheck<IEnumerable>> ContainsExactly(this ICheck<IEnumerable> check, object[] otherEnumerable)
  • public static ICheckLink<ICheck<T>> ContainsNoDuplicateItem<T>(this ICheck<T> context) where T : IEnumerable
  • public static ICheckLink<ICheck<T>> ContainsNoNull<T>(this ICheck<T> context) where T : IEnumerable
  • public static ICheckLinkWhich<ICheck<IEnumerable<T>>, ICheck<T>> ContainsOnlyElementsThatMatch<T>(this ICheck<IEnumerable<T>> check, Func<T, bool> predicate)
  • public static ICheckLink<ICheck<T>> ContainsOnlyInstanceOfType<T>(this ICheck<T> context, Type type) where T : IEnumerable
  • public static ICheckLink<ICheck<IEnumerable<T>>> CountIs<T>(this ICheck<IEnumerable<T>> check, long expectedCount)
  • public static ICheckLinkWhich<ICheck<IEnumerable<T>>, ICheck<T>> HasElementAt<T>(this ICheck<IEnumerable<T>> check, int index)
  • public static ICheckLinkWhich<ICheck<IEnumerable<T>>, ICheck<T>> HasElementThatMatches<T>(this ICheck<IEnumerable<T>> check, Func<T, bool> predicate)
  • public static ICheckLinkWhich<ICheck<IEnumerable<T>>, ICheck<T>> HasFirstElement<T>(this ICheck<IEnumerable<T>> check)
  • public static ICheckLinkWhich<ICheck<IEnumerable<T>>, ICheck<T>> HasLastElement<T>(this ICheck<IEnumerable<T>> check)
  • public static ICheckLinkWhich<ICheck<IEnumerable<T>>, ICheck<T>> HasOneElementOnly<T>(this ICheck<IEnumerable<T>> check)
  • public static ICheckLink<ICheck<IEnumerable<T>>> HasSize<T>(this ICheck<IEnumerable<T>> check, long expectedSize)
  • public static IExtendableCheckLink<IEnumerable> Contains<T>(this ICheck<IEnumerable> check, T[] expectedValues)
  • public static IExtendableCheckLink<IEnumerable> Contains(this ICheck<IEnumerable> check, IEnumerable otherEnumerable)
  • public static ICheckLink<ICheck<IEnumerable>> ContainsExactly<T>(this ICheck<IEnumerable> check, T[] expectedValues)
  • public static ICheckLink<ICheck<IEnumerable>> ContainsExactly(this ICheck<IEnumerable> check, IEnumerable otherEnumerable)
  • public static ICheckLink<ICheck<T>> IsEmpty<T>(this ICheck<T> check) where T : IEnumerable
  • public static ICheckLink<ICheck<IEnumerable>> IsEquivalentTo(this ICheck<IEnumerable> context, object[] expectedValues)
  • public static ICheckLink<ICheck<IEnumerable<T>>> IsEquivalentTo<T>(this ICheck<IEnumerable<T>> context, T[] expectedValues)
  • public static ICheckLink<ICheck<IEnumerable<T>>> IsEquivalentTo<T>(this ICheck<IEnumerable<T>> context, IEnumerable<T> content)
  • public static ICheckLink<ICheck<T>> IsInAscendingOrder<T>(this ICheck<T> context, IComparer comparer = null) where T : IEnumerable
  • public static ICheckLink<ICheck<T>> IsInDescendingOrder<T>(this ICheck<T> context, IComparer comparer = null) where T : IEnumerable
  • public static ICheckLink<ICheck<T>> IsNullOrEmpty<T>(this ICheck<T> check) where T : IEnumerable
  • public static ICheckLink<ICheck<IEnumerable<T>>> IsOnlyMadeOf<T>(this ICheck<IEnumerable<T>> check, T[] expectedValues)
  • public static ICheckLink<ICheck<IEnumerable>> IsOnlyMadeOf(this ICheck<IEnumerable> check, object[] expectedValues)
  • public static ICheckLink<ICheck<IEnumerable<T>>> IsOnlyMadeOf<T>(this ICheck<IEnumerable<T>> check, IEnumerable<T> expectedValues)
  • public static ICheckLink<ICheck<IEnumerable<T>>> IsSubSetOf<T>(this ICheck<IEnumerable<T>> context, IEnumerable<T> expectedSuperset)
  • public static ICheck<long> WhoseSize<T>(this ICheck<IEnumerable<T>> check)
  • public static ICheckLink<ICheck<IEnumerable>> IsEmpty(this ICheck<IEnumerable> check)
  • public static ICheckLink<ICheck<IEnumerable>> IsNullOrEmpty(this ICheck<IEnumerable> check)
  • public static ICheckLink<ICheck<IEnumerable>> IsOnlyMadeOf<T>(this ICheck<IEnumerable> check, T[] expectedValues)
  • public static ICheckLink<ICheck<IEnumerable>> IsOnlyMadeOf(this ICheck<IEnumerable> check, IEnumerable expectedValues)
• public static class EnumerableExtensions
  • public static long Count(this IEnumerable enumerable)
  • public static string ToEnumeratedString(this IEnumerable enumerable)
  • public static string ToEnumeratedString(this IEnumerable enumerable, out long itemsCount, string separator)
  • public static string ToEnumeratedString(this IEnumerable enumerable, out long itemsCount)
  • public static string ToEnumeratedString(this IEnumerable enumerable, string separator)
• public static class EnumerableFluentSyntaxExtension
  • public static IExtendableCheckLink<ICheck<IEnumerable<T>>, IEnumerable<T>> InThatOrder<T>(this IExtendableCheckLink<ICheck<IEnumerable<T>>, IEnumerable<T>> check)
  • public static IExtendableCheckLink<ICheck<IEnumerable>, IEnumerable> InThatOrder(this IExtendableCheckLink<ICheck<IEnumerable>, IEnumerable> check)
  • public static ExtendableCheckLink<ICheck<IEnumerable<T>>, IEnumerable<T>> Once<T>(this ExtendableCheckLink<ICheck<IEnumerable<T>>, IEnumerable<T>> check)
  • public static ExtendableCheckLink<ICheck<IEnumerable>, IEnumerable> Once(this ExtendableCheckLink<ICheck<IEnumerable>, IEnumerable> check)
  • public static ExtendableCheckLink<ICheck<IEnumerable<T>>, IEnumerable<T>> Only<T>(this ExtendableCheckLink<ICheck<IEnumerable<T>>, IEnumerable<T>> check)
  • public static ExtendableCheckLink<ICheck<IEnumerable>, IEnumerable> Only(this ExtendableCheckLink<ICheck<IEnumerable>, IEnumerable> check)
  • public static IExtendableCheckLink<IEnumerable> InThatOrder(this IExtendableCheckLink<IEnumerable> chainedCheckLink)
  • public static IExtendableCheckLink<IEnumerable> Once(this IExtendableCheckLink<IEnumerable> chainedCheckLink)
  • public static IExtendableCheckLink<IEnumerable> Only(this IExtendableCheckLink<IEnumerable> chainedCheckLink)
• public enum EqualityMode
• public static class ExceptionChecks
• public static class ExtractingExtensions
  • public static IEnumerable<object> Extracting<T>(this IEnumerable<T> enumerable, string propertyName)
  • public static IEnumerable<object> Extracting<T>(this T[] array, string propertyName)
  • public static IEnumerable<TP> Extracting<T, TP>(this IEnumerable<T> enumerable, Func<T, TP> getter)
  • public static IEnumerable<TP> Extracting<T, TP>(this T[] array, Func<T, TP> getter)
  • public static IEnumerable Extracting<T>(this IEnumerable<T> enumerable, string propertyName)
  • public static IEnumerable Extracting<T>(this T[] array, string propertyName)
  • public static IEnumerable Properties<T>(this IEnumerable<T> enumerable, string propertyName)
  • public static IEnumerable Properties<T>(this T[] array, string propertyName)
• public static class FloatCheckExtensions
  • public static INullableOrNumberCheckLink<float> HasAValue(this ICheck<float?> check)
  • public static void HasNoValue(this ICheck<float?> check)
  • public static ICheckLink<ICheck<float>> IsGreaterOrEqualThan(this ICheck<float> check, float givenValue)
  • public static ICheckLink<ICheck<float>> IsLessOrEqualThan(this ICheck<float> check, float givenValue)
  • public static ICheckLink<ICheck<float>> IsGreaterThan(this ICheck<float> check, float comparand)
  • public static ICheckLink<ICheck<float>> IsLessThan(this ICheck<float> check, float comparand)
  • public static ICheckLink<ICheck<float>> IsStrictlyGreaterThan(this ICheck<float> check, float comparand)
  • public static ICheckLink<ICheck<float>> IsStrictlyLessThan(this ICheck<float> check, float comparand)
• public static class FloatSignedCheckExtensions
  • public static ICheckLink<ICheck<float>> IsNegativeOrZero(this ICheck<float> check)
  • public static ICheckLink<ICheck<float>> IsPositiveOrZero(this ICheck<float> check)
  • public static ICheckLink<ICheck<float>> IsStrictlyNegative(this ICheck<float> check)
  • public static ICheckLink<ICheck<float>> IsStrictlyPositive(this ICheck<float> check)
  • public static ICheckLink<ICheck<float>> IsNegative(this ICheck<float> check)
  • public static ICheckLink<ICheck<float>> IsPositive(this ICheck<float> check)
• public static class FloatSpecificCheckExtensions
  • public static ICheckLink<ICheck<float>> IsCloseTo(this ICheck<float> check, double expected, double within)
• public class FluentDynamicCheck : IMustImplementIForkableCheckWithoutDisplayingItsMethodsWithinIntelliSense, IForkableCheck
• public class FluentCheckException : Exception
  • public FluentCheckException(string message)
• public class FluentCodeCheck<T> : ICodeCheck<T>, INegateableCheck<ICodeCheck<T>>, IForkableCheck, ICheckForExtensibility<T, ICodeCheck<T>>, IWithValue<T>, IExposingChecker<T, ICodeCheck<T>>, INegated, IMustImplementIForkableCheckWithoutDisplayingItsMethodsWithinIntelliSense where T : RunTrace
  • public IChecker<T, ICodeCheck<T>> Checker { get; }
  • public bool Negated { get; }
  • public ICodeCheck<T> Not { get; }
  • public T Value { get; }
  • public FluentCodeCheck(T getTrace)
  • public object ForkInstance()
• public sealed class FluentStructCheck<T> : IForkableCheck, IStructCheck<T>, INegateableCheck<IStructCheck<T>>, ICheckForExtensibility<T, IStructCheck<T>>, IWithValue<T>, IExposingChecker<T, IStructCheck<T>>, INegated, IMustImplementIForkableCheckWithoutDisplayingItsMethodsWithinIntelliSense where T : struct
  • public IChecker<T, IStructCheck<T>> Checker { get; }
  • public bool Negated { get; }
  • public IStructCheck<T> Not { get; }
  • public T Value { get; }
  • public FluentStructCheck(T value)
  • public ICheckLink<IStructCheck<T>> IsInstanceOf<U>() where U : struct
  • public ICheckLink<IStructCheck<T>> IsNotInstanceOf<U>() where U : struct
• public interface ICheck<T> : IMustImplementIForkableCheckWithoutDisplayingItsMethodsWithinIntelliSense, INegateableCheck<ICheck<T>>
  • ICheckLinkWhich<ICheck<T>, ICheck<TU>> IsInstanceOf<TU>()
  • ICheckLink<ICheck<T>> IsInstanceOf<U>()
• public interface ICheckLinkWhich<TMain, TSub> : ICheckLink<TMain> where TMain : IMustImplementIForkableCheckWithoutDisplayingItsMethodsWithinIntelliSense where TSub : IMustImplementIForkableCheckWithoutDisplayingItsMethodsWithinIntelliSense
• public interface ICheckPlusAnd : ICheck<ReflectionWrapper>, IMustImplementIForkableCheckWithoutDisplayingItsMethodsWithinIntelliSense, INegateableCheck<ICheck<ReflectionWrapper>>
• public interface ICheckWithConsidering : ICheck<ReflectionWrapper>, IMustImplementIForkableCheckWithoutDisplayingItsMethodsWithinIntelliSense, INegateableCheck<ICheck<ReflectionWrapper>>, IPublicOrNot
• public interface ICodeCheck<T> : IMustImplementIForkableCheckWithoutDisplayingItsMethodsWithinIntelliSense, INegateableCheck<ICodeCheck<T>> where T : RunTrace
• public interface IExposingChecker<T, TC> where TC : IMustImplementIForkableCheckWithoutDisplayingItsMethodsWithinIntelliSense
  • IChecker<T, TC> Checker { get; }
• public interface IExtendableCheckLink<T> : ICheckLink<ICheck<T>>
  • T OriginalComparand { get; }
• public interface IExtendableCheckLink<T, U> : ICheckLink<ICheck<T>>
  • T AccessCheck { get; }
  • TU OriginalComparand { get; }
  • U OriginalComparand { get; }
• public interface IFieldsOrProperties
• public interface IForkableCheck
  • object ForkInstance()
• public interface ILambdaCheck : IMustImplementIForkableCheckWithoutDisplayingItsMethodsWithinIntelliSense
  • ICheckLink<ILambdaCheck> DoesNotThrow()
  • ICheckLink<ILambdaCheck> LastsLessThan(double threshold, TimeUnit timeUnit)
  • ILambdaExceptionCheck<ILambdaCheck> Throws<T>()
  • ILambdaExceptionCheck<ILambdaCheck> ThrowsAny()
• public interface ILambdaExceptionCheck<TParent> : IHasParentCheck<TParent>, IMustImplementIForkableCheckWithoutDisplayingItsMethodsWithinIntelliSense
  • TException Value { get; }
  • ILambdaExceptionCheck<TE> DueTo<TE>() where TE : Exception
  • ICheckLink<ILambdaExceptionCheck<TParent>> WithMessage(string exceptionMessage)
  • ICheckLink<ILambdaExceptionCheck<TParent>> WithProperty(string propertyName, object propertyValue)
• public interface IMembersSelection : IFieldsOrProperties, IPublicOrNot
• public static class IntCheckExtensions
  • public static INullableOrNumberCheckLink<int> HasAValue(this ICheck<int?> check)
  • public static void HasNoValue(this ICheck<int?> check)
  • public static ICheckLink<ICheck<int>> IsGreaterOrEqualThan(this ICheck<int> check, int givenValue)
  • public static ICheckLink<ICheck<int>> IsLessOrEqualThan(this ICheck<int> check, int givenValue)
  • public static ICheckLink<ICheck<int>> IsGreaterThan(this ICheck<int> check, int comparand)
  • public static ICheckLink<ICheck<int>> IsLessThan(this ICheck<int> check, int comparand)
  • public static ICheckLink<ICheck<int>> IsStrictlyGreaterThan(this ICheck<int> check, int comparand)
  • public static ICheckLink<ICheck<int>> IsStrictlyLessThan(this ICheck<int> check, int comparand)
• public static class IntSignedCheckExtensions
  • public static ICheckLink<ICheck<int>> IsNegativeOrZero(this ICheck<int> check)
  • public static ICheckLink<ICheck<int>> IsPositiveOrZero(this ICheck<int> check)
  • public static ICheckLink<ICheck<int>> IsStrictlyNegative(this ICheck<int> check)
  • public static ICheckLink<ICheck<int>> IsStrictlyPositive(this ICheck<int> check)
  • public static ICheckLink<ICheck<int>> IsNegative(this ICheck<int> check)
  • public static ICheckLink<ICheck<int>> IsPositive(this ICheck<int> check)
• public interface INullableOrNumberCheckLink<N> where N : struct
  • ICheck<TN?> And { get; }
  • ICheck<TN> Which { get; }
  • ICheck<N?> And { get; }
  • ICheck<N> Which { get; }
• public interface IPublicOrNot
• public interface IStructCheck<T> : IMustImplementIForkableCheckWithoutDisplayingItsMethodsWithinIntelliSense, INegateableCheck<IStructCheck<T>> where T : struct
  • bool Equals(object obj)
  • ICheckLink<IStructCheck<T>> IsInstanceOf<U>() where U : struct
  • ICheckLink<IStructCheck<T>> IsNotInstanceOf<U>() where U : struct
• public class LambdaCheck : ILambdaCheck, IMustImplementIForkableCheckWithoutDisplayingItsMethodsWithinIntelliSense, IForkableCheck
  • public LambdaCheck(Delegate action)
  • public ICheckLink<ILambdaCheck> DoesNotThrow()
  • public object ForkInstance()
  • public ICheckLink<ILambdaCheck> LastsLessThan(double threshold, TimeUnit timeUnit)
  • public ILambdaExceptionCheck<ILambdaCheck> Throws<T>()
  • public ILambdaExceptionCheck<ILambdaCheck> ThrowsAny()
• public class LambdaExceptionCheck<T> : ILambdaExceptionCheck<T>, IHasParentCheck<T>, IMustImplementIForkableCheckWithoutDisplayingItsMethodsWithinIntelliSense, IForkableCheck
  • public LambdaExceptionCheck(T value, bool negated)
  • public ILambdaExceptionCheck<TE> DueTo<TE>() where TE : Exception
  • public LambdaExceptionCheck(Exception value)
  • public ICheckLink<ILambdaExceptionCheck<T>> WithMessage(string exceptionMessage)
  • public ICheckLink<ILambdaExceptionCheck<T>> WithProperty(string propertyName, object propertyValue)
• public static class LongCheckExtensions
  • public static INullableOrNumberCheckLink<long> HasAValue(this ICheck<long?> check)
  • public static void HasNoValue(this ICheck<long?> check)
  • public static ICheckLink<ICheck<long>> IsGreaterOrEqualThan(this ICheck<long> check, long givenValue)
  • public static ICheckLink<ICheck<long>> IsLessOrEqualThan(this ICheck<long> check, long givenValue)
  • public static ICheckLink<ICheck<long>> IsGreaterThan(this ICheck<long> check, long comparand)
  • public static ICheckLink<ICheck<long>> IsLessThan(this ICheck<long> check, long comparand)
  • public static ICheckLink<ICheck<long>> IsStrictlyGreaterThan(this ICheck<long> check, long comparand)
  • public static ICheckLink<ICheck<long>> IsStrictlyLessThan(this ICheck<long> check, long comparand)
• public static class LongSignedCheckExtensions
  • public static ICheckLink<ICheck<long>> IsNegativeOrZero(this ICheck<long> check)
  • public static ICheckLink<ICheck<long>> IsPositiveOrZero(this ICheck<long> check)
  • public static ICheckLink<ICheck<long>> IsStrictlyNegative(this ICheck<long> check)
  • public static ICheckLink<ICheck<long>> IsStrictlyPositive(this ICheck<long> check)
  • public static ICheckLink<ICheck<long>> IsNegative(this ICheck<long> check)
  • public static ICheckLink<ICheck<long>> IsPositive(this ICheck<long> check)
• public class MacroCheck<T, T1>
• public class MacroCheck<T, T1, T2>
• public static class MacroCheckExtensions
• public class MacroContext<T, T1> : MacroContextBase<T>
• public class MacroContext<T, T1, T2> : MacroContextBase<T>
• public class MacroContextBase<T>
• public static class MemberCheckExtensions
• public static class MessageRelatedExtensions
• public class NFluentEntryPoint
• public class NumberCheck<N> where N : IComparable
  • public NumberCheck(ICheck<N> check)
  • public ICheckLink<ICheck<N>> IsGreaterThan(N comparand)
  • public ICheckLink<ICheck<N>> IsLessThan(N comparand)
  • public ICheckLink<ICheck<N>> IsNegative()
  • public ICheckLink<ICheck<N>> IsNotZero()
  • public ICheckLink<ICheck<N>> IsPositive()
  • public ICheckLink<ICheck<N>> IsZero()
• public static class ObjectCheckExtensions
  • public static ICheckLinkWhich<ICheck<T?>, ICheck<T>> HasAValue<T>(this ICheck<T?> check) where T : struct
  • public static ICheckLink<ICheck<T>> HasDifferentValueThan<T, TU>(this ICheck<T> check, TU expected)
  • public static ICheckLink<ICheck<T?>> HasNoValue<T>(this ICheck<T?> check) where T : struct
  • public static ICheckLink<ICheck<T>> HasSameValueAs<T, TU>(this ICheck<T> check, TU expected)
  • public static ICheckLink<ICheck<object>> HasFieldsEqualToThose(this ICheck<object> check, object expected)
  • public static ICheckLink<ICheck<object>> HasFieldsNotEqualToThose(this ICheck<object> check, object expected)
  • public static ICheckLink<ICheck<T>> HasFieldsWithSameValues<T>(this ICheck<T> check, object expected)
  • public static ICheckLink<ICheck<T>> HasNotFieldsWithSameValues<T>(this ICheck<T> check, object expected)
  • public static ICheckLink<ICheck<T>> InheritsFromType<T>(this ICheck<T> check, Type parentType)
  • public static ICheckLink<ICheck<T>> Is<T>(this ICheck<T> check, T expected)
  • public static ICheckLink<ICheck<T>> IsDefaultValue<T>(this ICheck<T> context)
  • public static ICheckLink<ICheck<T>> IsDistinctFrom<T, TU>(this ICheck<T> check, TU comparand)
  • public static ICheckLink<ICheck<T>> IsEqualTo<T, TE>(this ICheck<T> check, TE expected, IEqualityComparer customComparer = null)
  • public static ICheckLink<ICheck<T>> IsDistinctFrom<T>(this ICheck<T> check, object comparand)
  • public static ICheckLink<ICheck<T>> IsEqualTo<T>(this ICheck<T> check, T expected)
  • public static ICheckLink<ICheck<T>> IsOneOf<T>(this ICheck<T> check, T[] values)
  • public static ICheckLink<ICheck<T>> IsSameReferenceAs<T, TU>(this ICheck<T> check, TU expected)
  • public static ICheckLink<ICheck<T>> IsSameReferenceThan<T>(this ICheck<T> check, object expected)
• public static class ObjectChecksNonGenericVariants
• public static class ObjectFieldsCheckExtensions
• public static class ReflectionWrapperChecks
• public static class SbyteCheckExtensions
  • public static INullableOrNumberCheckLink<sbyte> HasAValue(this ICheck<sbyte?> check)
  • public static void HasNoValue(this ICheck<sbyte?> check)
  • public static ICheckLink<ICheck<sbyte>> IsGreaterOrEqualThan(this ICheck<sbyte> check, sbyte givenValue)
  • public static ICheckLink<ICheck<sbyte>> IsLessOrEqualThan(this ICheck<sbyte> check, sbyte givenValue)
  • public static ICheckLink<ICheck<sbyte>> IsGreaterThan(this ICheck<sbyte> check, sbyte comparand)
  • public static ICheckLink<ICheck<sbyte>> IsLessThan(this ICheck<sbyte> check, sbyte comparand)
  • public static ICheckLink<ICheck<sbyte>> IsStrictlyGreaterThan(this ICheck<sbyte> check, sbyte comparand)
  • public static ICheckLink<ICheck<sbyte>> IsStrictlyLessThan(this ICheck<sbyte> check, sbyte comparand)
• public static class SbyteSignedCheckExtensions
  • public static ICheckLink<ICheck<sbyte>> IsNegativeOrZero(this ICheck<sbyte> check)
  • public static ICheckLink<ICheck<sbyte>> IsPositiveOrZero(this ICheck<sbyte> check)
  • public static ICheckLink<ICheck<sbyte>> IsStrictlyNegative(this ICheck<sbyte> check)
  • public static ICheckLink<ICheck<sbyte>> IsStrictlyPositive(this ICheck<sbyte> check)
  • public static ICheckLink<ICheck<sbyte>> IsNegative(this ICheck<sbyte> check)
  • public static ICheckLink<ICheck<sbyte>> IsPositive(this ICheck<sbyte> check)
• public static class ShortCheckExtensions
  • public static INullableOrNumberCheckLink<short> HasAValue(this ICheck<short?> check)
  • public static void HasNoValue(this ICheck<short?> check)
  • public static ICheckLink<ICheck<short>> IsGreaterOrEqualThan(this ICheck<short> check, short givenValue)
  • public static ICheckLink<ICheck<short>> IsLessOrEqualThan(this ICheck<short> check, short givenValue)
  • public static ICheckLink<ICheck<short>> IsGreaterThan(this ICheck<short> check, short comparand)
  • public static ICheckLink<ICheck<short>> IsLessThan(this ICheck<short> check, short comparand)
  • public static ICheckLink<ICheck<short>> IsStrictlyGreaterThan(this ICheck<short> check, short comparand)
  • public static ICheckLink<ICheck<short>> IsStrictlyLessThan(this ICheck<short> check, short comparand)
• public static class ShortSignedCheckExtensions
  • public static ICheckLink<ICheck<short>> IsNegativeOrZero(this ICheck<short> check)
  • public static ICheckLink<ICheck<short>> IsPositiveOrZero(this ICheck<short> check)
  • public static ICheckLink<ICheck<short>> IsStrictlyNegative(this ICheck<short> check)
  • public static ICheckLink<ICheck<short>> IsStrictlyPositive(this ICheck<short> check)
  • public static ICheckLink<ICheck<short>> IsNegative(this ICheck<short> check)
  • public static ICheckLink<ICheck<short>> IsPositive(this ICheck<short> check)
• public static class StreamCheckExtensions
• public static class StringCheckExtensions
  • public static ICheck<IEnumerable<string>> AsLines(this ICheck<string> check)
  • public static ExtendableCheckLink<ICheck<string>, string[]> Contains(this ICheck<string> check, string[] values)
  • public static IExtendableCheckLink<string, string[]> Contains(this ICheck<string> check, string[] values)
  • public static ICheckLink<ICheck<string>> IsEqualTo(this ICheck<string> check, object expected)
  • public static ICheckLink<ICheck<string>> IsNotEqualTo(this ICheck<string> check, object expected)
  • public static ICheckLink<ICheck<string>> IsNullOrWhiteSpace(this ICheck<string> check)
  • public static ICheckLink<ICheck<string>> MatchesWildcards(this ICheck<string> context, string expression)
• public static class StringFluentSyntaxExtension
  • public static IExtendableCheckLink<ICheck<string>, string[]> InThatOrder(this ExtendableCheckLink<ICheck<string>, string[]> chainedCheckLink)
  • public static ExtendableCheckLink<ICheck<string>, string[]> Once(this ExtendableCheckLink<ICheck<string>, string[]> chainedCheckLink)
  • public static IExtendableCheckLink<string, string[]> InThatOrder(this IExtendableCheckLink<string, string[]> chainedCheckLink)
  • public static IExtendableCheckLink<string, string[]> Once(this IExtendableCheckLink<string, string[]> chainedCheckLink)
• public static class StructCheckExtensions
  • public static ICheckLink<IStructCheck<T>> IsEqualTo<T>(this IStructCheck<T> check, T expected) where T : struct
  • public static ICheckLink<IStructCheck<T>> IsNotEqualTo<T>(this IStructCheck<T> check, object expected) where T : struct
• public static class TimeSpanCheckExtensions
  • public static ICheckLink<ICheck<TimeSpan>> IsEqualTo(this ICheck<TimeSpan> check, Duration expected)
  • public static ICheckLink<ICheck<TimeSpan>> IsGreaterThan(this ICheck<TimeSpan> check, Duration providedDuration)
  • public static ICheckLink<ICheck<TimeSpan>> IsLessThan(this ICheck<TimeSpan> check, Duration providedDuration)
• public static class TypeCheckExtensions
• public static class UintCheckExtensions
  • public static INullableOrNumberCheckLink<uint> HasAValue(this ICheck<uint?> check)
  • public static void HasNoValue(this ICheck<uint?> check)
  • public static ICheckLink<ICheck<uint>> IsGreaterOrEqualThan(this ICheck<uint> check, uint givenValue)
  • public static ICheckLink<ICheck<uint>> IsLessOrEqualThan(this ICheck<uint> check, uint givenValue)
  • public static ICheckLink<ICheck<uint>> IsGreaterThan(this ICheck<uint> check, uint comparand)
  • public static ICheckLink<ICheck<uint>> IsLessThan(this ICheck<uint> check, uint comparand)
  • public static ICheckLink<ICheck<uint>> IsStrictlyGreaterThan(this ICheck<uint> check, uint comparand)
  • public static ICheckLink<ICheck<uint>> IsStrictlyLessThan(this ICheck<uint> check, uint comparand)
• public static class UlongCheckExtensions
  • public static INullableOrNumberCheckLink<ulong> HasAValue(this ICheck<ulong?> check)
  • public static void HasNoValue(this ICheck<ulong?> check)
  • public static ICheckLink<ICheck<ulong>> IsGreaterOrEqualThan(this ICheck<ulong> check, ulong givenValue)
  • public static ICheckLink<ICheck<ulong>> IsLessOrEqualThan(this ICheck<ulong> check, ulong givenValue)
  • public static ICheckLink<ICheck<ulong>> IsGreaterThan(this ICheck<ulong> check, ulong comparand)
  • public static ICheckLink<ICheck<ulong>> IsLessThan(this ICheck<ulong> check, ulong comparand)
  • public static ICheckLink<ICheck<ulong>> IsStrictlyGreaterThan(this ICheck<ulong> check, ulong comparand)
  • public static ICheckLink<ICheck<ulong>> IsStrictlyLessThan(this ICheck<ulong> check, ulong comparand)
• public static class UshortCheckExtensions
  • public static INullableOrNumberCheckLink<ushort> HasAValue(this ICheck<ushort?> check)
  • public static void HasNoValue(this ICheck<ushort?> check)
  • public static ICheckLink<ICheck<ushort>> IsGreaterOrEqualThan(this ICheck<ushort> check, ushort givenValue)
  • public static ICheckLink<ICheck<ushort>> IsLessOrEqualThan(this ICheck<ushort> check, ushort givenValue)
  • public static ICheckLink<ICheck<ushort>> IsGreaterThan(this ICheck<ushort> check, ushort comparand)
  • public static ICheckLink<ICheck<ushort>> IsLessThan(this ICheck<ushort> check, ushort comparand)
  • public static ICheckLink<ICheck<ushort>> IsStrictlyGreaterThan(this ICheck<ushort> check, ushort comparand)
  • public static ICheckLink<ICheck<ushort>> IsStrictlyLessThan(this ICheck<ushort> check, ushort comparand)

NFluent.ApiChecks

• public static class ExceptionChecks

NFluent.Extensibility

• public static class CheckLogicExtensions
• public static class ExtensibilityHelper
  • public static ICheckLogic<T> BeginCheck<T>(ICheck<T> check)
  • public static ICheckLogic<T> BeginCheck<T>(FluentSut<T> sut)
  • public static ICheckLogic<TU> BeginCheckAs<T, TU>(ICheck<T> check, Func<T, TU> converter)
  • public static ICheckLink<ICheck<T>> BuildCheckLink<T>(ICheck<T> check)
  • public static ICheckLinkWhich<ICheck<TU>, ICheck<T>> BuildCheckLinkWhich<TU, T>(ICheck<TU> check, T item, EntityNamingLogic label)
  • public static ICheckLinkWhich<ICheck<TU>, ICheck<T>> BuildCheckLinkWhich<TU, T>(ICheck<TU> check, T item, string label, bool hasItem = true)
  • public static ExtendableCheckLink<T, TU> BuildExtendableCheckLink<T, TU>(T check, TU value) where T : IMustImplementIForkableCheckWithoutDisplayingItsMethodsWithinIntelliSense
  • public static IChecker<TU, ICodeCheck<TU>> ExtractCodeChecker<TU>(ICodeCheck<TU> check) where TU : RunTrace
  • public static IChecker<TS, IStructCheck<TS>> ExtractStructChecker<TS>(IStructCheck<TS> check) where TS : struct
• public class FluentMessage
  • public class MessageBlock
  • public string ExpectedLabel { get; }
  • public string ExpectedValuesLabel { get; }
  • protected string GivenLabel { get; }
  • public string TestedLabel { get; }
  • public FluentMessage(string message)
  • public static FluentMessage BuildMessageWithGiven(string message)
  • public FluentMessage AddCustomMessage(string customAddOnMessage)
  • public MessageBlock Expected<T>(T expected, long? index = default)
  • public MessageBlock ExpectedValues<T>(T expectedValues, long? index = default)
  • public FluentMessage For(EntityNamingLogic newEntityDescription)
  • public FluentMessage For(Type forcedType)
  • public MessageBlock On<T>(T test, long? index = default)
  • public MessageBlock ReferenceValues<T>(T expected)
  • public MessageBlock WithGivenValue<T>(T givenValue, long? index = default)
  • public MessageBlock Expected(object expected)
  • public MessageBlock ExpectedType(Type expectedType)
  • public MessageBlock ExpectedValues(object expectedValues)
  • public FluentMessage For(string newEntityDescription)
  • public MessageBlock On(object test)
  • public MessageBlock WithGivenValue(object givenValue)
• public interface IChecker<T, C> : IWithValue<T>, INegated where C : IMustImplementIForkableCheckWithoutDisplayingItsMethodsWithinIntelliSense
  • ICheckLogic<T> BeginCheck()
  • ICheckLink<TC> BuildChainingObject()
  • FluentMessage BuildMessage(string message)
  • FluentMessage BuildShortMessage(string message)
  • ICheckLink<TC> ExecuteCheck(Action action, string negatedExceptionMessage)
  • void ExecuteNotChainableCheck(Action action, string negatedExceptionMessage)
  • ICheck<TU> ExtractSub<TU>(Func<T, TU> extractor, string label)
  • void SetSutLabel(string sutLabel)
  • ICheckLink<C> ReturnValueForLinkage { get; }
  • ICheckLink<C> ExecuteCheck(Action action, string negatedExceptionMessage)
  • void ExecuteNotLinkableCheck(Action action, string negatedExceptionMessage)
• public interface ICheckLogic<T> : ICheckLogicBase
• public interface ICheckLogicBase
• public interface IErrorReporter
• public interface IExposingChecker<T, TC> where TC : IMustImplementIForkableCheckWithoutDisplayingItsMethodsWithinIntelliSense
• public class MessageBlock
• public enum MessageOption
• public static class ReverseEngineeringExceptionMessagesHelper

NFluent.Extensions

• public static class ExtensionsCommonHelpers
  • public static Type GetBaseType(this Type type)
  • public static string DoubleCurlyBraces(this string value)
  • public static bool IsPrimitive(this Type type)
  • public static string ToStringProperlyFormatted(this object theObject)
  • public static string TypeToStringProperlyFormatted(this Type type, bool shortName = false)
  • public static string ToStringProperlyFormated(this object theObject)
  • public static string ToStringProperlyFormated(this DateTime theDateTime)
  • public static string ToStringProperlyFormated(this bool theBoolean)
  • public static string TypeToStringProperlyFormated(this Type type, bool shortName = false)
• public static class StringExtensions

NFluent.Helpers

• public struct Duration
• public static class ComparableHelper
  • public static void IsAfter(IComparable checkedValue, IComparable givenValue)
  • public static void IsBefore(IComparable checkedValue, IComparable givenValue)
• public static class ExceptionHelper
  • public static Exception BuildInconclusiveException(string theMessage)
  • public static string DumpInnerExceptionStackTrace(Exception exception)
  • public static Type FailedExceptionType()
  • public static Type InconclusiveExceptionType()
  • public static void ResetCache()
• public static class FailureHandler
• public class ReflectionWrapper
• public enum TestFramework
• public static class TimeHelper
  • public static long GetInTicks(long value, TimeUnit unit)

NFluent.Kernel

• public class ExtendableCheckLink<T, TU> : IExtendableCheckLink<T, TU>, ICheckLink<T> where T : IMustImplementIForkableCheckWithoutDisplayingItsMethodsWithinIntelliSense
• public class FluentCheckException : Exception
• public class FluentSut<T> : IWithValue<T>, INegated
• public class NumberCheck<TN> where TN : IComparable

NFluent.Messages

• public class EntityNamingLogic
• public interface ISelfDescriptiveValue

NFluent.Mocks

• public sealed class CaptureConsole : IDisposable