private static Action VerifyValueNotDisposedDelegation <T>(T value, FluentConditionCallback <T> condition, out string renderedMessage, string expectedMessage = null) where T : IDisposable { expectedMessage = (expectedMessage ?? CannotAccessDisposedObject).AssertNotNull().AssertNotEmpty(); renderedMessage = RenderDisposedMessageWithObjectType <T>(expectedMessage); return(() => value.VerifyValueNotDisposed(condition, () => expectedMessage)); }
/// <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); }
private static Action VerifyRequirementExpectingException <T>(T value, FluentConditionCallback <T> condition , string argumentName, out string renderedMessage, string expectedMessage = null) { expectedMessage = (expectedMessage ?? DefaultMessage).AssertNotNull().AssertNotEmpty(); renderedMessage = RenderArgumentMessage(expectedMessage, argumentName.AssertNotNull().AssertNotEmpty()); return(() => VerifyRequirement(value, condition, argumentName, expectedMessage)); }
private static Exception VerifyExtension <T>(T _, FluentConditionCallback <T> condition, string expectedMessage = null) { expectedMessage = (expectedMessage ?? DefaultMessage).AssertNotNull().AssertNotEmpty(); return(_.VerifyFailOperation(condition, () => expectedMessage)); }
private static Action VerifyExtensionDelegation(object _, FluentConditionCallback <object> condition, string expectedMessage = null) { expectedMessage = (expectedMessage ?? DefaultMessage).AssertNotNull().AssertNotEmpty(); return(() => _.VerifyFailOperation(condition, () => expectedMessage)); }
// TODO: TBD: we might redress the Assumes tests with an approach something like this... private static T VerifyRequirement <T>(T value, FluentConditionCallback <T> condition, string argumentName, string expectedMessage = null) => value.RequiresArgument(condition.AssertNotNull(), argumentName.AssertNotNull().AssertNotEmpty() , () => (expectedMessage ?? DefaultMessage).AssertNotNull().AssertNotEmpty());
/// <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); }
private static T VerifyRequirement <T>(T value, FluentConditionCallback <T> condition, string expectedMessage = null) { expectedMessage = (expectedMessage ?? DefaultMessage).AssertNotNull().AssertNotEmpty(); return(value.RequiresValidState(condition, () => expectedMessage)); }
private static object VerifyValueNotDisposed(object value, FluentConditionCallback <object> condition, string expectedMessage = null) => value.VerifyValueNotDisposed(condition, () => expectedMessage);
/// <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());
private static object VerifyValueNotDisposedConditionOnly(object value, string objectName, FluentConditionCallback <object> condition) => value.VerifyValueNotDisposedConditionOnly(objectName, condition);
private static Action VerifyValueNotDisposedDelegation(object value, FluentConditionCallback <object> condition, out string renderedMessage, string expectedMessage = null) { expectedMessage = (expectedMessage ?? CannotAccessDisposedObject).AssertNotNull().AssertNotEmpty(); renderedMessage = RenderDisposedMessage(); return(() => value.VerifyValueNotDisposed(condition, () => expectedMessage)); }
private static Action VerifyValueNotDisposedConditionOnlyDelegation(object value, string objectName, FluentConditionCallback <object> condition, out string renderedMessage) { renderedMessage = RenderDisposedMessage(objectName); return(() => value.VerifyValueNotDisposedConditionOnly(objectName, condition)); }
/// <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="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 <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> /// 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); }
private static Action VerifyRangeRequirement <T>(T value, FluentConditionCallback <T> condition, string argumentName, out string renderedMessage, string expectedMessage = null) { expectedMessage = (expectedMessage ?? DefaultMessage).AssertNotNull().AssertNotEmpty(); renderedMessage = RenderArgumentMessage(expectedMessage, argumentName); return(() => value.RequiresRange(condition, argumentName, () => expectedMessage)); }
/// <summary> /// Throws an <see cref="ObjectDisposedException"/> when <paramref name="condition"/> /// is False. /// </summary> /// <param name="value">The Disposed Value.</param> /// <param name="objectName">The ObjectName to use for the thrown exception.</param> /// <param name="condition">The condition which returns True to avoid <see cref="ObjectDisposedException"/>.</param> /// <returns>The <paramref name="value"/> after Not Disposed <paramref name="condition"/> is Verified.</returns> public static object VerifyValueNotDisposedConditionOnly(this object value, string objectName, FluentConditionCallback <object> condition) { Verify.NotDisposed(condition.Invoke(value), objectName); return(value); }
/// <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 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); }
private static T VerifyValueNotDisposed <T>(T value, FluentConditionCallback <T> condition) where T : IDisposable => value.VerifyValueNotDisposed(condition);
private static T VerifyRangeRequirement <T>(T _, FluentConditionCallback <T> condition, string argumentName) => _.RequiresRange(condition, argumentName);
private static T VerifyOperation <T>(T value, FluentConditionCallback <T> condition, string expectedMessage = null) { expectedMessage = (expectedMessage ?? DefaultMessage).AssertNotNull().AssertNotEmpty(); return(value.VerifyOperation(condition, () => expectedMessage)); }