/// <summary> /// Check that the code does not throw an exception. /// </summary> /// <returns> /// A check link. /// </returns> /// <exception cref="FluentCheckException"> /// The code raised an exception. /// </exception> public ICheckLink <ILambdaCheck> DoesNotThrow() { var check = new FluentCodeCheck <RunTrace>(this.runTrace); check.DoesNotThrow(); return(new CheckLink <ILambdaCheck>(this)); }
/// <summary> /// Checks that the code did throw an exception of any type. /// </summary> /// <returns> /// A check link. /// </returns> /// <exception cref="FluentCheckException"> /// The code did not raised an exception of any type. /// </exception> public ILambdaExceptionCheck <ILambdaCheck> ThrowsAny() { var check = new FluentCodeCheck <RunTrace>(this.runTrace); check.ThrowsAny(); return(new LambdaExceptionCheck <ILambdaCheck>(this.runTrace.RaisedException)); }
/// <summary> /// Checks that the execution time is below a specified threshold. /// </summary> /// <param name="threshold"> /// The threshold. /// </param> /// <param name="timeUnit"> /// The time unit of the given threshold. /// </param> /// <returns> /// A check link. /// </returns> /// <exception cref="FluentCheckException"> /// Execution was strictly above limit. /// </exception> public ICheckLink <ILambdaCheck> LastsLessThan(double threshold, TimeUnit timeUnit) { var check = new FluentCodeCheck <RunTrace>(this.runTrace); check.LastsLessThan(threshold, timeUnit); return(new CheckLink <ILambdaCheck>(this)); }
/// <summary> /// Returns a <see cref="ICheck{T}" /> instance that will provide check methods to be executed on a given async function (returning Task{TResult}). /// </summary> /// <typeparam name="TResult">The type of the result for this asynchronous function.</typeparam> /// <param name="awaitableFunction">The asynchronous function to be tested.</param> /// <returns> /// A <see cref="ICheck{RunTrace}" /> instance to use in order to assert things on the given value. /// </returns> /// <remarks> /// Every method of the returned <see cref="ICheck{T}" /> instance will throw a <see cref="FluentCheckException" /> when failing. /// </remarks> public static ICodeCheck <RunTraceResult <TResult> > ThatAsyncCode <TResult>(Func <Task <TResult> > awaitableFunction) { return(new FluentCodeCheck <RunTraceResult <TResult> >(FluentCodeCheck <RunTraceResult <Task <TResult> > > .GetAsyncTrace(awaitableFunction))); }
/// <summary> /// Returns a <see cref="ICheck{T}" /> instance that will provide check methods to be executed on a given async code (returning Task). /// </summary> /// <param name="awaitableMethod">The async code to be tested.</param> /// <returns> /// A <see cref="ICheck{RunTrace}" /> instance to use in order to assert things on the given value. /// </returns> /// <remarks> /// Every method of the returned <see cref="ICheck{T}" /> instance will throw a <see cref="FluentCheckException" /> when failing. /// </remarks> public static ICodeCheck <RunTrace> ThatAsyncCode(Func <Task> awaitableMethod) { return(new FluentCodeCheck <RunTrace>(FluentCodeCheck <RunTraceResult <Func <Task> > > .GetAsyncTrace(awaitableMethod))); }
/// <summary> /// Returns a <see cref="ICheck{T}" /> instance that will provide check methods to be executed on a lambda. /// </summary> /// <typeparam name="TU">Result type of the function.</typeparam> /// <param name="value">The code to be tested.</param> /// <returns> /// A <see cref="ICheck{RunTrace}" /> instance to use in order to assert things on the lambda. /// </returns> /// <remarks> /// Every method of the returned <see cref="ICheck{T}" /> instance will throw a <see cref="FluentCheckException" /> when failing. /// </remarks> public static ICodeCheck <RunTraceResult <TU> > ThatCode <TU>(Func <TU> value) { return(new FluentCodeCheck <RunTraceResult <TU> >(FluentCodeCheck <RunTraceResult <TU> > .GetTrace(value))); }
/// <summary> /// Returns a <see cref="ICheck{T}" /> instance that will provide check methods to be executed on a given value. /// </summary> /// <param name="value">The code to be tested.</param> /// <returns> /// A <see cref="ICheck{RunTrace}" /> instance to use in order to assert things on the given value. /// </returns> /// <remarks> /// Every method of the returned <see cref="ICheck{T}" /> instance will throw a <see cref="FluentCheckException" /> when failing. /// </remarks> public static ICodeCheck <RunTrace> ThatCode(Action value) { return(new FluentCodeCheck <RunTrace>(FluentCodeCheck <RunTraceResult <Action> > .GetTrace(value))); }