private void DoTestWithParametersBig(object[] objects)
{
var i1Mock = NewMock <I1>();
internalContainer.ExpectGet(context, i1Mock);
var factoryConstructorInfo = new ContainerConstructorInfo
{
ConstructorInfo =
typeof(C3).GetConstructor(new[]
{
typeof(int[]),
typeof(object[]), typeof(I1),
typeof(int?), typeof(object)
}),
ParametersInfo = new[] { 3, 1, -1, 0, 2 }
};
Func <IInternalContainer, IInjectionContext, object[], object> @delegate =
classCreator.BuildConstructionDelegate(factoryConstructorInfo, null);
object instance = @delegate(internalContainer, context, objects);
Assert.That(instance, Is.InstanceOf <C3>());
Assert.AreSame(i1Mock, ((C3)instance).i1Field);
Assert.AreEqual(objects[0], ((C3)instance).intField);
Assert.AreEqual(objects[1], ((C3)instance).objectArrayField);
Assert.AreEqual(objects[2], ((C3)instance).objectField);
Assert.AreEqual(objects[3], ((C3)instance).intArrayField);
}
public void TestParentAndChild()
{
ContainerConstructorInfo constructor = constructorSelector.GetConstructor(typeof(C2),
new[] { typeof(Guid), typeof(Guid?) });
CheckConstructor <C2>(new[] { typeof(Guid?), typeof(Guid) }, constructor, new[] { 1, 0 });
}
private void DoTestWithParameters(object[] objects)
{
var i2Mock = NewMock <I2>();
internalContainer.ExpectGet(context, i2Mock);
var factoryConstructorInfo = new ContainerConstructorInfo
{
ConstructorInfo =
typeof(C3).GetConstructor(new[]
{
typeof(int), typeof(I2),
typeof(string)
}),
ParametersInfo = new[] { 1, -1, 0 }
};
Func <IInternalContainer, IInjectionContext, object[], object> @delegate =
classCreator.BuildConstructionDelegate(factoryConstructorInfo, null);
object instance = @delegate(internalContainer, context, objects);
Assert.That(instance, Is.InstanceOf <C3>());
Assert.AreSame(i2Mock, ((C3)instance).z);
Assert.AreSame(objects[0], ((C3)instance).b);
Assert.AreEqual(objects[1], ((C3)instance).a);
}
public void TestAssignableFrom()
{
ContainerConstructorInfo constructor = constructorSelector.GetConstructor(typeof(C1),
new[] { typeof(Impl) });
CheckConstructor <C1>(new[] { typeof(I1), typeof(Base), typeof(I2) }, constructor, new[] { -1, 0, -1 });
}
private void DoTestWithParametersBig(object[] objects)
{
contextMock.Setup(x => x.InternalContainer).Returns(internalContainerMock.Object);
var i1Mock = GetMock <I1>().Object;
internalContainerMock.Setup(x => x.Get <I1>(contextMock.Object)).Returns(i1Mock);
contextMock.Setup(c => c.BeginConstruct(typeof(C3)));
contextMock.Setup(c => c.EndConstruct(typeof(C3)));
var factoryConstructorInfo = new ContainerConstructorInfo
{
ConstructorInfo =
typeof(C3).GetConstructor(new[]
{
typeof(int[]),
typeof(object[]), typeof(I1),
typeof(int?), typeof(object)
}),
ParametersInfo = new[] { 3, 1, -1, 0, 2 }
};
var classFactory = classCreator.BuildFactory(factoryConstructorInfo, null);
var instance = classFactory.Create(contextMock.Object, objects);
Assert.That(instance, Is.InstanceOf <C3>());
Assert.AreSame(i1Mock, ((C3)instance).i1Field);
Assert.AreEqual(objects[0], ((C3)instance).intField);
Assert.AreEqual(objects[1], ((C3)instance).objectArrayField);
Assert.AreEqual(objects[2], ((C3)instance).objectField);
Assert.AreEqual(objects[3], ((C3)instance).intArrayField);
}
public void TestSimple()
{
ContainerConstructorInfo constructor = constructorSelector.GetConstructor(typeof(C1),
new[] { typeof(int) });
CheckConstructor <C1>(new[] { typeof(int), typeof(I1) }, constructor, new[] { 0, -1 });
}
private void DoTestWithParameters(object[] objects)
{
contextMock.Setup(x => x.InternalContainer).Returns(internalContainerMock.Object);
var i2Mock = GetMock <I2>().Object;
internalContainerMock.Setup(x => x.Get <I2>(contextMock.Object)).Returns(i2Mock);
contextMock.Setup(c => c.BeginConstruct(typeof(C3)));
contextMock.Setup(c => c.EndConstruct(typeof(C3)));
var factoryConstructorInfo = new ContainerConstructorInfo
{
ConstructorInfo =
typeof(C3).GetConstructor(new[]
{
typeof(int), typeof(I2),
typeof(string)
}),
ParametersInfo = new[] { 1, -1, 0 }
};
var classFactory = classCreator.BuildFactory(factoryConstructorInfo, null);
var instance = classFactory.Create(contextMock.Object, objects);
Assert.That(instance, Is.InstanceOf <C3>());
Assert.AreSame(i2Mock, ((C3)instance).z);
Assert.AreSame(objects[0], ((C3)instance).b);
Assert.AreEqual(objects[1], ((C3)instance).a);
}
private void DoTestWithParameters(object[] objects)
{
var i2Mock = NewMock <I2>();
internalContainer.ExpectGet(context, i2Mock);
context.Expect(c => c.BeginConstruct(typeof(C3)));
context.Expect(c => c.EndConstruct(typeof(C3)));
var factoryConstructorInfo = new ContainerConstructorInfo
{
ConstructorInfo =
typeof(C3).GetConstructor(new[]
{
typeof(int), typeof(I2),
typeof(string)
}),
ParametersInfo = new[] { 1, -1, 0 }
};
IClassFactory classFactory = classCreator.BuildFactory(factoryConstructorInfo, null);
object instance = classFactory.Create(context, objects);
Assert.That(instance, Is.InstanceOf <C3>());
Assert.AreSame(i2Mock, ((C3)instance).z);
Assert.AreSame(objects[0], ((C3)instance).b);
Assert.AreEqual(objects[1], ((C3)instance).a);
}
public void TestBadFunc()
{
var constructorInfo = new ContainerConstructorInfo
{
ConstructorInfo = testType.GetConstructor(new[] { typeof(Func <I1>), typeof(long) })
};
RunMethodWithException <NotSupportedException>(() => classCreator.BuildFactory(constructorInfo, wrapperType: null));
}
protected static void CheckConstructor <T>(Type[] types, ContainerConstructorInfo constructor, int[] expectedPermutation)
{
Assert.IsNotNull(constructor.ConstructorInfo, "Конструктор не найден");
Assert.AreEqual(typeof(T), constructor.ConstructorInfo.ReflectedType);
var expected = typeof(T).GetConstructor(types);
Assert.IsNotNull(expected, "Ожидаемый конструктор не найден");
Assert.AreEqual(expected, constructor.ConstructorInfo, "не тот конструктор");
CollectionAssert.AreEqual(expectedPermutation, constructor.ParametersInfo);
}
public void TestManyTypes()
{
ContainerConstructorInfo constructor = constructorSelector.GetConstructor(typeof(C2),
new[]
{
typeof(string),
typeof(int)
});
CheckConstructor <C2>(new[] { typeof(int), typeof(I2), typeof(string) }, constructor, new[] { 1, -1, 0 });
}
public void TestSimple()
{
var constructorSelectorMock = GetMock <IConstructorSelector>();
var classCreatorMock = GetMock <IClassCreator>();
var classFactoryMock = GetMock <IClassFactory>();
var parameterTypes = new[] { typeof(long) };
var containerConstructorInfo = new ContainerConstructorInfo();
constructorSelectorMock.Setup(cs => cs.GetConstructor(typeof(int), parameterTypes)).Returns(containerConstructorInfo);
classCreatorMock.Setup(creator => creator.BuildFactory(containerConstructorInfo, null)).Returns(classFactoryMock.Object);
var creationContext = new CreationContext(classCreatorMock.Object, constructorSelectorMock.Object, null);
Assert.AreSame(classFactoryMock.Object, creationContext.BuildFactory(typeof(int), parameterTypes));
}
public void TestCrashWhenValueObjectIsNull()
{
var objects = new object[] { null };
var factoryConstructorInfo = new ContainerConstructorInfo
{
ConstructorInfo =
typeof(C3).GetConstructor(new[]
{
typeof(int)
}),
ParametersInfo = new[] { 0 }
};
Func <IInternalContainer, IInjectionContext, object[], object> @delegate =
classCreator.BuildConstructionDelegate(factoryConstructorInfo, null);
RunMethodWithException <ArgumentException>(() => @delegate(internalContainer, context, objects), "bad parameter");
}
public void TestCrashWhenValueObjectIsNull()
{
var objects = new object[] { null };
var factoryConstructorInfo = new ContainerConstructorInfo
{
ConstructorInfo =
typeof(C3).GetConstructor(new[]
{
typeof(int)
}),
ParametersInfo = new[] { 0 }
};
context.Expect(c => c.BeginConstruct(typeof(C3)));
context.Expect(c => c.EndConstruct(typeof(C3)));
context.Expect(x => x.Crash());
IClassFactory classFactory = classCreator.BuildFactory(factoryConstructorInfo, null);
RunMethodWithException <ArgumentException>(() => classFactory.Create(context, objects), "bad parameter");
}
