/// <summary>
/// Reports a certain failure.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="_">A do not care place holder rooting the extension method.</param>
/// <param name="message">The message.</param>
/// <returns>The <paramref name="_"/> place holder after Reporting the certain Failure.</returns>
public static T ReportFail <T>(this T _, FluentMessageCallback message = null)
{
void Evaluate(string s) => Report.Fail(s.Notify());
Evaluate(message.UseCallbackOrDefault().Invoke());
return(_);
}
/// <summary>
/// Reports an error if the <paramref name="condition"/> Evaluates to True.
/// </summary>
/// <param name="condition">An error is reported when <paramref name="condition"/> is False.</param>
/// <param name="message"></param>
/// <returns>The <paramref name="condition"/> after Reporting If met.</returns>
public static bool ReportIf(this bool condition, FluentMessageCallback message = null)
{
void Evaluate(bool y, string s) => Report.If(y, s.Notify(y));
Evaluate(condition, message.UseCallbackOrDefault().Invoke());
return(condition);
}
private static Action VerifyRequirement <T>(T _, FluentMessageCallback message, Exception innerException = null)
{
// ReSharper disable once ImplicitlyCapturedClosure
Action GetRequiresFail() => () => _.RequiresFail(message);
Action GetRequiresFailWithInnerException() => () => _.RequiresFail(innerException, message);
return(innerException == null?GetRequiresFail() : GetRequiresFailWithInnerException());
}
/// <summary>
/// Throws an <see cref="InvalidOperationException"/> if a <paramref name="condition"/>
/// is False.
/// </summary>
/// <param name="condition">The Condition which returns True to avoid <see cref="InvalidOperationException"/>.</param>
/// <param name="message">The message to use for the thrown exception.</param>
/// <returns>The <paramref name="condition"/> after Operation is Verified.</returns>
public static bool VerifyOperation(this bool condition, FluentMessageCallback message)
{
Verify.Operation(condition, message.Invoke());
return(condition);
}
/// <summary>
/// Throws an <see cref="InvalidOperationException"/> if a <paramref name="value"/>
/// <paramref name="condition"/> is False.
/// </summary>
/// <typeparam name="T">The Value type.</typeparam>
/// <param name="value">The Value.</param>
/// <param name="condition">The Condition which returns True to avoid <see cref="InvalidOperationException"/>.</param>
/// <param name="message">The message for use with the thrown exception.</param>
/// <returns>The <paramref name="value"/> after Operation <paramref name="condition"/> is Verified.</returns>
public static T VerifyOperation <T>(this T value, FluentConditionCallback <T> condition, FluentMessageCallback message)
{
Verify.Operation(condition.Invoke(value), message.Invoke());
return(value);
}
/// <summary>
/// Throws an <see cref="ObjectDisposedException"/> when <paramref name="condition"/>
/// is False.
/// </summary>
/// <typeparam name="T">The Value type.</typeparam>
/// <param name="value">The Value whose <see cref="IDisposable"/> is under consideration.</param>
/// <param name="condition">the condition which returns True to avoid <see cref="ObjectDisposedException"/>.</param>
/// <param name="message">The message to use for the thrown exception.</param>
/// <returns>The <paramref name="value"/> after Not Disposed <paramref name="condition"/> is Verified.</returns>
public static T VerifyValueNotDisposed <T>(this T value, FluentConditionCallback <T> condition, FluentMessageCallback message = null)
where T : IDisposable
{
Verify.NotDisposed(condition.Invoke(value), value, message?.Invoke());
return(value);
}
/// <summary>
/// Throws an <see cref="ObjectDisposedException"/> when
/// <see cref="IDisposableObservable.IsDisposed"/> is False.
/// </summary>
/// <typeparam name="T">The Value type.</typeparam>
/// <param name="disposedValue">The Disposed Value whose <see cref="IDisposableObservable"/> is under consideration.</param>
/// <param name="message">The message to use for the thrown exception.</param>
/// <returns>The <paramref name="disposedValue"/> after Not Disposed is Verified.</returns>
public static T VerifyObservableValueNotDisposed <T>(this T disposedValue, FluentMessageCallback message)
where T : IDisposableObservable
{
Verify.NotDisposed(disposedValue, message.Invoke());
return(disposedValue);
}
/// <summary>
/// Throws an public exception if a condition evaluates to true.
/// </summary>
/// <param name="condition"></param>
/// <param name="message"></param>
/// <returns></returns>
/// <see cref="Assumes.False(bool,string)"/>
public static bool AssumesFalse(this bool condition, FluentMessageCallback message = null)
{
Assumes.False(condition, message.UseCallbackOrDefault().Invoke());
return(condition);
}
/// <summary>
/// Throws an <see cref="ArgumentOutOfRangeException"/> if a <paramref name="condition"/>
/// Does Not Evaluate to True.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="value"></param>
/// <param name="condition"></param>
/// <param name="argumentName"></param>
/// <param name="message"></param>
/// <returns>The <paramref name="value"/> after Range <paramref name="condition"/> is Required.</returns>
public static T RequiresRange <T>(this T value, FluentConditionCallback <T> condition, string argumentName, FluentMessageCallback message = null)
{
Requires.Range(condition.Invoke(value), argumentName, message.UseCallbackOrDefault().Invoke());
return(value);
}
/// <summary>
/// Throws an <see cref="ObjectDisposedException"/> when <paramref name="condition"/>
/// is False. Unlike the Condition Only extension method, this method passes the
/// <paramref name="value"/> through to the API.
/// </summary>
/// <param name="value">The Disposed Value.</param>
/// <param name="condition">The condition which returns True to avoid <see cref="ObjectDisposedException"/>.</param>
/// <param name="message">The message to use for the thrown exception.</param>
/// <returns>The <paramref name="value"/> after Not Disposed <paramref name="condition"/> is Verified.</returns>
public static object VerifyValueNotDisposed(this object value, FluentConditionCallback <object> condition, FluentMessageCallback message = null)
{
Verify.NotDisposed(condition.Invoke(value), value, message?.Invoke());
return(value);
}
/// <summary>
/// Validates some expression describing the acceptable <paramref name="condition"/>
/// for an argument Evaluates to True.
/// </summary>
/// <param name="condition">The expression that must Evaluate to True to avoid an <see cref="InvalidOperationException"/>.</param>
/// <param name="message">The message to include with the exception.</param>
/// <returns>The <paramref name="condition"/> after Valid State is Required.</returns>
public static bool RequiresValidState(this bool condition, FluentMessageCallback message)
{
Requires.ValidState(condition, message.Invoke());
return(condition);
}
// TODO: TBD: `out of range´ of what? would it not be worth specifying in terms of at least an IEnumerable<T>? /// <summary> /// Throws an <see cref="ArgumentOutOfRangeException"/> when <paramref name="value"/> /// <paramref name="evaluate"/> returns false. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="value"></param> /// <param name="argumentName"></param> /// <param name="evaluate"></param> /// <param name="message"></param> /// <returns>Nothing. This method always throws.</returns> public static Exception RequiresFailRange <T>(this T value, string argumentName, FluentRangeVerificationCallback <T> evaluate, FluentMessageCallback message = null) => evaluate.Invoke(value) ? null : Requires.FailRange(argumentName, message.UseCallbackOrDefault().Invoke());
/// <summary>
/// Validates some expression describing the acceptable <paramref name="condition"/>
/// for an argument Evaluates to True.
/// </summary>
/// <param name="condition">The expression that must Evaluate to True to avoid an <see cref="ArgumentException"/>.</param>
/// <param name="argumentName">The name of the argument.</param>
/// <param name="message">The message.</param>
/// <returns>The <paramref name="condition"/> after That <paramref name="condition"/> is Required.</returns>
public static bool RequiresThat(this bool condition, string argumentName, FluentMessageCallback message)
{
Requires.That(condition, argumentName, message.Invoke());
return(condition);
}
/// <summary> /// Throws an <see cref="ArgumentException"/>. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="_"></param> /// <param name="innerException"></param> /// <param name="message"></param> /// <returns>Nothing. This method always throws. But the signature allows calling /// code to "throw" this method for CSharp syntax reasons.</returns> public static Exception RequiresFail <T>(this T _, Exception innerException, FluentMessageCallback message) => Requires.Fail(innerException, message.UseCallbackOrDefault().Invoke());
/// <summary>
/// Validates some expression describing the acceptable <paramref name="condition"/>
/// for an argument Evaluates to True.
/// </summary>
/// <typeparam name="T">The type of the argument.</typeparam>
/// <param name="value">The Value of the argument.</param>
/// <param name="condition">The expression that must Evaluate to True to avoid an <see cref="InvalidOperationException"/>.</param>
/// <param name="message">The message to include with the exception.</param>
/// <returns>The <paramref name="value"/> after Valid State <paramref name="condition"/> is Required.</returns>
public static T RequiresValidState <T>(this T value, FluentConditionCallback <T> condition, FluentMessageCallback message)
{
Requires.ValidState(condition.Invoke(value), message.Invoke());
return(value);
}
/// <summary>
/// Throws an <see cref="ArgumentException"/> if a <paramref name="condition"/>
/// does not evaluate to True.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="argument"></param>
/// <param name="condition"></param>
/// <param name="argumentName"></param>
/// <param name="message"></param>
/// <returns></returns>
public static T RequiresArgument <T>(this T argument, FluentConditionCallback <T> condition, string argumentName, FluentMessageCallback message)
{
Requires.Argument(condition.Invoke(argument), argumentName, message.Invoke());
return(argument);
}
/// <summary> /// Throws an <see cref="InvalidOperationException"/>. /// </summary> /// <typeparam name="T">The type of the root place holder.</typeparam> /// <param name="_">A do not care place holder to root the extension method.</param> /// <param name="message">The message to use with the thrown exception.</param> /// <returns>Nothing. This method always throws. The signature claims to return an /// exception to allow callers to throw this method to satisfy CSharp execution /// path constraints.</returns> public static Exception VerifyFailOperation <T>(this T _, FluentMessageCallback message) => Verify.FailOperation(message.Invoke());
/// <summary> /// Throws an public exception. /// </summary> /// <param name="_">A do not care place holder in order to root the extension method.</param> /// <param name="message">The message to use for the thrown exception.</param> /// <param name="innerException">An inner <see cref="Exception"/> for use with the thrown exception.</param> /// <param name="showAssert">Whether to Show an Assert.</param> /// <returns>Nothing, as this method always throws. The signature allows for /// "throwing" Fail so C# knows execution will stop.</returns> /// <see cref="Assumes.Fail(string,Exception,bool)"/> public static Exception AssumesFail(this object _, FluentMessageCallback message, Exception innerException, bool showAssert = true) => Assumes.Fail(message.Invoke(), innerException, showAssert);
/// <summary> /// Conditionally throws an <see cref="InvalidOperationException"/> based on the /// <paramref name="condition"/>. /// </summary> /// <typeparam name="T">The type of the root place holder.</typeparam> /// <param name="_">A do not care place holder to root the extension method.</param> /// <param name="condition">Condition must return true to avoid failing the operation.</param> /// <param name="message">The message to use with the thrown exception.</param> /// <returns>The root place holder after Fail Operation is Verified.</returns> public static Exception VerifyFailOperation <T>(this T _, FluentConditionCallback <T> condition, FluentMessageCallback message) => condition.Invoke(_) ? default : Verify.FailOperation(message.Invoke());
/// <summary>
/// Validates some expression describing the acceptable <paramref name="condition"/>
/// for an argument <paramref name="value"/> Evaluates to True.
/// </summary>
/// <typeparam name="T">The type of the argument.</typeparam>
/// <param name="value">The Value of the argument.</param>
/// <param name="condition">The Condition to Evaluate to True to avoid an <see cref="ArgumentException"/>.</param>
/// <param name="argumentName">The name of the argument.</param>
/// <param name="message">The message.</param>
/// <returns>The <paramref name="value"/> after That <paramref name="value"/> is Required.</returns>
public static T RequiresThat <T>(this T value, FluentConditionCallback <T> condition, string argumentName, FluentMessageCallback message)
{
Requires.That(condition.Invoke(value), argumentName, message.Invoke());
return(value);
}
/// <summary> /// Throws an public exception. /// </summary> /// <typeparam name="T">The place holder type.</typeparam> /// <param name="message">The message to use for the thrown exception.</param> /// <param name="showAssert">Whether to Show an Assert.</param> /// <returns>Nothing, as this method always throws. The signature allows for /// "throwing" Fail so CSharp knows execution will stop.</returns> /// <see cref="Assumes.Fail(string,bool)"/> public static Exception AssumesFail <T>(this T _, FluentMessageCallback message, bool showAssert = true) => Assumes.Fail(message.Invoke(), showAssert);
/// <summary>
/// Reports an error if the <paramref name="condition"/> Evaluates to True.
/// </summary>
/// <param name="value">The Value being Reported upon.</param>
/// <param name="condition">An error is reported when <paramref name="condition"/> returns False.</param>
/// <param name="message"></param>
/// <returns>The <paramref name="value"/> after Reporting If <paramref name="condition"/> met.</returns>
public static object ReportIf(this object value, FluentConditionCallback <object> condition, FluentMessageCallback message = null)
{
void Evaluate(bool y, string s) => Report.If(y, s.Notify(y));
Evaluate(condition.Invoke(value), message.UseCallbackOrDefault().Invoke());
return(value);
}
/// <summary> /// Throws an public exception. /// </summary> /// <typeparam name="T">The place holder type.</typeparam> /// <param name="message">The message to use for the thrown exception.</param> /// <param name="innerException">An inner <see cref="Exception"/> for use with the thrown exception.</param> /// <param name="showAssert">Whether to Show an Assert.</param> /// <returns>Nothing, as this method always throws. The signature allows for /// "throwing" Fail so C# knows execution will stop.</returns> /// <see cref="Assumes.Fail(string,Exception,bool)"/> public static Exception AssumesFail <T>(this T _, FluentMessageCallback message, Exception innerException, bool showAssert = true) => Assumes.Fail(message.UseCallbackOrDefault().Invoke(), innerException, showAssert);
public static FluentMessageCallback UseCallbackOrDefault(this FluentMessageCallback callback, string message = null) => callback ?? GetDefaultCallback(message);
/// <summary>
/// Throws an public exception if a <paramref name="condition"/> Evaluates to False.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="value"></param>
/// <param name="condition"></param>
/// <param name="message"></param>
/// <returns></returns>
/// <see cref="Assumes.True(bool,string)"/>
public static T AssumesTrue <T>(this T value, FluentConditionCallback <T> condition, FluentMessageCallback message = null)
{
Assumes.True(condition.Invoke(value), message.UseCallbackOrDefault().Invoke());
return(value);
}
/// <summary>
/// Throws an <see cref="ArgumentOutOfRangeException"/> if a <paramref name="condition"/>
/// Does Not Evaluate to True.
/// </summary>
/// <param name="condition"></param>
/// <param name="argumentName"></param>
/// <param name="message"></param>
/// <returns>The <paramref name="condition"/> after Range is Required.</returns>
public static bool RequiresRange(this bool condition, string argumentName, FluentMessageCallback message = null)
{
Requires.Range(condition, argumentName, message.UseCallbackOrDefault().Invoke());
return(condition);
}
