public override bool TryCreateDummyValue(DummyCreationSession session, Type typeOfDummy, out object result)
{
result = default(object);
if (typeof(Delegate).IsAssignableFrom(typeOfDummy) || typeOfDummy.GetTypeInfo().IsAbstract)
{
return(false);
}
if (this.cachedConstructors.TryGetValue(typeOfDummy, out ConstructorInfo cachedConstructor))
{
if (this.TryCreateDummyValueUsingConstructor(session, cachedConstructor, out result))
{
return(true);
}
}
foreach (var constructor in GetConstructorsInOrder(typeOfDummy))
{
if (this.TryCreateDummyValueUsingConstructor(session, constructor, out result))
{
this.cachedConstructors[typeOfDummy] = constructor;
return(true);
}
}
return(false);
}
private static IEnumerable<ResolvedArgument> ResolveArguments(
IEnumerable<Type> parameterTypes,
DummyCreationSession session,
IDummyValueResolver resolver)
{
var resolvedArguments = new List<ResolvedArgument>();
foreach (var parameterType in parameterTypes)
{
var resolvedArgument = new ResolvedArgument { ArgumentType = parameterType };
try
{
var creationResult = resolver.TryResolveDummyValue(session, parameterType);
resolvedArgument.WasResolved = creationResult.WasSuccessful;
if (creationResult.WasSuccessful)
{
resolvedArgument.ResolvedValue = creationResult.Result;
}
}
catch
{
resolvedArgument.WasResolved = false;
}
resolvedArguments.Add(resolvedArgument);
}
return resolvedArguments;
}
public ResolvedConstructor(
IEnumerable<Type> parameterTypes,
DummyCreationSession session,
IDummyValueResolver resolver)
{
this.Arguments = ResolveArguments(parameterTypes, session, resolver);
}
public object CreateFake(Type typeOfFake, IProxyOptions proxyOptions, DummyCreationSession session, IDummyValueResolver resolver, bool throwOnFailure)
{
if (!this.proxyGenerator.CanGenerateProxy(typeOfFake, out string reasonCannotGenerate))
{
if (throwOnFailure)
{
this.thrower.ThrowFailedToGenerateProxyWithoutTryingConstructors(typeOfFake, reasonCannotGenerate);
}
return(null);
}
ProxyGeneratorResult result;
if (proxyOptions.ArgumentsForConstructor != null)
{
result = this.GenerateProxy(typeOfFake, proxyOptions, proxyOptions.ArgumentsForConstructor);
if (!result.ProxyWasSuccessfullyGenerated)
{
if (throwOnFailure)
{
this.thrower.ThrowFailedToGenerateProxyWithArgumentsForConstructor(typeOfFake, result.ReasonForFailure);
}
return(null);
}
return(result.GeneratedProxy);
}
result = this.TryCreateFakeWithDummyArgumentsForConstructor(typeOfFake, proxyOptions, session, resolver, throwOnFailure);
return(result?.GeneratedProxy);
}
public override bool TryCreateDummyValue(DummyCreationSession session, Type typeOfDummy, out object result)
{
result = default(object);
if (typeof(Delegate).IsAssignableFrom(typeOfDummy) || typeOfDummy.GetTypeInfo().IsAbstract)
{
return(false);
}
foreach (var constructor in GetConstructorsInOrder(typeOfDummy))
{
var parameterTypes = constructor.GetParameters().Select(x => x.ParameterType);
try
{
var resolvedArguments = this.ResolveAllTypes(session, parameterTypes);
if (resolvedArguments != null)
{
result = Activator.CreateInstance(typeOfDummy, resolvedArguments.ToArray());
return(true);
}
}
catch
{
}
}
return(false);
}
public override bool TryCreateDummyValue(DummyCreationSession session, Type typeOfDummy, out object result)
{
result = default(object);
if (typeOfDummy == typeof(Task))
{
result = TaskHelper.FromResult(default(object));
return(true);
}
if (typeOfDummy.GetTypeInfo().IsGenericType&& typeOfDummy.GetGenericTypeDefinition() == typeof(Task <>))
{
var typeOfTaskResult = typeOfDummy.GetGenericArguments()[0];
object taskResult;
if (!this.Resolver.TryResolveDummyValue(session, typeOfTaskResult, out taskResult))
{
taskResult = typeOfTaskResult.GetDefaultValue();
}
var method = GenericFromResultMethodDefinition.MakeGenericMethod(typeOfTaskResult);
result = method.Invoke(null, new[] { taskResult });
return(true);
}
return(false);
}
public override CreationResult TryCreateDummyValue(DummyCreationSession session, Type typeOfDummy)
{
var success = this.DummyFactory.TryCreateDummyObject(typeOfDummy, out object result);
return(success
? CreationResult.SuccessfullyCreated(result)
: CreationResult.FailedToCreateDummy(typeOfDummy, "No Dummy Factory produced a result."));
}
public override CreationResult TryCreateDummyValue(DummyCreationSession session, Type typeOfDummy)
{
if (typeof(Delegate).IsAssignableFrom(typeOfDummy))
{
return(CreationResult.FailedToCreateDummy(typeOfDummy, "It is a Delegate."));
}
if (typeOfDummy.GetTypeInfo().IsAbstract)
{
return(CreationResult.FailedToCreateDummy(typeOfDummy, "It is abstract."));
}
// Save the constructors as we try them. Avoids eager evaluation and double evaluation
// of constructors enumerable.
var consideredConstructors = new List <ResolvedConstructor>();
if (this.cachedConstructors.TryGetValue(typeOfDummy, out ConstructorInfo cachedConstructor))
{
var resolvedConstructor = new ResolvedConstructor(
cachedConstructor.GetParameters().Select(pi => pi.ParameterType),
session,
this.Resolver);
if (resolvedConstructor.WasSuccessfullyResolved)
{
if (TryCreateDummyValueUsingConstructor(cachedConstructor, resolvedConstructor, out object result))
{
return(CreationResult.SuccessfullyCreated(result));
}
consideredConstructors.Add(resolvedConstructor);
}
}
else
{
foreach (var constructor in GetConstructorsInOrder(typeOfDummy))
{
var resolvedConstructor = new ResolvedConstructor(
constructor.GetParameters().Select(pi => pi.ParameterType),
session,
this.Resolver);
if (resolvedConstructor.WasSuccessfullyResolved && TryCreateDummyValueUsingConstructor(constructor, resolvedConstructor, out object result))
{
this.cachedConstructors[typeOfDummy] = constructor;
return(CreationResult.SuccessfullyCreated(result));
}
consideredConstructors.Add(resolvedConstructor);
}
}
if (consideredConstructors.Any())
{
return(CreationResult.FailedToCreateDummy(typeOfDummy, consideredConstructors));
}
return(CreationResult.FailedToCreateDummy(typeOfDummy, "It has no public constructors."));
}
public override CreationResult TryCreateDummyValue(DummyCreationSession session, Type typeOfDummy)
{
if (typeOfDummy.GetTypeInfo().IsValueType&& typeOfDummy != typeof(void))
{
return(CreationResult.SuccessfullyCreated(Activator.CreateInstance(typeOfDummy)));
}
return(CreationResult.FailedToCreateDummy(typeOfDummy, "It is not a value type."));
}
public override bool TryCreateDummyValue(DummyCreationSession session, Type typeOfDummy, out object result)
{
result = default(object);
if (typeOfDummy.GetTypeInfo().IsValueType&& typeOfDummy != typeof(void))
{
result = Activator.CreateInstance(typeOfDummy);
return(true);
}
return(false);
}
public object CreateFake(Type typeOfFake, IProxyOptions proxyOptions, DummyCreationSession session, IDummyValueResolver resolver, bool throwOnFailure)
{
var result = this.GenerateProxy(typeOfFake, proxyOptions, proxyOptions.ArgumentsForConstructor);
if (throwOnFailure)
{
this.AssertThatProxyWasGeneratedWhenArgumentsForConstructorAreSpecified(typeOfFake, result, proxyOptions);
}
if (!result.ProxyWasSuccessfullyGenerated && proxyOptions.ArgumentsForConstructor == null)
{
result = this.TryCreateFakeWithDummyArgumentsForConstructor(typeOfFake, proxyOptions, session, resolver, result.ReasonForFailure, throwOnFailure);
}
return(result != null ? result.GeneratedProxy : null);
}
public bool TryResolveDummyValue(DummyCreationSession session, Type typeOfDummy, out object result)
{
result = default(object);
if (!session.TryBeginToResolveType(typeOfDummy))
{
return(false);
}
if (this.TryResolveDummyValueWithAllAvailableStrategies(session, typeOfDummy, out result))
{
session.OnSuccessfulResolve(typeOfDummy);
return(true);
}
return(false);
}
public CreationResult TryResolveDummyValue(DummyCreationSession session, Type typeOfDummy)
{
if (!session.TryBeginToResolveType(typeOfDummy))
{
return(CreationResult.FailedToCreateDummy(typeOfDummy, "Recursive dependency detected. Already resolving " + typeOfDummy + '.'));
}
var creationResult = this.TryResolveDummyValueWithAllAvailableStrategies(session, typeOfDummy);
if (creationResult.WasSuccessful)
{
session.OnSuccessfulResolve(typeOfDummy);
}
return(creationResult);
}
private IEnumerable <object> ResolveAllTypes(DummyCreationSession session, IEnumerable <Type> types)
{
var result = new List <object>();
foreach (var type in types)
{
object resolvedType;
if (!this.Resolver.TryResolveDummyValue(session, type, out resolvedType))
{
return(null);
}
result.Add(resolvedType);
}
return(result);
}
public override CreationResult TryCreateDummyValue(DummyCreationSession session, Type typeOfDummy)
{
if (typeOfDummy.GetTypeInfo().IsGenericType&& typeOfDummy.GetGenericTypeDefinition() == typeof(Lazy <>))
{
var typeOfLazyResult = typeOfDummy.GetGenericArguments()[0];
var creationResult = this.Resolver.TryResolveDummyValue(session, typeOfLazyResult);
object lazyResult = creationResult.WasSuccessful
? creationResult.Result
: typeOfLazyResult.GetDefaultValue();
var funcType = typeof(Func <>).MakeGenericType(typeOfLazyResult);
var method = CreateGenericFromResultMethodDefinition().MakeGenericMethod(typeOfLazyResult);
var func = method.Invoke(null, new[] { lazyResult });
var dummy = typeOfDummy.GetConstructor(new[] { funcType, typeof(bool) }).Invoke(new[] { func, true });
return(CreationResult.SuccessfullyCreated(dummy));
}
return(CreationResult.FailedToCreateDummy(typeOfDummy, "It is not a Lazy."));
}
private bool TryCreateDummyValueUsingConstructor(DummyCreationSession session, ConstructorInfo constructor, out object result)
{
var parameterTypes = constructor.GetParameters().Select(x => x.ParameterType);
try
{
var resolvedArguments = this.ResolveAllTypes(session, parameterTypes);
if (resolvedArguments != null)
{
result = constructor.Invoke(resolvedArguments.ToArray());
return(true);
}
}
catch
{
}
result = default(object);
return(false);
}
public override CreationResult TryCreateDummyValue(DummyCreationSession session, Type typeOfDummy)
{
if (typeOfDummy == typeof(Task))
{
return(CreationResult.SuccessfullyCreated(TaskHelper.FromResult(default(object))));
}
if (typeOfDummy.GetTypeInfo().IsGenericType&& typeOfDummy.GetGenericTypeDefinition() == typeof(Task <>))
{
var typeOfTaskResult = typeOfDummy.GetGenericArguments()[0];
var creationResult = this.Resolver.TryResolveDummyValue(session, typeOfTaskResult);
object taskResult = creationResult.WasSuccessful
? creationResult.Result
: typeOfTaskResult.GetDefaultValue();
var method = GenericFromResultMethodDefinition.MakeGenericMethod(typeOfTaskResult);
return(CreationResult.SuccessfullyCreated(method.Invoke(null, new[] { taskResult })));
}
return(CreationResult.FailedToCreateDummy(typeOfDummy, "It is not a Task."));
}
private bool TryResolveDummyValueWithAllAvailableStrategies(DummyCreationSession session, Type typeOfDummy, out object result)
{
result = default(object);
ResolveStrategy cachedStrategy;
if (this.strategyCache.TryGetValue(typeOfDummy, out cachedStrategy))
{
return(cachedStrategy.TryCreateDummyValue(session, typeOfDummy, out result));
}
foreach (var strategy in this.strategies)
{
if (strategy.TryCreateDummyValue(session, typeOfDummy, out result))
{
this.strategyCache.TryAdd(typeOfDummy, strategy);
return(true);
}
}
this.strategyCache.TryAdd(typeOfDummy, new UnableToResolveStrategy());
return(false);
}
public override bool TryCreateDummyValue(DummyCreationSession session, Type typeOfDummy, out object result)
{
result = default(object);
if (typeOfDummy.GetTypeInfo().IsGenericType&& typeOfDummy.GetGenericTypeDefinition() == typeof(Lazy <>))
{
var typeOfLazyResult = typeOfDummy.GetGenericArguments()[0];
object lazyResult;
if (!this.Resolver.TryResolveDummyValue(session, typeOfLazyResult, out lazyResult))
{
lazyResult = typeOfLazyResult.GetDefaultValue();
}
var funcType = typeof(Func <>).MakeGenericType(typeOfLazyResult);
var method = CreateGenericFromResultMethodDefinition().MakeGenericMethod(typeOfLazyResult);
var func = method.Invoke(null, new[] { lazyResult });
result = typeOfDummy.GetConstructor(new[] { funcType, typeof(bool) }).Invoke(new[] { func, true });
return(true);
}
return(false);
}
private CreationResult TryResolveDummyValueWithAllAvailableStrategies(DummyCreationSession session, Type typeOfDummy)
{
if (this.strategyCache.TryGetValue(typeOfDummy, out ResolveStrategy cachedStrategy))
{
return(cachedStrategy.TryCreateDummyValue(session, typeOfDummy));
}
CreationResult creationResult = null;
foreach (var strategy in this.strategies)
{
var thisCreationResult = strategy.TryCreateDummyValue(session, typeOfDummy);
if (thisCreationResult.WasSuccessful)
{
this.strategyCache.TryAdd(typeOfDummy, strategy);
return(thisCreationResult);
}
creationResult = CreationResult.MergeIntoDummyResult(creationResult, thisCreationResult);
}
this.strategyCache.TryAdd(typeOfDummy, new UnableToResolveStrategy(creationResult));
return(creationResult);
}
public CreationResult CreateFake(Type typeOfFake, IProxyOptions proxyOptions, DummyCreationSession session, IDummyValueResolver resolver)
{
if (!CastleDynamicProxyGenerator.CanGenerateProxy(typeOfFake, out string reasonCannotGenerate))
{
return(CreationResult.FailedToCreateFake(typeOfFake, reasonCannotGenerate));
}
if (proxyOptions.ArgumentsForConstructor != null)
{
var proxyGeneratorResult = this.GenerateProxy(typeOfFake, proxyOptions, proxyOptions.ArgumentsForConstructor);
return(proxyGeneratorResult.ProxyWasSuccessfullyGenerated
? CreationResult.SuccessfullyCreated(proxyGeneratorResult.GeneratedProxy)
: CreationResult.FailedToCreateFake(typeOfFake, proxyGeneratorResult.ReasonForFailure));
}
return(this.TryCreateFakeWithDummyArgumentsForConstructor(typeOfFake, proxyOptions, session, resolver));
}
public override bool TryCreateDummyValue(DummyCreationSession session, Type typeOfDummy, out object result)
{
result = default(object);
return(false);
}
public abstract bool TryCreateDummyValue(DummyCreationSession session, Type typeOfDummy, out object result);
public override bool TryCreateDummyValue(DummyCreationSession session, Type typeOfDummy, out object result)
{
return(this.DummyFactory.TryCreateDummyObject(typeOfDummy, out result));
}
private ProxyGeneratorResult TryCreateFakeWithDummyArgumentsForConstructor(Type typeOfFake, IProxyOptions proxyOptions, DummyCreationSession session, IDummyValueResolver resolver, string failReasonForDefaultConstructor, bool throwOnFailure)
{
var constructors = ResolveConstructors(typeOfFake, session, resolver);
// Save the constructors as we try them. Avoids eager evaluation and double evaluation
// of constructors enumerable.
var consideredConstructors = new List <ResolvedConstructor>();
foreach (var constructor in constructors)
{
if (constructor.WasSuccessfullyResolved)
{
var result = this.GenerateProxy(typeOfFake, proxyOptions, constructor.Arguments.Select(x => x.ResolvedValue));
if (result.ProxyWasSuccessfullyGenerated)
{
return(result);
}
constructor.ReasonForFailure = result.ReasonForFailure;
}
consideredConstructors.Add(constructor);
}
if (throwOnFailure)
{
this.thrower.ThrowFailedToGenerateProxyWithResolvedConstructors(typeOfFake, failReasonForDefaultConstructor, consideredConstructors);
}
return(null);
}
private static ResolvedConstructor ResolveConstructorArguments(Type[] parameterTypes, DummyCreationSession session, IDummyValueResolver resolver)
{
if (parameterTypes == null)
{
return(new ResolvedConstructor());
}
var resolvedArguments = new List <ResolvedArgument>();
foreach (var parameterType in parameterTypes)
{
bool wasResolved;
object result = null;
try
{
wasResolved = resolver.TryResolveDummyValue(session, parameterType, out result);
}
catch
{
wasResolved = false;
}
var resolvedArgument = new ResolvedArgument
{
WasResolved = wasResolved,
ResolvedValue = result,
ArgumentType = parameterType
};
resolvedArguments.Add(resolvedArgument);
}
return(new ResolvedConstructor
{
Arguments = resolvedArguments.ToArray()
});
}
private CreationResult TryCreateFakeWithDummyArgumentsForConstructor(Type typeOfFake, IProxyOptions proxyOptions, DummyCreationSession session, IDummyValueResolver resolver)
{
// Save the constructors as we try them. Avoids eager evaluation and double evaluation
// of constructors enumerable.
var consideredConstructors = new List <ResolvedConstructor>();
if (this.parameterTypesCache.TryGetValue(typeOfFake, out Type[] cachedParameterTypes))
public override bool TryCreateDummyValue(DummyCreationSession session, Type typeOfDummy, out object result)
{
return(this.FakeCreator.TryCreateFakeObject(session, typeOfDummy, this.Resolver, out result));
}
public CreationResult CreateFake(Type typeOfFake, IProxyOptions proxyOptions, DummyCreationSession session, IDummyValueResolver resolver)
{
if (proxyOptions.Attributes.Any())
{
return(CreationResult.FailedToCreateFake(typeOfFake, "Faked delegates cannot have custom attributes applied to them."));
}
if (proxyOptions.ArgumentsForConstructor != null && proxyOptions.ArgumentsForConstructor.Any())
{
return(CreationResult.FailedToCreateFake(typeOfFake, "Faked delegates cannot be made using explicit constructor arguments."));
}
if (proxyOptions.AdditionalInterfacesToImplement.Any())
{
return(CreationResult.FailedToCreateFake(typeOfFake, "Faked delegates cannot be made to implement additional interfaces."));
}
var fakeCallProcessorProvider = this.fakeCallProcessorProviderFactory(typeOfFake, proxyOptions);
var proxyGeneratorResult = DelegateProxyGenerator.GenerateProxy(typeOfFake, fakeCallProcessorProvider);
return(proxyGeneratorResult.ProxyWasSuccessfullyGenerated
? CreationResult.SuccessfullyCreated(proxyGeneratorResult.GeneratedProxy)
: CreationResult.FailedToCreateFake(typeOfFake, proxyGeneratorResult.ReasonForFailure));
}
public CreationResult CreateFake(Type typeOfFake, IProxyOptions proxyOptions, DummyCreationSession session, IDummyValueResolver resolver) => this.strategies.First(s => s.IsResponsibleForCreating(typeOfFake)).CreateFake(typeOfFake, proxyOptions, session, resolver);
