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