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