private object InstantiateProxy(CompositeType compositeType, Type proxyType, MockFactory mockFactory, MockStyle mockStyle, string name, object[] constructorArgs)
{
IInterceptor interceptor = new MockObjectInterceptor(mockFactory, compositeType, name, mockStyle);
object[] activationArgs;
/* ^ */ var _typeInfo = compositeType.PrimaryType.GetTypeInfo(); /* [email protected] ^ */
if (/* ^ */ _typeInfo.IsClass /* [email protected] ^ */)
{
activationArgs = new object[constructorArgs.Length + 1];
constructorArgs.CopyTo(activationArgs, 1);
activationArgs[0] = new[] { interceptor };
}
else
{
activationArgs = new[] { new[] { interceptor }, new object(), name };
}
return Activator.CreateInstance(proxyType, activationArgs);
}
public override object CreateMock(MockFactory mockFactory, CompositeType typesToMock, string name, MockStyle mockStyle, object[] constructorArgs)
{
if (typesToMock == null)
throw new ArgumentNullException("typesToMock");
Type primaryType = typesToMock.PrimaryType;
Type[] additionalInterfaces = BuildAdditionalTypeArrayForProxyType(typesToMock);
IInterceptor mockInterceptor = new MockObjectInterceptor(mockFactory, typesToMock, name, mockStyle);
object result;
/* ^ */ var _typeInfo = primaryType.GetTypeInfo(); /* [email protected] ^ */
if (/* ^ */ _typeInfo.IsInterface /* [email protected] ^ */)
{
result = generator.CreateInterfaceProxyWithoutTarget(primaryType, additionalInterfaces, new ProxyGenerationOptions {BaseTypeForInterfaceProxy = typeof (InterfaceMockBase)}, mockInterceptor);
((InterfaceMockBase) result).Name = name;
}
else
{
result = generator.CreateClassProxy(primaryType, additionalInterfaces, ProxyGenerationOptions.Default, constructorArgs, mockInterceptor);
//return generator.CreateClassProxy(primaryType, new []{typeof(IMockObject)}, mockInterceptor);
}
return result;
}
/// <summary>
/// Initializes a new instance of the <see cref="MockObject"/> class.
/// </summary>
/// <param name="mockFactory">The mockFactory.</param>
/// <param name="mockedType">Type of the mocked.</param>
/// <param name="name">The name.</param>
/// <param name="mockStyle">The mock style.</param>
protected MockObject(MockFactory mockFactory, CompositeType mockedType, string name, MockStyle mockStyle)
{
MockFactory = mockFactory;
MockStyle = mockStyle;
MockName = name;
eventHandlers = new Dictionary<string, List<Delegate>>();
MockedTypes = mockedType;
}
/// <summary>
/// Initializes a new instance of the <see cref="MockObject"/> class.
/// </summary>
/// <param name="mockFactory">The mockFactory.</param>
/// <param name="mockedType">Type of the mocked.</param>
/// <param name="name">The name.</param>
/// <param name="mockStyle">The mock style.</param>
protected MockObject(MockFactory mockFactory, CompositeType mockedType, string name, MockStyle mockStyle)
{
MockFactory = mockFactory;
MockStyle = mockStyle;
MockName = name;
eventHandlers = new Dictionary <string, List <Delegate> >();
MockedTypes = mockedType;
}
/// <summary>
/// Specifies how the mock object should behave when first created.
/// It is invalid to set the MockStyle of a mock more than once.
/// </summary>
/// <param name="mockStyle">A MockStyle value.</param>
/// <returns>The mock object definition.</returns>
public IMockDefinitionSyntax OfStyle(MockStyle mockStyle)
{
if (_mockStyle.HasValue)
{
throw new InvalidOperationException("MockStyle has already been set for this mock definition.");
}
_mockStyle = mockStyle;
return(this);
}
public override object CreateMock(MockFactory mockFactory, CompositeType typesToMock, string name, MockStyle mockStyle, object[] constructorArgs)
{
_typesToMock = typesToMock;
_typesToMock.Add(typeof(IMockObject));
var reflectiveInterceptor = new ReflectiveInterceptor(mockFactory, typesToMock, name, mockStyle);
var proxy = CreateMock(reflectiveInterceptor, constructorArgs);
if (_typesToMock.PrimaryType.IsInterface)
((InterfaceMockBase) proxy).Name = name;
return proxy;
}
private object InstantiateProxy(CompositeType compositeType, MockFactory mockFactory, MockStyle mockStyle, string name, object[] constructorArgs)
{
LinFuMockObjectInterceptor interceptor = new LinFuMockObjectInterceptor(mockFactory, compositeType, name, mockStyle);
object proxy;
if (compositeType.PrimaryType.IsClass)
{
Type[] additionalInterfaceTypes = BuildAdditionalTypeArrayForProxyType(compositeType);
if (compositeType.PrimaryType.IsSealed)
{
throw new ArgumentException("Cannot mock sealed classes.");
}
proxy = factory.CreateProxy(compositeType.PrimaryType, interceptor, additionalInterfaceTypes);
}
else
{
Type[] additionalInterfaceTypes = BuildAdditionalTypeArrayForProxyType(compositeType);
proxy = factory.CreateProxy(typeof(InterfaceMockBase), interceptor, additionalInterfaceTypes);
}
return proxy;
}
/// <summary>
/// Creates a <see cref="Mock{T}"/> with the specified <see cref="MockStyle"/>.
/// </summary>
/// <typeparam name="T">The type of mock to create.</typeparam>
/// <param name="mockStyle"></param>
/// <returns></returns>
public Mock <T> CreateMock <T>(MockStyle mockStyle) where T : class
{
return(CreateMock <T>(DefinedAs.OfStyle(mockStyle)));
}
/// <summary>
/// Sets the mock style used for all properties and methods returning a value of type <paramref name="nestedMockType"/>
/// of the <paramref name="mock"/>.
/// </summary>
/// <param name="mock">The mock (with mock style Stub).</param>
/// <param name="nestedMockType">Type of the nested mock.</param>
/// <param name="nestedMockStyle">The nested mock style.</param>
public void SetStubMockStyle(object mock, Type nestedMockType, MockStyle nestedMockStyle)
{
IMockObject mockObject = CastToMockObject(mock);
_stubMockStyleDictionary[mockObject, nestedMockType] = nestedMockStyle;
}
/// <summary>
/// Sets the mock style used for all properties and methods returning a value of type <typeparamref name="TStub"/>
/// of the <paramref name="mock"/>.
/// </summary>
/// <typeparam name="TStub">The type of the stub.</typeparam>
/// <param name="mock">The mock (with mock style Stub).</param>
/// <param name="nestedMockStyle">The nested mock style.</param>
public void SetStubMockStyle <TStub>(object mock, MockStyle nestedMockStyle)
{
SetStubMockStyle(mock, typeof(TStub), nestedMockStyle);
}
/// <summary>
/// Creates a new named dynamic mock of the specified type and allows the style
/// of the mock to be specified.
/// </summary>
/// <param name="mockedType">The type to mock.</param>
/// <param name="name">A name for the mock that will be used in error messages.</param>
/// <param name="mockStyle">Specifies how the mock object should behave when first created.</param>
/// <param name="constructorArgs">The arguments for the constructor of the class to be mocked.
/// Only applicable when mocking classes with non-default constructors.</param>
/// <returns>A named mock.</returns>
internal object NewMock(Type mockedType, string name, MockStyle mockStyle, params object[] constructorArgs)
{
return(DefinedAs.Named(name).OfStyle(mockStyle).WithArgs(constructorArgs).Create(mockedType, this, _currentMockObjectFactory));
}
public ReflectiveInterceptor(MockFactory mockFactory, CompositeType mockedType, string name, MockStyle mockStyle)
: base(mockFactory, mockedType, name, mockStyle)
{
}
/// <summary>
/// Creates a mock of the specified type(s).
/// </summary>
/// <param name="mockFactory">The mockFactory used to create this mock instance.</param>
/// <param name="typesToMock">The type(s) to include in the mock.</param>
/// <param name="name">The name to use for the mock instance.</param>
/// <param name="mockStyle">The behaviour of the mock instance when first created.</param>
/// <param name="constructorArgs">Constructor arguments for the class to be mocked. Only valid if mocking a class type.</param>
/// <returns>A mock instance of the specified type(s).</returns>
public override object CreateMock(MockFactory mockFactory, CompositeType typesToMock, string name, MockStyle mockStyle, object[] constructorArgs)
{
Type proxyType = GetProxyType(typesToMock);
return InstantiateProxy(typesToMock, proxyType, mockFactory, mockStyle, name, constructorArgs);
}
protected InterceptorBase(MockFactory mockFactory, CompositeType mockedType, string name, MockStyle mockStyle)
: base(mockFactory, mockedType, name, mockStyle)
{
}
public ReflectiveInterceptor(MockFactory mockFactory, CompositeType mockedType, string name, MockStyle mockStyle)
: base(mockFactory, mockedType, name, mockStyle)
{
}
protected InterceptorBase(MockFactory mockFactory, CompositeType mockedType, string name, MockStyle mockStyle)
: base(mockFactory, mockedType, name, mockStyle)
{
}
public override object CreateMock(MockFactory mockFactory, CompositeType typesToMock, string name, MockStyle mockStyle, object[] constructorArgs)
{
if (typesToMock == null)
{
throw new ArgumentNullException("typesToMock");
}
Type primaryType = typesToMock.PrimaryType;
Type[] additionalInterfaces = BuildAdditionalTypeArrayForProxyType(typesToMock);
IInterceptor mockInterceptor = new MockObjectInterceptor(mockFactory, typesToMock, name, mockStyle);
object result;
/* ^ */ var _typeInfo = primaryType.GetTypeInfo(); /* [email protected] ^ */
if (/* ^ */ _typeInfo.IsInterface /* [email protected] ^ */)
{
result = generator.CreateInterfaceProxyWithoutTarget(primaryType, additionalInterfaces, new ProxyGenerationOptions {
BaseTypeForInterfaceProxy = typeof(InterfaceMockBase)
}, mockInterceptor);
((InterfaceMockBase)result).Name = name;
}
else
{
result = generator.CreateClassProxy(primaryType, additionalInterfaces, ProxyGenerationOptions.Default, constructorArgs, mockInterceptor);
//return generator.CreateClassProxy(primaryType, new []{typeof(IMockObject)}, mockInterceptor);
}
return(result);
}
public override object CreateMock(MockFactory mockFactory, CompositeType typesToMock, string name, MockStyle mockStyle, object[] constructorArgs)
{
_typesToMock = typesToMock;
_typesToMock.Add(typeof(IMockObject));
var reflectiveInterceptor = new ReflectiveInterceptor(mockFactory, typesToMock, name, mockStyle);
var proxy = CreateMock(reflectiveInterceptor, constructorArgs);
if (_typesToMock.PrimaryType.IsInterface)
{
((InterfaceMockBase)proxy).Name = name;
}
return(proxy);
}
private object InstantiateProxy(CompositeType compositeType, Type proxyType, MockFactory mockFactory, MockStyle mockStyle, string name, object[] constructorArgs)
{
IInterceptor interceptor = new MockObjectInterceptor(mockFactory, compositeType, name, mockStyle);
object[] activationArgs;
if (compositeType.PrimaryType.IsClass)
{
activationArgs = new object[constructorArgs.Length + 1];
constructorArgs.CopyTo(activationArgs, 1);
activationArgs[0] = new[] { interceptor };
}
else
{
activationArgs = new[] { new[] { interceptor }, new object(), name };
}
return(Activator.CreateInstance(proxyType, activationArgs));
}
internal LinFuMockObjectInterceptor(MockFactory mockFactory, CompositeType mockedType, string name, MockStyle mockStyle) : base(mockFactory, mockedType, name, mockStyle)
{
}
/// <summary>
/// Creates a <see cref="Mock{T}"/> with the specified <see cref="MockStyle"/> and additional types.
/// </summary>
/// <typeparam name="T">The type of mock to create.</typeparam>
/// <param name="mockStyle"></param>
/// <param name="additionalTypesToMock"></param>
/// <returns></returns>
public Mock <T> CreateMock <T>(MockStyle mockStyle, params Type[] additionalTypesToMock) where T : class
{
return(CreateMock <T>(DefinedAs.OfStyle(mockStyle).Implementing(additionalTypesToMock)));
}
/// <summary> /// Creates a mock of the specified type(s). /// </summary> /// <param name="mockFactory">The mockFactory used to create this mock instance.</param> /// <param name="typesToMock">The type(s) to include in the mock.</param> /// <param name="name">The name to use for the mock instance.</param> /// <param name="mockStyle">The behaviour of the mock instance when first created.</param> /// <param name="constructorArgs">Constructor arguments for the class to be mocked. Only valid if mocking a class type.</param> /// <returns>A mock instance of the specified type(s).</returns> public abstract object CreateMock(MockFactory mockFactory, CompositeType typesToMock, string name, MockStyle mockStyle, object[] constructorArgs);
/// <summary>
/// Creates a <see cref="Mock{T}"/> with the specified name and <see cref="MockStyle"/>.
/// </summary>
/// <typeparam name="T">The type of mock to create.</typeparam>
/// <param name="name"></param>
/// <param name="mockStyle"></param>
/// <returns></returns>
public Mock <T> CreateMock <T>(string name, MockStyle mockStyle) where T : class
{
return(CreateMock <T>(DefinedAs.Named(name).OfStyle(mockStyle)));
}
private object InstantiateProxy(CompositeType compositeType, MockFactory mockFactory, MockStyle mockStyle, string name, object[] constructorArgs)
{
LinFuMockObjectInterceptor interceptor = new LinFuMockObjectInterceptor(mockFactory, compositeType, name, mockStyle);
object proxy;
if (compositeType.PrimaryType.IsClass)
{
Type[] additionalInterfaceTypes = BuildAdditionalTypeArrayForProxyType(compositeType);
if (compositeType.PrimaryType.IsSealed)
{
throw new ArgumentException("Cannot mock sealed classes.");
}
proxy = factory.CreateProxy(compositeType.PrimaryType, interceptor, additionalInterfaceTypes);
}
else
{
Type[] additionalInterfaceTypes = BuildAdditionalTypeArrayForProxyType(compositeType);
proxy = factory.CreateProxy(typeof(InterfaceMockBase), interceptor, additionalInterfaceTypes);
}
return(proxy);
}
/// <summary> /// Creates a mock of the specified type(s). /// </summary> /// <param name="mockFactory">The mockFactory used to create this mock instance.</param> /// <param name="typesToMock">The type(s) to include in the mock.</param> /// <param name="name">The name to use for the mock instance.</param> /// <param name="mockStyle">The behaviour of the mock instance when first created.</param> /// <param name="constructorArgs">Constructor arguments for the class to be mocked. Only valid if mocking a class type.</param> /// <returns>A mock instance of the specified type(s).</returns> public abstract object CreateMock(MockFactory mockFactory, CompositeType typesToMock, string name, MockStyle mockStyle, object[] constructorArgs);
/// <summary>
/// Creates a new dynamic mock of the specified type.
/// </summary>
/// <typeparam name="TMockedType">The type to mock.</typeparam>
/// <param name="mockStyle">Specifies how the mock object should behave when first created.</param>
/// <param name="constructorArgs">The arguments for the constructor of the class to be mocked.
/// Only applicable when mocking classes with non-default constructors.</param>
/// <returns>A dynamic mock for the specified type.</returns>
public TMockedType CreateInstance <TMockedType>(MockStyle mockStyle, params object[] constructorArgs)
{
return(CreateInstance <TMockedType>(DefinedAs.OfStyle(mockStyle).WithArgs(constructorArgs)));
}
/// <summary>
/// Creates a mock of the specified type(s).
/// </summary>
/// <param name="mockFactory">The mockFactory used to create this mock instance.</param>
/// <param name="typesToMock">The type(s) to include in the mock.</param>
/// <param name="name">The name to use for the mock instance.</param>
/// <param name="mockStyle">The behaviour of the mock instance when first created.</param>
/// <param name="constructorArgs">Constructor arguments for the class to be mocked. Only valid if mocking a class type.</param>
/// <returns>A mock instance of the specified type(s).</returns>
public override object CreateMock(MockFactory mockFactory, CompositeType typesToMock, string name, MockStyle mockStyle, object[] constructorArgs)
{
Type proxyType = GetProxyType(typesToMock);
return(InstantiateProxy(typesToMock, proxyType, mockFactory, mockStyle, name, constructorArgs));
}
/// <summary>
/// Initializes a new instance of the <see cref="MockObjectInterceptor"/> class.
/// </summary>
/// <param name="mockFactory">The mockFactory.</param>
/// <param name="mockedType">Type of the mocked.</param>
/// <param name="name">The name.</param>
/// <param name="mockStyle">The mock style.</param>
internal MockObjectInterceptor(MockFactory mockFactory, CompositeType mockedType, string name, MockStyle mockStyle)
: base(mockFactory, mockedType, name, mockStyle)
{
}
public object CreateMock(MockFactory mockFactory, CompositeType mockedTypes, string name, MockStyle mockStyle, object[] constructorArgs)
{
return(null);
}
private object InstantiateProxy(CompositeType compositeType, Type proxyType, MockFactory mockFactory, MockStyle mockStyle, string name, object[] constructorArgs)
{
IInterceptor interceptor = new MockObjectInterceptor(mockFactory, compositeType, name, mockStyle);
object[] activationArgs;
/* ^ */ var _typeInfo = compositeType.PrimaryType.GetTypeInfo(); /* [email protected] ^ */
if (/* ^ */ _typeInfo.IsClass /* [email protected] ^ */)
{
activationArgs = new object[constructorArgs.Length + 1];
constructorArgs.CopyTo(activationArgs, 1);
activationArgs[0] = new[] { interceptor };
}
else
{
activationArgs = new[] { new[] { interceptor }, new object(), name };
}
return(Activator.CreateInstance(proxyType, activationArgs));
}
/// <summary>
/// Specifies how the mock object should behave when first created.
/// </summary>
/// <param name="mockStyle">A MockStyle value.</param>
/// <returns>The mock object definition.</returns>
public static IMockDefinitionSyntax OfStyle(MockStyle mockStyle)
{
return(new MockBuilder().OfStyle(mockStyle));
}
/// <summary>
/// Creates a <see cref="Mock{T}"/> using the specified arguments.
/// </summary>
/// <typeparam name="T">The type of mock to create.</typeparam>
/// <param name="name"></param>
/// <param name="mockStyle"></param>
/// <param name="additionalTypesToMock"></param>
/// <param name="constructorArguments"></param>
/// <returns></returns>
public Mock <T> CreateMock <T>(string name, MockStyle mockStyle, Type[] additionalTypesToMock, params object[] constructorArguments) where T : class
{
return(CreateMock <T>(DefinedAs.Named(name).OfStyle(mockStyle).Implementing(additionalTypesToMock).WithArgs(constructorArguments)));
}
