internal static PropertyInfo ResolveProperty(Type type, string name, bool ignoreCase, object[] indexArgs, bool hasInstance, object setterValue = null, bool getter = true)
{
var candidates = type.GetAllProperties().Where(prop => MockingUtil.StringEqual(prop.Name, name, ignoreCase)).ToArray();
if (candidates.Length == 1)
{
return(candidates[0]);
}
if (!getter)
{
Array.Resize(ref indexArgs, indexArgs.Length + 1);
indexArgs[indexArgs.Length - 1] = setterValue;
}
var propMethods = candidates
.Select(prop => getter ? prop.GetGetMethod(true) : prop.GetSetMethod(true))
.Where(m => m != null && CanCall(m, hasInstance))
.ToArray();
indexArgs = indexArgs ?? MockingUtil.NoObjects;
object state;
var foundGetter = MockingUtil.BindToMethod(MockingUtil.AllMembers, propMethods, ref indexArgs, null, null, null, out state);
return(candidates.First(prop => (getter ? prop.GetGetMethod(true) : prop.GetSetMethod(true)) == foundGetter));
}
private AssemblyName GetAssemblyName(bool signStrongName)
{
var keyPairStream = signStrongName ? GetKeyPair() : null;
var name = signStrongName ? strongAssemblyName : weakAssemblyName;
return(MockingUtil.GetStrongAssemblyName(name, keyPairStream));
}
public static string FormatValue(object value)
{
if (value == null)
{
return("null");
}
if (value is string)
{
return(String.Format("\"{0}\"", value));
}
if (value is char)
{
return(String.Format("'{0}'", value));
}
var valueType = MockingUtil.GetUnproxiedType(value);
string valueStr = valueType.ToString();
try
{
valueStr = value.ToString();
}
catch { }
if (valueStr == valueType.ToString())
{
return(valueStr);
}
return(String.Format("({0}) {1}", valueType.GetShortCSharpName(), valueStr));
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
var callResult = Expression.Variable(typeof(object));
var argsVar = Expression.Variable(typeof(object[]));
MethodInfo invoke = typeof(PrivateAccessor).GetMethod("CallMethod", new[] { typeof(string), typeof(object[]) });
var invokeArgs = new List <Expression>
{
Expression.Constant(binder.Name),
argsVar
};
var typeArgs = MockingUtil.TryGetTypeArgumentsFromBinder(binder);
if (typeArgs != null)
{
invoke = typeof(PrivateAccessor).GetMethod("CallMethodWithTypeArguments");
invokeArgs.Insert(1, Expression.Constant(typeArgs));
}
var executionList = new List <Expression>
{
Expression.Assign(argsVar, Expression.NewArrayInit(typeof(object), args.Select(a => Expression.Convert(a.Expression, typeof(object))))),
Expression.Assign(callResult, Expression.Call(
Expression.Convert(this.Expression, typeof(PrivateAccessor)), invoke, invokeArgs.ToArray())),
};
executionList.AddRange(args
.Select((a, i) => new { expr = a.Expression, i })
.Where(p => p.expr is ParameterExpression)
.Select(p => Expression.Assign(p.expr, Expression.Convert(Expression.ArrayIndex(argsVar, Expression.Constant(p.i)), p.expr.Type))));
executionList.Add(callResult);
return(CreateMetaObject(Expression.Block(new[] { argsVar, callResult }, executionList)));
}
public ImplementationOverrideBehavior(Delegate implementationOverride, bool ignoreDelegateReturnValue)
{
this.ignoreDelegateReturnValue = ignoreDelegateReturnValue;
this.implementationOverride = implementationOverride;
this.overrideInvoker = MockingUtil.MakeFuncCaller(implementationOverride);
}
/// <summary>
/// Creates a mocked instance from an internal class.
/// </summary>
/// <param name="fullName">Fully qualified name of the target type.</param>
/// <param name="behavior">Specifies behavior of the mock. Default is <see cref="Behavior.RecursiveLoose"/></param>
/// <returns>Mock instance</returns>
public static object Create(string fullName, Behavior behavior)
{
return(ProfilerInterceptor.GuardInternal(() =>
{
return MockingContext.CurrentRepository.Create(MockingUtil.GetTypeFrom(fullName), null, behavior, null, null);
}));
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
var wrapper = this.Value as ExpressionContainer;
var valueExpr = wrapper.Expression;
var typeArgs = MockingUtil.TryGetTypeArgumentsFromBinder(binder);
var candidateMethods = valueExpr.Type.GetAllMethods()
.Where(m => MockingUtil.StringEqual(m.Name, binder.Name, binder.IgnoreCase) && m.IsStatic == wrapper.IsStatic)
.Where(m => m.GetParameters().Length >= args.Length)
.Select(m =>
{
if (typeArgs == null)
{
return(MockingUtil.TrySpecializeGenericMethod(m, args.Select(a => a.RuntimeType).ToArray()) ?? m);
}
else
{
return(MockingUtil.TryApplyTypeArguments(m, typeArgs));
}
})
.Where(m => m != null)
.Where(m =>
{
var methodParams = m.GetParameters();
for (int i = 0; i < args.Length; ++i)
{
var matcher = UnwrapMatcher(args[i]);
if (matcher != null)
{
var argType = matcher.ReturnType;
if (!methodParams[i].ParameterType.IsAssignableFrom(argType))
{
return(false);
}
}
}
return(true);
})
.ToArray();
if (candidateMethods.Length == 0 && args.Length == 0)
{
return(DoBindGetMember(binder.ReturnType, binder.Name, binder.IgnoreCase));
}
var methodArgs = args.Select(a =>
{
var matcher = UnwrapMatcher(a);
return(matcher != null ? matcher.ReturnType.GetDefaultValue() : a.Value);
}).ToArray();
object state;
var method = (MethodInfo)MockingUtil.BindToMethod(MockingUtil.Default, candidateMethods, ref methodArgs, null, null, null, out state);
var memberExpr = Expression.Call(!wrapper.IsStatic ? valueExpr : null, method, args.Select(FromArg).ToArray());
return(CreateRecorder(memberExpr, binder.ReturnType, BindingRestrictions.GetInstanceRestriction(this.Expression, this.Value)));
}
internal static object IsAny(Type type, params object[] args)
{
return(ProfilerInterceptor.GuardInternal(() =>
{
MockingContext.CurrentRepository.AddMatcherInContext(new TypeMatcher(type));
return MockingUtil.CreateInstance(type, args);
}));
}
/// <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 = MockingUtil.ResolveProperty(this.type, name, false, indexArgs, this.instance != null, value, getter: false);
ProfilerInterceptor.GuardExternal(() => SecuredReflectionMethods.SetProperty(prop, this.instance, value, indexArgs));
});
}
public void Raise(object instance, string eventName, params object[] args)
{
ProfilerInterceptor.GuardInternal(() =>
{
RaiseEventBehavior.RaiseEventImpl(instance, MockingUtil.GetUnproxiedType(instance).GetEvent(eventName,
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance), args);
});
}
/// <summary>
/// Throws a the specified exception for the target async call causing returned task to fail.
/// </summary>
/// <returns></returns>
public IAssertable ThrowsAsync <T>(params object[] args) where T : Exception
{
return(ProfilerInterceptor.GuardInternal(() =>
{
this.behaviors.Add(new ThrowAsyncExceptionBehavior((T)MockingUtil.CreateInstance(typeof(T), args)));
return this;
}));
}
/// <summary>
/// Throws a the specified expection for target call.
/// </summary>
/// <returns></returns>
public IAssertable Throws <T>() where T : Exception
{
return(ProfilerInterceptor.GuardInternal(() =>
{
this.behaviors.Add(new ThrowExceptionBehavior((T)MockingUtil.CreateInstance(typeof(T))));
return this;
}));
}
public void Assert(object target, MethodInfo method, Occurs occurs, params object[] args)
{
ProfilerInterceptor.GuardInternal(() =>
{
var message = MockingUtil.GetAssertionMessage(args);
MockingContext.CurrentRepository.AssertMethodInfo(message, target, method, args, occurs);
});
}
public void Assert(MethodBase method, params object[] args)
{
ProfilerInterceptor.GuardInternal(() =>
{
var message = MockingUtil.GetAssertionMessage(args);
MockingContext.CurrentRepository.AssertMethodInfo(message, null, method, args, null);
});
}
public ActionExpectation Arrange(Type targetType, string memberName, params object[] args)
{
return(ProfilerInterceptor.GuardInternal(() =>
{
var method = MockingUtil.GetMethodByName(targetType, typeof(void), memberName, ref args);
return MockingContext.CurrentRepository.Arrange(null, method, args, () => new ActionExpectation());
}));
}
public FuncExpectation <TReturn> Arrange <T, TReturn>(string memberName, params object[] args)
{
return(ProfilerInterceptor.GuardInternal(() =>
{
var method = MockingUtil.GetMethodByName(typeof(T), typeof(TReturn), memberName, ref args);
return MockingContext.CurrentRepository.Arrange(null, method, args, () => new FuncExpectation <TReturn>());
}));
}
/// <summary>
/// Raises the specified event passing the given arguments to the handlers.
/// </summary>
/// <param name="name">The name of the event to raise.</param>
/// <param name="eventArgs">Arguments to pass to the event handlers. Must match the event handler signature exactly.</param>
public void RaiseEvent(string name, params object[] eventArgs)
{
ProfilerInterceptor.GuardInternal(() =>
{
var evt = this.type.GetEvent(name, MockingUtil.AllMembers);
MockingUtil.RaiseEventThruReflection(this.instance, evt, eventArgs);
});
}
public int GetTimesCalled(Type type, string memberName, params object[] args)
{
return(ProfilerInterceptor.GuardInternal(() =>
{
var method = MockingUtil.GetMethodByName(type, typeof(void), memberName, ref args);
return MockingContext.CurrentRepository.GetTimesCalledFromMethodInfo(null, method, args);
}));
}
/// <summary>
/// Creates a mocked instance from an internal class.
/// </summary>
/// <param name="fullName">Fully qualified name of the target type.</param>
/// <param name="behavior">Specifies behavior of the mock. Default is <see cref="Behavior.RecursiveLoose"/></param>
/// <returns>Mock instance</returns>
public static object Create(string fullName, Behavior behavior)
{
return(ProfilerInterceptor.GuardInternal(() =>
{
MockCreationSettings settings = MockCreationSettings.GetSettings(behavior);
return MockingContext.CurrentRepository.Create(MockingUtil.GetTypeFrom(fullName), settings);
}));
}
public FuncExpectation <TReturn> Arrange <TReturn>(object target, string methodName, Type[] memberParamTypes, string localFunctionName, params object[] args)
{
return(ProfilerInterceptor.GuardInternal(() =>
{
MethodInfo method = MockingUtil.GetMethodWithLocalFunction(target, methodName, memberParamTypes);
return this.Arrange <TReturn>(target, method, localFunctionName, args);
}));
}
/// <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 = MockingUtil.ResolveProperty(this.type, name, false, indexArgs, this.instance != null);
return ProfilerInterceptor.GuardExternal(() => SecuredReflectionMethods.GetProperty(prop, this.instance, indexArgs));
}));
}
public ActionExpectation Arrange(Type type, string methodName, Type[] methodParamTypes, string localMemberName, params object[] args)
{
return(ProfilerInterceptor.GuardInternal(() =>
{
MethodInfo method = MockingUtil.GetMethodWithLocalFunction(type, methodName, methodParamTypes);
return this.Arrange(type, method, localMemberName, args);
}));
}
public ActionExpectation Arrange(object target, MethodInfo method, string localFunctionName, params object[] args)
{
return(ProfilerInterceptor.GuardInternal(() =>
{
MethodInfo localMethod = MockingUtil.GetLocalFunction(target, method, localFunctionName);
return Mock.NonPublic.Arrange(target, localMethod, args);
}));
}
public void Assert(object target, string methodName, Type[] methodParamTypes, string localFunctionName, params object[] args)
{
ProfilerInterceptor.GuardInternal(() =>
{
MethodInfo method = MockingUtil.GetMethodWithLocalFunction(target, methodName, methodParamTypes);
this.Assert(target, method, localFunctionName, args);
});
}
public FuncExpectation <TReturn> Arrange <TReturn>(Type type, MethodInfo method, string localFunctionName, params object[] args)
{
return(ProfilerInterceptor.GuardInternal(() =>
{
MethodInfo localMethod = MockingUtil.GetLocalFunction(type, method, localFunctionName);
return Mock.NonPublic.Arrange <TReturn>(type, localMethod, args);
}));
}
public object Call(object target, MethodInfo method, string localFunctionName, params object[] args)
{
return(ProfilerInterceptor.GuardInternal(() =>
{
Type type = target.GetType();
MethodInfo localFunction = MockingUtil.GetLocalFunction(type, method, localFunctionName);
return Mock.NonPublic.MakePrivateAccessor(target).CallMethod(localFunction, args);
}));
}
public void Assert(Type targetType, string memberName, Occurs occurs, params object[] args)
{
ProfilerInterceptor.GuardInternal(() =>
{
var message = MockingUtil.GetAssertionMessage(args);
var method = MockingUtil.GetMethodByName(targetType, typeof(void), memberName, ref args);
MockingContext.CurrentRepository.AssertMethodInfo(message, null, method, args, occurs);
});
}
void INonPublicExpectation.Assert <TReturn>(Type targetType, string memberName, params object[] args)
{
ProfilerInterceptor.GuardInternal(() =>
{
var message = MockingUtil.GetAssertionMessage(args);
var method = MockingUtil.GetMethodByName(targetType, typeof(TReturn), memberName, ref args);
MockingContext.CurrentRepository.AssertMethodInfo(message, null, method, args, null);
});
}
/// <summary>
/// Creates a mocked instance from an internal class.
/// </summary>
/// <param name="fullName">Fully qualified name of the target type.</param>
/// <param name="settings">Settings for the mock</param>
/// <returns>Mock instance</returns>
public static object Create(string fullName, Action <IFluentConfig> settings)
{
return(ProfilerInterceptor.GuardInternal(() =>
{
var fluentConfig = new FluentConfig();
settings(fluentConfig);
return fluentConfig.CreateMock(MockingUtil.GetTypeFrom(fullName), MockingContext.CurrentRepository);
}));
}
public void Assert(object target, MethodInfo method, string localFunctionName, Occurs occurs, params object[] args)
{
ProfilerInterceptor.GuardInternal(() =>
{
Type type = target.GetType();
MethodInfo localFunction = MockingUtil.GetLocalFunction(type, method, localFunctionName);
Mock.NonPublic.Assert(target, localFunction, occurs, args);
});
}
