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));
}
