public object Create(object request, ISpecimenContext context)
{
var requestedType = request as Type;
if (requestedType == null)
{
using (InstanceGetters.DisableProcessing())
return(new NoSpecimen());
}
using (InstanceGetters.DisableProcessing())
{
{
var result = CreatePrigType(requestedType);
if (!(result is NoSpecimen))
{
return(result);
}
}
{
var result = CreateInstancePrigType(requestedType);
if (!(result is NoSpecimen))
{
return(result);
}
}
return(new NoSpecimen());
}
}
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
using (InstanceGetters.DisableProcessing())
throw new ArgumentNullException("context");
}
var result = m_builder.Create(request, context);
using (InstanceGetters.DisableProcessing())
{
if (!(result is NoSpecimen))
{
return(result);
}
var requestedType = request as Type;
if (requestedType == null)
{
return(new NoSpecimen());
}
{
if (requestedType == typeof(IntPtr))
{
return(IntPtr.Zero);
}
}
return(new NoSpecimen());
}
}
public void SetBody(object value)
{
if (InstanceGetters.IsDisabledProcessing())
{
throw new InvalidOperationException("'SetBody(object)' can't be called while Prig framework is disabling processing. " +
"Confirm unintended calls for 'InstanceGetters.DisableProcessing().'");
}
BodyProperty.SetValue(BodyPropertyTarget, value, null);
}
void DoSetupForAutoMock(MockProxy proxy, MethodInfo dlgtMethod, ISpecimenContext context)
{
var setup = default(object);
using (InstanceGetters.DisableProcessing())
{
var proxyType = proxy.GetType();
var setupMethod = GetSetupMethod(proxyType, dlgtMethod);
var expression = GetExpression(setupMethod.GetParameters()[0].ParameterType, dlgtMethod, context);
setup = setupMethod.Invoke(proxy, new object[] { expression });
}
DoReturnsForAutoMock(setup, context);
}
MockProxy GetAutoMock(Type dlgtType, MethodInfo dlgtMethod, ISpecimenContext context)
{
Debug.Assert(dlgtType.IsSubclassOf(typeof(Delegate)));
var proxy = default(MockProxy);
using (InstanceGetters.DisableProcessing())
{
var createMethod = m_ms.GetType().GetMethod("Create", Type.EmptyTypes);
var createMethodInst = createMethod.MakeGenericMethod(dlgtType);
proxy = (MockProxy)createMethodInst.Invoke(m_ms, null);
}
DoSetupForAutoMock(proxy, dlgtMethod, context);
return(proxy);
}
public void InstanceGettersTest01()
{
var assemblyQualifiedName = "System.DateTime, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
var get_NowPtr = typeof(DateTime).GetProperty("Now").GetGetMethod().MethodHandle.GetFunctionPointer();
{
Assert.IsTrue(InstanceGetters.TryAdd(assemblyQualifiedName, get_NowPtr));
}
{
var funcPtr = IntPtr.Zero;
Assert.IsTrue(InstanceGetters.TryGet(assemblyQualifiedName, out funcPtr));
Assert.AreEqual(get_NowPtr, funcPtr);
}
}
void SetAutoBody(IndirectionStubSpecimen stub, ISpecimenContext context)
{
var proxy = default(MockProxy);
var dlgtType = default(Type);
var dlgtMethod = default(MethodInfo);
using (InstanceGetters.DisableProcessing())
{
dlgtType = stub.IndirectionDelegate;
dlgtMethod = stub.IndirectionDelegateMethod;
}
proxy = GetAutoMock(dlgtType, dlgtMethod, context);
stub.SetBody(proxy.Object);
using (InstanceGetters.DisableProcessing())
m_ms.Assign(stub.CallableTarget, proxy);
}
void DoReturnsForAutoMock(object setup, ISpecimenContext context)
{
var setupType = default(Type);
var resultType = default(Type);
using (InstanceGetters.DisableProcessing())
{
setupType = setup.GetType();
if (!setupType.GetInterfaces().Where(_ => _.IsGenericType).Any(_ => _.GetGenericTypeDefinition() == typeof(IReturns <,>)))
{
return;
}
resultType = setupType.GetGenericArguments()[1];
}
var result = context.Resolve(resultType);
if (result is NoSpecimen)
{
return;
}
using (InstanceGetters.DisableProcessing())
{
var returnsMethod = setupType.GetMethods(PublicInstance).Single(ReturnsImmediateValue);
resultType = result.GetType(); // replace result type because perhaps it is a Prig Type for a specified instance.
var paramType = returnsMethod.GetParameters()[0].ParameterType;
if (!paramType.IsAssignableFrom(resultType))
{
var opImplicitMethod = resultType.GetMethods(PublicStatic).
Where(_ => _.Name == "op_Implicit").
SingleOrDefault(_ => _.ReturnType == paramType);
if (opImplicitMethod == null)
{
throw new InvalidOperationException(string.Format("{0} doesn't have implicit conversion to {1}.", resultType, paramType));
}
result = opImplicitMethod.Invoke(null, new object[] { result });
}
returnsMethod.Invoke(setup, new object[] { result });
}
}
public object Create(object request, ISpecimenContext context)
{
if (context == null)
{
using (InstanceGetters.DisableProcessing())
throw new ArgumentNullException("context");
}
var result = m_builder.Create(request, context);
var specimen = default(PrigTypeSpecimen);
if ((specimen = result as PrigTypeSpecimen) != null)
{
return(CreateMock(specimen, context));
}
else if (!(result is NoSpecimen))
{
return(result);
}
using (InstanceGetters.DisableProcessing())
return(new NoSpecimen());
}
public void FixtureTearDown()
{
InstanceGetters.Clear();
}
public void FixtureSetUp()
{
InstanceGetters.Clear();
}
public void Customize(IFixture fixture)
{
using (InstanceGetters.DisableProcessing())
fixture.Customizations.Add(new IntPtrInitializer(new PrigTypeMocker(m_ms, new PrigTypeCollector())));
}
