public void Can_build_product()
{
var factory = new ConstructorFactory<Rabbit>(() => { return new Rabbit(); });
var product = factory.Create();
Assert.NotNull(product);
Assert.IsType<Rabbit>(product);
}
public void Accepts_custom_action()
{
var factory = new ConstructorFactory<Rabbit>(() => { return new Rabbit { Age = 3 }; });
var product = factory.Create(x => x.Name = "Fluffy");
Assert.Equal(3, product.Age);
Assert.Equal("Fluffy", product.Name);
}
public void Should_work()
{
Factory<MyClass> factory = new ConstructorFactory<MyClass>(() => new MyClass());
MyClass subject = factory.Get();
Assert.IsNotNull(subject);
}
public void Can_handle_null_custom_action()
{
var factory = new ConstructorFactory<Rabbit>(() => { return new Rabbit(); });
Rabbit product = null;
Assert.DoesNotThrow(() =>
{
product = factory.Create(null);
});
Assert.NotNull(product);
}
public void Should_narrow_the_factory_width()
{
var factory = new ConstructorFactory<MyClass, MyDependency>(x => new MyClass(x));
var dependencyFactory = new ConstructorFactory<MyDependency>(() => new MyDependency());
var curryFactory = new PartialFactory<MyClass, MyDependency>(factory, dependencyFactory);
MyClass subject = curryFactory.Get();
Assert.IsNotNull(subject);
Assert.IsNotNull(subject.Dependency);
}
public ParentObject Get()
{
if (_factory == null)
{
var other = new ConstructorFactory<DependentObject>(() => new DependentObject());
var factory1 = new ConstructorFactory<ParentObject, DependentObject>(x => new ParentObject(x));
_factory = new PartialFactory<ParentObject, DependentObject>(factory1, other);
}
var factory = (ServiceBook.Factory<ParentObject>)_factory;
return factory.Get();
}
public void TestConstructorFactorySingleToneByThread()
{
if (!ConstructorFactory.SetSingleToneByThread <Tuple <string> >(new object[] { "hello factory" }))
{
Assert.Fail("set singletone constructor not work");
}
if (!DataFactory.SetSingleToneByThread <Tuple <string> >())
{
Assert.Fail("set singletone not work");
}
var takeData = DataFactory.GetSingleToneByThread <Tuple <string> >();
Assert.IsTrue(takeData.Item1 == "hello factory");
}
public void Should_use_the_provider_factory()
{
var testContainer = new TestContainer();
var convention = new ConcreteTypeRegistrationConvention();
RegistrationCatalog catalog = new ContainerRegistrationCatalog(convention, testContainer);
var factory = new ConstructorFactory<ISomething>(() => new Something());
Registration registration = new ClosedTypeRegistration<ISomething>(factory);
var registrationFactory = new ClosedTypeRegistrationFactory<ISomething>(() => factory);
catalog.AddRegistration(registrationFactory);
RegistrationFactory[] dependencies = catalog.Registrations.ToArray();
Assert.AreEqual(new[] {typeof(ISomething)}, dependencies.Select(x => x.RegistrationType));
}
public void NullablePrimitiveCollection()
{
//DateTime is not managed
var nullableTypes = new Type[]
{
// typeof( bool? ),//Bool flattens value to 0 or 1 so hashset differ too much. change the verifier to take care of conversions
typeof(char?),
typeof(sbyte?),
typeof(byte?),
typeof(int?),
typeof(uint?),
typeof(int?),
typeof(uint?),
typeof(int?),
typeof(uint?),
typeof(float?),
typeof(double?),
typeof(decimal? ),
//typeof( string )
};
foreach (var sourceElementType in nullableTypes)
{
foreach (var targetElementType in nullableTypes)
{
if (sourceElementType == typeof(char?) &&
targetElementType == typeof(bool?))
{
continue;
}
if (sourceElementType == typeof(bool?) &&
targetElementType == typeof(char?))
{
continue;
}
//for the following pairs a conversion is known
//to be harder (not possible or convention-based),
//so here we just skip that few cases
if (sourceElementType == typeof(bool?) &&
targetElementType == typeof(string))
{
continue;
}
if (sourceElementType == typeof(string) &&
targetElementType == typeof(bool?))
{
continue;
}
var sourceType = typeof(GenericCollections <>)
.MakeGenericType(sourceElementType);
var targetType = typeof(GenericCollections <>)
.MakeGenericType(targetElementType);
var sourceTypeCtor = ConstructorFactory.CreateConstructor <bool, uint, uint>(sourceType);
var targetTypeCtor = ConstructorFactory.CreateConstructor <bool, uint, uint>(targetType);
var source = sourceTypeCtor(true, 0, 10);
var target = targetTypeCtor(true, 0, 10);
var ultraMapper = new Mapper();
ultraMapper.Map(source, target);
bool isResultOk = ultraMapper.VerifyMapperResult(source, target);
Assert.IsTrue(isResultOk);
}
}
}
public void PrimitiveCollection()
{
var excludeTypes = new TypeCode[]
{
TypeCode.Empty,
TypeCode.DBNull,
TypeCode.DateTime, //DateTime is not managed
TypeCode.Object,
TypeCode.Boolean, //Bool flattens value to 0 or 1 so hashset differ too much. change the verifier to take care of conversions
};
var types = Enum.GetValues(typeof(TypeCode)).Cast <TypeCode>()
.Except(excludeTypes)
.Select(typeCode => TypeExtensions.GetType(typeCode)).ToList();
foreach (var sourceElementType in types)
{
foreach (var targetElementType in types)
{
//for the following pairs a conversion is known
//to be harder (not possible or convention-based),
//so here we just skip that few cases
if (sourceElementType == typeof(string) &&
targetElementType == typeof(bool))
{
continue;
}
if (sourceElementType == typeof(char) &&
targetElementType == typeof(bool))
{
continue;
}
if (sourceElementType == typeof(bool) &&
targetElementType == typeof(char))
{
continue;
}
var sourceType = typeof(GenericCollections <>)
.MakeGenericType(sourceElementType);
var targetType = typeof(GenericCollections <>)
.MakeGenericType(targetElementType);
var sourceTypeCtor = ConstructorFactory.CreateConstructor <bool, uint, uint>(sourceType);
var targetTypeCtor = ConstructorFactory.CreateConstructor <bool, uint, uint>(targetType);
var source = sourceTypeCtor(true, 0, 10);
var target = targetTypeCtor(false, 0, 10);
var ultraMapper = new Mapper();
ultraMapper.Map(source, target);
bool isResultOk = ultraMapper.VerifyMapperResult(source, target);
Assert.IsTrue(isResultOk);
}
}
}
public void SetUp()
{
_factory = new ConstructorFactory();
_mutableType = MutableTypeObjectMother.Create();
}
