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