public ResolvedConstructor( IEnumerable <Type> parameterTypes, IDummyValueResolver resolver, LoopDetectingResolutionContext resolutionContext) { this.Arguments = ResolveArguments(parameterTypes, resolver, resolutionContext); }
public ResolvedConstructor( IEnumerable<Type> parameterTypes, DummyCreationSession session, IDummyValueResolver resolver) { this.Arguments = ResolveArguments(parameterTypes, session, resolver); }
public CreationResult CreateFake( Type typeOfFake, IProxyOptions proxyOptions, IDummyValueResolver resolver, LoopDetectingResolutionContext resolutionContext) { if (!CastleDynamicProxyGenerator.CanGenerateProxy(typeOfFake, out string?reasonCannotGenerate)) { return(CreationResult.FailedToCreateFake(typeOfFake, reasonCannotGenerate)); } if (proxyOptions.ArgumentsForConstructor is not 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, resolver, resolutionContext)); }
private static IEnumerable <ResolvedArgument> ResolveArguments( IEnumerable <Type> parameterTypes, IDummyValueResolver resolver, LoopDetectingResolutionContext resolutionContext) { var resolvedArguments = new List <ResolvedArgument>(); foreach (var parameterType in parameterTypes) { var resolvedArgument = new ResolvedArgument(parameterType); try { var creationResult = resolver.TryResolveDummyValue(parameterType, resolutionContext); resolvedArgument.WasResolved = creationResult.WasSuccessful; if (creationResult.WasSuccessful) { resolvedArgument.ResolvedValue = creationResult.Result; } } catch { resolvedArgument.WasResolved = false; } resolvedArguments.Add(resolvedArgument); } return(resolvedArguments); }
private static void StubResolverToFailForType <T>(IDummyValueResolver resolver) { object outResult; A.CallTo(() => resolver.TryResolveDummyValue(A <DummyCreationSession> ._, typeof(T), out outResult)) .Returns(false); }
public override CreationResult TryCreateDummyValue( Type typeOfDummy, IDummyValueResolver resolver, LoopDetectingResolutionContext resolutionContext) { return(this.creationResult); }
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; }
private static Lazy <T> CreateLazyDummy <T>(IDummyValueResolver resolver) { return(new Lazy <T>(() => { var creationResult = resolver.TryResolveDummyValue(typeof(T), new LoopDetectingResolutionContext()); return creationResult.WasSuccessful ? (T)creationResult.Result ! : default !;
private static void StubResolverWithDummyValue <T>(IDummyValueResolver resolver, T dummyValue) { object outResult; A.CallTo(() => resolver.TryResolveDummyValue(A <DummyCreationSession> ._, typeof(T), out outResult)) .Returns(true) .AssignsOutAndRefParameters(dummyValue); }
public override CreationResult TryCreateDummyValue(Type typeOfDummy, IDummyValueResolver resolver) { 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(Type typeOfDummy, IDummyValueResolver resolver) { 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 CreationResult TryCreateDummyValue(Type typeOfDummy, IDummyValueResolver resolver) { 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), 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), 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.")); }
private CreationResult TryCreateFakeWithDummyArgumentsForConstructor( Type typeOfFake, IProxyOptions proxyOptions, IDummyValueResolver resolver, LoopDetectingResolutionContext resolutionContext) { // 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 CreationResult TryCreateDummyValue( Type typeOfDummy, IDummyValueResolver resolver, LoopDetectingResolutionContext resolutionContext) { return(this.FakeCreator.CreateFakeWithoutLoopDetection( typeOfDummy, new ProxyOptions(), resolver, resolutionContext)); }
public override CreationResult TryCreateDummyValue( Type typeOfDummy, IDummyValueResolver resolver, LoopDetectingResolutionContext resolutionContext) { var proxyOptions = this.ProxyOptionsFactory.BuildProxyOptions(typeOfDummy, null); return(this.FakeCreator.CreateFakeWithoutLoopDetection( typeOfDummy, proxyOptions, resolver, resolutionContext)); }
public CreationResult CreateFakeWithoutLoopDetection( Type typeOfFake, IProxyOptions proxyOptions, IDummyValueResolver resolver, LoopDetectingResolutionContext resolutionContext) { if (typeOfFake.IsInterface) { return(this.defaultCreationStrategy.CreateFakeInterface(typeOfFake, proxyOptions)); } return(DelegateCreationStrategy.IsResponsibleForCreating(typeOfFake) ? this.delegateCreationStrategy.CreateFake(typeOfFake, proxyOptions) : this.defaultCreationStrategy.CreateFake(typeOfFake, proxyOptions, resolver, resolutionContext)); }
public override CreationResult TryCreateDummyValue( Type typeOfDummy, IDummyValueResolver resolver, LoopDetectingResolutionContext resolutionContext) { if (typeOfDummy.GetTypeInfo().IsGenericType&& typeOfDummy.GetGenericTypeDefinition() == typeof(Lazy <>)) { var typeOfLazyResult = typeOfDummy.GetGenericArguments()[0]; var method = CreateLazyDummyGenericDefinition.MakeGenericMethod(typeOfLazyResult); var dummy = method.Invoke(null, new object[] { resolver }); return(CreationResult.SuccessfullyCreated(dummy)); } return(CreationResult.FailedToCreateDummy(typeOfDummy, "It is not a Lazy.")); }
public override CreationResult TryCreateDummyValue( Type typeOfDummy, IDummyValueResolver resolver, LoopDetectingResolutionContext resolutionContext) { if (typeOfDummy == typeof(Task)) { return(CreationResult.SuccessfullyCreated(TaskHelper.CompletedTask)); } if (typeOfDummy.IsGenericType && typeOfDummy.GetGenericTypeDefinition() == typeof(Task <>)) { var typeOfTaskResult = typeOfDummy.GetGenericArguments()[0]; var creationResult = resolver.TryResolveDummyValue(typeOfTaskResult, resolutionContext); object?taskResult = creationResult.WasSuccessful ? creationResult.Result : typeOfTaskResult.GetDefaultValue(); var method = GenericFromResultMethodDefinition.MakeGenericMethod(typeOfTaskResult); return(CreationResult.SuccessfullyCreated(method.Invoke(null, new[] { taskResult }))); } if (typeOfDummy.FullName == "System.Threading.Tasks.ValueTask") { return(CreationResult.SuccessfullyCreated(typeOfDummy.GetDefaultValue())); } if (typeOfDummy.IsGenericType && !typeOfDummy.IsGenericTypeDefinition && typeOfDummy.FullName is string fullName && fullName.StartsWith("System.Threading.Tasks.ValueTask`", StringComparison.Ordinal)) { var typeOfTaskResult = typeOfDummy.GetGenericArguments()[0]; var creationResult = resolver.TryResolveDummyValue(typeOfTaskResult, resolutionContext); object?taskResult = creationResult.WasSuccessful ? creationResult.Result : typeOfTaskResult.GetDefaultValue(); var ctor = typeOfDummy.GetConstructor(new[] { typeOfTaskResult }) !; return(CreationResult.SuccessfullyCreated(ctor.Invoke(new[] { taskResult }))); } return(CreationResult.FailedToCreateDummy(typeOfDummy, "It is not a Task.")); }
public override CreationResult TryCreateDummyValue(Type typeOfDummy, IDummyValueResolver resolver) { if (typeOfDummy.GetTypeInfo().IsGenericType&& typeOfDummy.GetGenericTypeDefinition() == typeof(Lazy <>)) { var typeOfLazyResult = typeOfDummy.GetGenericArguments()[0]; var creationResult = resolver.TryResolveDummyValue(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.")); }
public override CreationResult TryCreateDummyValue(Type typeOfDummy, IDummyValueResolver resolver, LoopDetectingResolutionContext resolutionContext) { if (IsTuple(typeOfDummy)) { var argTypes = typeOfDummy.GetTypeInfo().GetGenericArguments(); var args = new object[argTypes.Length]; for (int i = 0; i < argTypes.Length; i++) { var argType = argTypes[i]; var creationResult = resolver.TryResolveDummyValue(argType, resolutionContext); args[i] = creationResult.WasSuccessful ? creationResult.Result : argType.GetDefaultValue(); } var dummy = Activator.CreateInstance(typeOfDummy, args); return(CreationResult.SuccessfullyCreated(dummy)); } return(CreationResult.FailedToCreateDummy(typeOfDummy, "It is not a tuple.")); }
public override CreationResult TryCreateDummyValue(Type typeOfDummy, IDummyValueResolver resolver) { 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 = resolver.TryResolveDummyValue(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.")); }
public CreationResult CreateFake( Type typeOfFake, IProxyOptions proxyOptions, IDummyValueResolver resolver, LoopDetectingResolutionContext resolutionContext) { if (!resolutionContext.TryBeginToResolve(typeOfFake)) { return(CreationResult.FailedToCreateFake(typeOfFake, "Recursive dependency detected. Already resolving " + typeOfFake + '.')); } var result = this.CreateFakeWithoutLoopDetection( typeOfFake, proxyOptions, resolver, resolutionContext); if (result.WasSuccessful) { resolutionContext.OnSuccessfulResolve(typeOfFake); } return(result); }
public CreationResult CreateFake( Type typeOfFake, IProxyOptions proxyOptions, IDummyValueResolver resolver, LoopDetectingResolutionContext resolutionContext) { if (!resolutionContext.TryBeginToResolve(typeOfFake)) { return(CreationResult.FailedToCreateFake(typeOfFake, "Recursive dependency detected. Already resolving " + typeOfFake + '.')); } try { return(this.CreateFakeWithoutLoopDetection( typeOfFake, proxyOptions, resolver, resolutionContext)); } finally { resolutionContext.EndResolve(typeOfFake); } }
public DefaultFakeAndDummyManager(IDummyValueResolver dummyValueResolver, FakeObjectCreator fakeCreator, DynamicOptionsBuilder dynamicOptionsBuilder) { this.dummyValueResolver = dummyValueResolver; this.fakeCreator = fakeCreator; this.dynamicOptionsBuilder = dynamicOptionsBuilder; }
public abstract CreationResult TryCreateDummyValue( Type typeOfDummy, IDummyValueResolver resolver, LoopDetectingResolutionContext resolutionContext);
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() }); }
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);
private static void StubResolverWithDummyValue <T>(IDummyValueResolver resolver, T dummyValue) { A.CallTo(() => resolver.TryResolveDummyValue(typeof(T))) .Returns(CreationResult.SuccessfullyCreated(dummyValue)); }
public FakeAndDummyManager(IDummyValueResolver dummyValueResolver, IFakeObjectCreator fakeCreator, ImplicitOptionsBuilderCatalogue implicitOptionsBuilderCatalogue) { this.dummyValueResolver = dummyValueResolver; this.fakeCreator = fakeCreator; this.implicitOptionsBuilderCatalogue = implicitOptionsBuilderCatalogue; }