public object CallOverride(Invocation invocation) { var args = implementationOverride.Method.GetParameters().Length > 0 && invocation.Args != null ? invocation.Args : Empty; var paramsCount = invocation.Method.GetParameters().Length; var implementationParamsCount = implementationOverride.Method.GetParameters().Length; if (invocation.Method.IsExtensionMethod() && paramsCount - 1 == implementationParamsCount) { args = args.Skip(1).ToArray(); } int extraParamCount = 1 + (implementationOverride.Target != null && implementationOverride.Method.IsStatic ? 1 : 0); if (!invocation.Method.IsStatic && extraParamCount + paramsCount == implementationParamsCount) { args = new[] { invocation.Instance }.Concat(args).ToArray(); } try { var returnValue = ProfilerInterceptor.GuardExternal(() => overrideInvoker(args, this.implementationOverride)); return(returnValue); } catch (InvalidCastException ex) { throw new MockException("The implementation callback has an incorrect signature", ex); } }
protected override bool MatchesCore(IMatcher other) { var otherRange = other as RangeMatcher <T>; if (otherRange != null) { return((this.kind == otherRange.kind || otherRange.kind == RangeKind.Exclusive) ? ProfilerInterceptor.GuardExternal(() => this.from.CompareTo(otherRange.from) <= 0 && this.to.CompareTo(otherRange.to) >= 0) : ProfilerInterceptor.GuardExternal(() => this.from.CompareTo(otherRange.from) < 0 && this.to.CompareTo(otherRange.to) > 0)); } var matcher = (IValueMatcher)other; if (matcher.Value == null) { return(false); } if (!typeof(T).IsAssignableFrom(matcher.Type)) { return(false); } T val = (T)matcher.Value; if (kind == Telerik.JustMock.RangeKind.Inclusive) { return(ProfilerInterceptor.GuardExternal(() => val.CompareTo(from) >= 0 && val.CompareTo(to) <= 0)); } else { return(ProfilerInterceptor.GuardExternal(() => val.CompareTo(from) > 0 && val.CompareTo(to) < 0)); } }
public object Create(Type type, MocksRepository repository, IMockMixin mockMixinImpl, MockCreationSettings settings, bool createTransparentProxy) { var baseType = type.IsGenericType ? type.GetGenericTypeDefinition() : type; RuntimeTypeHandle proxyTypeHandle; var key = new ProxySourceRegistry.ProxyKey( baseType.TypeHandle, GetAdditionalInterfaceHandles(type, settings.AdditionalMockedInterfaces)); if (!ProxySourceRegistry.ProxyTypes.TryGetValue(key, out proxyTypeHandle)) { ThrowNoProxyException(baseType, settings.AdditionalMockedInterfaces); } var interceptor = new DynamicProxyInterceptor(repository); var proxyType = Type.GetTypeFromHandle(proxyTypeHandle); if (proxyType.IsGenericTypeDefinition) { proxyType = proxyType.MakeGenericType(type.GetGenericArguments()); } var mockConstructorCall = settings.MockConstructorCall && proxyType.BaseType != typeof(object) && UninitializedObjectFactory.IsSupported; ConstructorInfo proxyCtor = null; if (!mockConstructorCall && settings.Args == null) { proxyCtor = proxyType.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) .First(ctor => ctor.IsPublic || ctor.IsFamily || ctor.IsFamilyOrAssembly); settings.Args = proxyCtor.GetParameters() .TakeWhile(p => p.ParameterType != typeof(IInterceptor)) .Select(p => (p.Attributes & ParameterAttributes.HasDefault) != 0 ? p.DefaultValue : p.ParameterType.GetDefaultValue()) .ToArray(); } var ctorArgs = (settings.Args ?? Enumerable.Empty <object>()) .Concat(new object[] { interceptor, mockMixinImpl }) .Concat(settings.Mixins).ToArray(); if (!mockConstructorCall) { if (proxyCtor != null) { return(ProfilerInterceptor.GuardExternal(() => proxyCtor.Invoke(ctorArgs))); } else { return(ProfilerInterceptor.GuardExternal(() => Activator.CreateInstance(proxyType, ctorArgs))); } } else { var result = UninitializedObjectFactory.Create(proxyType); proxyType.GetMethod(".init").Invoke(result, ctorArgs); return(result); } }
/// <summary> /// Creates an instance within the specified context. /// </summary> /// <param name="context">The context.</param> /// <returns>The created instance.</returns> public virtual object Create(IContext context) { Ensure.ArgumentNotNull(context, "context"); if (context.Plan == null) { context.Plan = this.Planner.GetPlan(this.GetImplementationType(context.Request.Service)); } if (!context.Plan.Has <ConstructorInjectionDirective>()) { throw new ActivationException(ExceptionFormatter.NoConstructorsAvailable(context)); } var directives = context.Plan.GetAll <ConstructorInjectionDirective>(); var bestDirectives = directives .GroupBy(option => this.ConstructorScorer.Score(context, option)) .OrderByDescending(g => g.Key) .First(); if (bestDirectives.Skip(1).Any()) { throw new ActivationException(ExceptionFormatter.ConstructorsAmbiguous(context, bestDirectives)); } var directive = bestDirectives.Single(); var arguments = directive.Targets.Select(target => this.GetValue(context, target)).ToArray(); var injector = directive.Injector; return(ProfilerInterceptor.GuardExternal(() => injector(arguments))); }
/// <summary> /// Sets the value of a property by name. /// </summary> /// <param name="name">The name of the property.</param> /// <param name="value">The value to set to the property.</param> /// <param name="indexArgs">Optional index arguments if the property has any.</param> public void SetProperty(string name, object value, params object[] indexArgs) { ProfilerInterceptor.GuardInternal(() => { var prop = ResolveProperty(this.type, name, false, indexArgs, this.instance != null, value, getter: false); ProfilerInterceptor.GuardExternal(() => SecuredReflectionMethods.SetProperty(prop, this.instance, value, indexArgs)); }); }
/// <summary> /// Gets the value of a property by name. /// </summary> /// <param name="name">The name of the property.</param> /// <param name="indexArgs">Optional index arguments if the property has any.</param> /// <returns>The value of the property.</returns> public object GetProperty(string name, params object[] indexArgs) { return(ProfilerInterceptor.GuardInternal(() => { var prop = ResolveProperty(this.type, name, false, indexArgs, this.instance != null); return ProfilerInterceptor.GuardExternal(() => SecuredReflectionMethods.GetProperty(prop, this.instance, indexArgs)); })); }
protected override bool MatchesCore(IMatcher other) { var matcher = (IValueMatcher)other; var value = matcher.Value; if (value == null && typeof(T).IsValueType) { return(false); } if (value != null && !typeof(T).IsAssignableFrom(matcher.Type)) { return(false); } return(ProfilerInterceptor.GuardExternal(() => predicate((T)value))); }
public void Process(object[] invocationArgs, Type declaringType) { object[] args = null; var func = this.eventDelegateParametersFactory as Func <object[]>; if (func != null) { args = ProfilerInterceptor.GuardExternal(func); } else { var invoker = MockingUtil.MakeFuncCaller(this.eventDelegateParametersFactory); args = (object[])ProfilerInterceptor.GuardExternal(() => invoker(invocationArgs, this.eventDelegateParametersFactory)); } RaiseEventImpl(this.instance, this.evt, args); }
private object CallInvoke(MethodBase method, object[] args) { try { return(ProfilerInterceptor.GuardExternal(() => SecuredReflectionMethods.Invoke(method, this.instance, args))); } catch (TargetInvocationException targetInvocationException) { if (this.RethrowOriginalOnCallMethod && targetInvocationException.InnerException != null) { throw targetInvocationException.InnerException; } else { throw; } } }
private static bool NodeMatchesFilter(CallPattern callPattern, IMatcherTreeNode node) { var filter = callPattern.Filter; if (filter == null) { return(true); } var args = new List <object>(); var nodeIter = node; while (nodeIter != null) { var valueMatcher = nodeIter.Matcher as IValueMatcher; if (valueMatcher != null) { args.Add(valueMatcher.Value); } nodeIter = nodeIter.Parent; } if (!callPattern.Method.IsStatic && filter.Method.GetParameters().Length + 1 == args.Count) { args.RemoveAt(args.Count - 1); } args.Reverse(); var argsArray = args.ToArray(); object state; MockingUtil.BindToMethod(MockingUtil.Default, new[] { filter.Method }, ref argsArray, null, null, null, out state); var filterFunc = MockingUtil.MakeFuncCaller(filter); var isMatch = (bool)ProfilerInterceptor.GuardExternal(() => filterFunc(argsArray, filter)); DebugView.TraceEvent(IndentLevel.Matcher, () => String.Format("Matcher predicate {0} call to {2} with arguments ({1})", isMatch ? "passed" : "rejected", String.Join(", ", args.Select(x => x.ToString()).ToArray()), callPattern.Method)); return(isMatch); }
public void RaiseEvent(EventInfo evt, object[] delegateArguments) { Delegate existing; eventHandlers.TryGetValue(evt, out existing); if (existing != null) { try { object state; MockingUtil.BindToMethod(MockingUtil.Default, new[] { existing.Method }, ref delegateArguments, null, null, null, out state); } catch (MissingMethodException ex) { throw new MockException(String.Format("Event signature {0} is incompatible with argument types ({1})", existing.Method, String.Join(", ", delegateArguments.Select(x => x != null ? x.GetType().ToString() : "null").ToArray()) ), ex); } var invoker = MockingUtil.MakeFuncCaller(existing); ProfilerInterceptor.GuardExternal(() => invoker(delegateArguments, existing)); } }
private object CallInvoke(MethodBase method, object[] args) { return(ProfilerInterceptor.GuardExternal(() => SecuredReflectionMethods.Invoke(method, this.instance, args))); }