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