public void CoreTestMapList() { var source = VerySimpleClass.CreateMany(5); var MyDTO = Mapper.Map <IEnumerable <VerySimpleClass>, IEnumerable <DTO.VerySimpleClass> >(source); var manual = source.Select(x => new DTO.VerySimpleClass(x)).ToArray(); Assert.True(MyDTO.EnumerableEquals(manual)); }
public void ShouldNotAttemptToReleaseANonDisposableFactory() { // given var container = new ObjectContainer(); var dependency = new VerySimpleClass(); container.RegisterFactoryAs <IInterface1>(() => new VerySimpleClass()); var obj = container.Resolve <IInterface1>(); // when container.Dispose(); }
public void ShouldResolveRegisteredInstance() { // given var instance = new VerySimpleClass(); var container = new ObjectContainer(); container.RegisterInstanceAs <IInterface1>(instance); // when var obj = container.Resolve <IInterface1>(); // then Assert.AreSame(instance, obj); }
public void ShouldBeAbleToRegisterAFactoryDelegateWithDependencyToTheContainer() { // given var container = new ObjectContainer(); var dependency = new VerySimpleClass(); container.RegisterInstanceAs<IInterface1>(dependency); container.RegisterFactoryAs<IInterface3>(c => new ClassWithSimpleDependency(c.Resolve<IInterface1>())); // when var obj = container.Resolve<IInterface3>(); // then Assert.IsNotNull(obj); Assert.IsInstanceOf(typeof(ClassWithSimpleDependency), obj); Assert.AreSame(dependency, ((ClassWithSimpleDependency)obj).Dependency); }
public void ShouldNotAttemptToDisposeFactoryMoreThanOnce() { // given var container = new ObjectContainer(); var dependency = new VerySimpleClass(); var instance = new OneTimeDisposableClass1(); container.RegisterFactoryAs <IDisposableClass>(() => instance, dispose: true); var obj = container.Resolve <IDisposableClass>(); obj = container.Resolve <IDisposableClass>(); // when container.Dispose(); // then obj.WasDisposed.ShouldBeTrue(); }
public void ShouldBeAbleToRegisterAFactoryDelegateWithDependencyToTheContainer() { // given var container = new ObjectContainer(); var dependency = new VerySimpleClass(); container.RegisterInstanceAs <IInterface1>(dependency); container.RegisterFactoryAs <IInterface3>(c => new ClassWithSimpleDependency(c.Resolve <IInterface1>())); // when var obj = container.Resolve <IInterface3>(); // then Assert.IsNotNull(obj); Assert.IsInstanceOf(typeof(ClassWithSimpleDependency), obj); Assert.AreSame(dependency, ((ClassWithSimpleDependency)obj).Dependency); }
public void ShouldResolveClassWithSimpleDependency() { // given var dependency = new VerySimpleClass(); var container = new ObjectContainer(); container.RegisterTypeAs <ClassWithSimpleDependency, IInterface3>(); container.RegisterInstanceAs <IInterface1>(dependency); // when var obj = container.Resolve <IInterface3>(); // then Assert.IsNotNull(obj); Assert.IsInstanceOf(typeof(ClassWithSimpleDependency), obj); Assert.AreSame(dependency, ((ClassWithSimpleDependency)obj).Dependency); }
static void Main(string[] args) { Init.InitHMapper(); Init.InitAutomapper(); Init.InitExpressMapper(); var test = AutoMapper.Mapper.Map <PolymorphicSubClass, DTO.PolymorphicSubClass>(PolymorphicSubClass.Create(5)); Run("Very simple class", VerySimpleClass.CreateMany(300000), x => new DTO.VerySimpleClass(x)); Run("Simple class", SimpleClass.CreateMany(40000), x => new DTO.SimpleClass(x)); Run("Simple set", SimpleSet.CreateMany(10000, 100), x => new DTO.SimpleSet(x)); Run("Multiple set", MultipleSets.CreateMany(1000, 100), x => new DTO.MultipleSets(x)); Run("Dictionary", DictionarySet.CreateMany(300, 100), x => new DTO.DictionarySet(x)); Run("Simple generic class of int", SimpleGeneric <int> .CreateMany(Enumerable.Range(1, 300000).Select(i => i).ToArray()), x => new DTO.SimpleGeneric <int>(x)); Run("Mapped object generic class", MappedObjectGeneric <VerySimpleClass> .CreateMany(VerySimpleClass.CreateMany(200000)), x => new DTO.MappedObjectGeneric <DTO.VerySimpleClass>(x)); Run("Multiple generic class", MultipleGenerics <int, string> .CreateMany(Enumerable.Range(1, 200000).Select(i => Tuple.Create(i, Guid.NewGuid().ToString())).ToArray()), x => new DTO.MultipleGenerics <string, int>(x)); Run("Polymorphic class", PolymorphicSubSubClass.CreateMany(300000), x => new DTO.PolymorphicSubClass(x)); Run("Set of polymorphic class", SetOfPolymorphic.CreateMany(150000), x => new DTO.SetOfPolymorphic(x)); Run("Generic of polymorphic class", MappedObjectGeneric <PolymorphicBaseClass> .CreateMany(PolymorphicBaseClass.CreateMany(200000)), x => new DTO.MappedObjectGeneric <DTO.PolymorphicBaseClass>(x)); Run("Set of generic polymorphic classes", SetOfGenericPolymorph.CreateMany(50000), x => new DTO.SetOfGenericPolymorph(x)); }
public MyStructWithDependencies(VerySimpleClass dep) { }
public void CoreTestMappedObjectGeneric() { Run(MappedObjectGeneric <VerySimpleClass> .Create(1, VerySimpleClass.Create()), x => new DTO.MappedObjectGeneric <DTO.VerySimpleClass>(x)); }
public void CoreTestVerySimpleObject() { Run(VerySimpleClass.Create(), x => new DTO.VerySimpleClass(x)); }
public Interface1DependingOnAnotherImplementation(VerySimpleClass other) // VerySimpleClass also implements IInterface1 { Other = other; }
public void ShouldResolveRegisteredInstance() { // given var instance = new VerySimpleClass(); var container = new ObjectContainer(); container.RegisterInstanceAs<IInterface1>(instance); // when var obj = container.Resolve<IInterface1>(); // then Assert.AreSame(instance, obj); }
public void ShouldResolveClassWithSimpleDependency() { // given var dependency = new VerySimpleClass(); var container = new ObjectContainer(); container.RegisterTypeAs<ClassWithSimpleDependency, IInterface3>(); container.RegisterInstanceAs<IInterface1>(dependency); // when var obj = container.Resolve<IInterface3>(); // then Assert.IsNotNull(obj); Assert.IsInstanceOf(typeof(ClassWithSimpleDependency), obj); Assert.AreSame(dependency, ((ClassWithSimpleDependency)obj).Dependency); }