public static void ReturnsNextFromSequence <T>(this IReturnValueConfiguration <Task <T> > configuration, params T[] values) { Guard.AgainstNull(configuration, nameof(configuration)); Guard.AgainstNull(values, nameof(values)); configuration.ReturnsNextFromQueue(new ConcurrentQueue <Task <T> >(values.Select(TaskHelper.FromResult))); }
private static void ReturnsNextFromQueue <T>(this IReturnValueConfiguration <T> configuration, ConcurrentQueue <T> queue) { configuration.ReturnsLazily(x => { queue.TryDequeue(out T returnValue); return(returnValue); }).NumberOfTimes(queue.Count); }
/// <summary> /// Configures the call to return the next value from the specified sequence each time it's called. /// After the sequence has been exhausted, the call will revert to the previously configured behavior. /// </summary> /// <typeparam name="T">The type of return value.</typeparam> /// <param name="configuration">The call configuration to extend.</param> /// <param name="values">The values to return in sequence.</param> public static void ReturnsNextFromSequence <T>(this IReturnValueConfiguration <T> configuration, params T[] values) { Guard.AgainstNull(configuration, "configuration"); var queue = new Queue <T>(values); configuration.ReturnsLazily(x => queue.Dequeue()).NumberOfTimes(queue.Count); }
ReturnsLazily <TReturnType, T1, T2, T3, T4>(this IReturnValueConfiguration <TReturnType> configuration, Func <T1, T2, T3, T4, TReturnType> valueProducer) { return(configuration.ReturnsLazily(call => { AssertThatSignaturesAreEqual(call.Method, valueProducer.Method, NameOfReturnsLazilyFeature); return valueProducer(call.GetArgument <T1>(0), call.GetArgument <T2>(1), call.GetArgument <T3>(2), call.GetArgument <T4>(3)); })); }
public static IAfterCallConfiguredConfiguration <IReturnValueConfiguration <ValueTask <T> > > ThrowsAsync <T, T1, T2>( this IReturnValueConfiguration <ValueTask <T> > configuration, Func <T1, T2, Exception> exceptionFactory) { Guard.AgainstNull(configuration, nameof(configuration)); Guard.AgainstNull(exceptionFactory, nameof(exceptionFactory)); return(configuration.ReturnsLazily((T1 arg1, T2 arg2) => new ValueTask <T>(TaskHelper.FromException <T>(exceptionFactory(arg1, arg2))))); }
public static IAfterCallConfiguredConfiguration <IReturnValueConfiguration <ValueTask <T> > > ThrowsAsync <T, T1, T2, T3, T4, T5, T6, T7, T8>( this IReturnValueConfiguration <ValueTask <T> > configuration, Func <T1, T2, T3, T4, T5, T6, T7, T8, Exception> exceptionFactory) { Guard.AgainstNull(configuration, nameof(configuration)); Guard.AgainstNull(exceptionFactory, nameof(exceptionFactory)); return(configuration.ReturnsLazily((T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8) => new ValueTask <T>(TaskHelper.FromException <T>(exceptionFactory(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8))))); }
public static IAfterCallConfiguredConfiguration <IReturnValueConfiguration <Task> > ThrowsAsync <T1>( this IReturnValueConfiguration <Task> configuration, Func <T1, Exception> exceptionFactory) { Guard.AgainstNull(configuration, nameof(configuration)); Guard.AgainstNull(exceptionFactory, nameof(exceptionFactory)); return(configuration.ReturnsLazily((T1 arg1) => TaskHelper.FromException(exceptionFactory(arg1)))); }
public static IAfterCallConfiguredConfiguration <IReturnValueConfiguration <Task> > ThrowsAsync( this IReturnValueConfiguration <Task> configuration, Exception exception) { Guard.AgainstNull(configuration, nameof(configuration)); Guard.AgainstNull(exception, nameof(exception)); return(configuration.ReturnsLazily(call => TaskHelper.FromException(exception))); }
public static IAfterCallConfiguredConfiguration <IReturnValueConfiguration <Task <T> > > ThrowsAsync <T>( this IReturnValueConfiguration <Task <T> > configuration, Func <IFakeObjectCall, Exception> exceptionFactory) { Guard.AgainstNull(configuration, nameof(configuration)); Guard.AgainstNull(exceptionFactory, nameof(exceptionFactory)); return(configuration.ReturnsLazily(call => TaskHelper.FromException <T>(exceptionFactory(call)))); }
public static IAfterCallConfiguredConfiguration <IReturnValueConfiguration <ValueTask> > ThrowsAsync( this IReturnValueConfiguration <ValueTask> configuration, Func <Exception> exceptionFactory) { Guard.AgainstNull(configuration, nameof(configuration)); Guard.AgainstNull(exceptionFactory, nameof(exceptionFactory)); return(configuration.ReturnsLazily(call => new ValueTask(TaskHelper.FromException(exceptionFactory())))); }
public void Calls_to_returns_fake_configuraion_for_the_faked_object_when_function_call_is_specified() { var fake = new Fake <IFoo>(); IReturnValueConfiguration <IFoo, int> returnValueConfiguration = fake.CallsTo(x => x.Baz()); var configuration = returnValueConfiguration as FakeConfiguration <IFoo> .ReturnValueConfiguration <int>; Assert.That(configuration.ParentConfiguration.Fake.Object, Is.SameAs(fake.FakedObject)); }
public static void ReturnsNextFromSequence <T>(this IReturnValueConfiguration <Task <T> > configuration, params T[] values) { Guard.AgainstNull(configuration, "configuration"); var taskValues = values.Select(value => TaskHelper.FromResult(value)); var queue = new Queue <Task <T> >(taskValues); configuration.ReturnsLazily(x => queue.Dequeue()).NumberOfTimes(queue.Count); }
public static IAfterCallConfiguredConfiguration <IReturnValueConfiguration <Task> > ThrowsAsync <T1, T2, T3, T4, T5, T6>( this IReturnValueConfiguration <Task> configuration, Func <T1, T2, T3, T4, T5, T6, Exception> exceptionFactory) { Guard.AgainstNull(configuration, nameof(configuration)); Guard.AgainstNull(exceptionFactory, nameof(exceptionFactory)); return (configuration.ReturnsLazily( (T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6) => TaskHelper.FromException(exceptionFactory(arg1, arg2, arg3, arg4, arg5, arg6)))); }
ReturnsLazily <TReturnType, T1, T2, T3, T4, T5, T6, T7, T8>(this IReturnValueConfiguration <TReturnType> configuration, Func <T1, T2, T3, T4, T5, T6, T7, T8, TReturnType> valueProducer) { Guard.AgainstNull(configuration, nameof(configuration)); return(configuration.ReturnsLazily(call => { ValueProducerSignatureHelper.AssertThatValueProducerSignatureSatisfiesCallSignature(call.Method, valueProducer.GetMethodInfo(), NameOfReturnsLazilyFeature); return valueProducer(call.GetArgument <T1>(0), call.GetArgument <T2>(1), call.GetArgument <T3>(2), call.GetArgument <T4>(3), call.GetArgument <T5>(4), call.GetArgument <T6>(5), call.GetArgument <T7>(6), call.GetArgument <T8>(7)); })); }
ReturnsLazily <TReturnType, T1, T2, T3, T4>(this IReturnValueConfiguration <Task <TReturnType> > configuration, Func <T1, T2, T3, T4, TReturnType> valueProducer) { Guard.AgainstNull(configuration, "configuration"); return(configuration.ReturnsLazily(call => { ValueProducerSignatureHelper.AssertThatValueProducerSignatureSatisfiesCallSignature(call.Method, valueProducer.Method, NameOfReturnsLazilyFeature); return TaskHelper.FromResult(valueProducer(call.GetArgument <T1>(0), call.GetArgument <T2>(1), call.GetArgument <T3>(2), call.GetArgument <T4>(3))); })); }
ReturnsLazily <TReturnType, T1>(this IReturnValueConfiguration <TReturnType> configuration, Func <T1, TReturnType> valueProducer) { Guard.AgainstNull(configuration, "configuration"); return(configuration.ReturnsLazily(call => { ValueProducerSignatureHelper.AssertThatValueProducerSignatureSatisfiesCallSignature(call.Method, valueProducer.Method, NameOfReturnsLazilyFeature); return valueProducer(call.GetArgument <T1>(0)); })); }
ReturnsLazily <TReturnType, T1>(this IReturnValueConfiguration <Task <TReturnType> > configuration, Func <T1, TReturnType> valueProducer) { Guard.AgainstNull(configuration, nameof(configuration)); Guard.AgainstNull(valueProducer, nameof(valueProducer)); return(configuration.ReturnsLazily(call => { ValueProducerSignatureHelper.AssertThatValueProducerSignatureSatisfiesCallSignature(call.Method, valueProducer.GetMethodInfo(), NameOfReturnsLazilyFeature); return TaskHelper.FromResult(valueProducer(call.GetArgument <T1>(0))); })); }
public static IAfterCallSpecifiedWithOutAndRefParametersConfiguration ReturnsLazily <T>(this IReturnValueConfiguration <Task <T> > configuration, Func <T> valueProducer) { Guard.AgainstNull(configuration, "configuration"); Guard.AgainstNull(valueProducer, "valueProducer"); return(configuration.ReturnsLazily(x => TaskHelper.FromResult(valueProducer()))); }
public static IAfterCallSpecifiedWithOutAndRefParametersConfiguration Returns <T>(this IReturnValueConfiguration <Task <T> > configuration, T value) { Guard.AgainstNull(configuration, "configuration"); return(configuration.ReturnsLazily(() => value)); }
/// <summary> /// Configures the specified call to do nothing when called. /// </summary> /// <param name="configuration">The call configuration to extend.</param> /// <returns>A configuration object.</returns> public static IAfterCallConfiguredConfiguration <IReturnValueConfiguration <Task> > DoesNothing(this IReturnValueConfiguration <Task> configuration) { Guard.AgainstNull(configuration, nameof(configuration)); return(configuration.Returns(TaskHelper.CompletedTask)); }
/// <summary> /// Specifies that the configured call/calls should return null when called. /// </summary> /// <typeparam name="TFake">The type of the fake.</typeparam> /// <typeparam name="TMember">The type of the faked member.</typeparam> /// <param name="configuration">The configuration to apply to.</param> /// <returns>A configuration object.</returns> public static IAfterCallSpecifiedConfiguration ReturnsNull <TMember>(this IReturnValueConfiguration <TMember> configuration) where TMember : class { Guard.IsNotNull(configuration, "configuration"); return(configuration.Returns((TMember)null)); }
public static IAfterCallConfiguredWithOutAndRefParametersConfiguration <IReturnValueConfiguration <T> > ReturnsLazily <T>(this IReturnValueConfiguration <T> configuration, Func <T> valueProducer) { Guard.AgainstNull(configuration, nameof(configuration)); Guard.AgainstNull(valueProducer, nameof(valueProducer)); return(configuration.ReturnsLazily(x => valueProducer())); }
public static IAfterCallConfiguredWithOutAndRefParametersConfiguration <IReturnValueConfiguration <Task <T> > > Returns <T>(this IReturnValueConfiguration <Task <T> > configuration, T value) { Guard.AgainstNull(configuration, nameof(configuration)); return(configuration.ReturnsLazily(() => value)); }
/// <summary> /// Configures the call to return the next value from the specified sequence each time it's called. Null will /// be returned when all the values in the sequence has been returned. /// </summary> /// <typeparam name="T">The type of return value.</typeparam> /// <param name="configuration">The call configuration to extend.</param> /// <param name="values">The values to return in sequence.</param> /// <returns>A configuration object.</returns> public static IAfterCallSpecifiedWithOutAndRefParametersConfiguration ReturnsNextFromSequence <T>(this IReturnValueConfiguration <T> configuration, params T[] values) { var enumerator = values.Cast <T>().GetEnumerator(); Func <T> factory = () => { if (!enumerator.MoveNext()) { return(default(T)); } return(enumerator.Current); }; return(configuration.Returns(factory)); }