public void CannotInsertOneNameTwice()
{
var store = new ComponentStore();
var name = "test";
store.Add<IService, ClassWithNoDependencies>(name);
Assert.Throws<NameAlreadyRegisteredException>(() => store.Add<IService, ClassWithNoDependencies>(name));
}
public void CanInsertServiceTwice()
{
var store = new ComponentStore();
store.Add<IService, ClassWithNoDependencies>();
Assert.DoesNotThrow(() => store.Add<IService, ClassWithNoDependencies>());
}
public void CanSplitGraph()
{
/*
* Dotty Graph:
*
* digraph G {
* a [label="IService :: A"] ;
* a -> b [label="service1"] ;
* a -> c [label="service2"] ;
* b [label="IService :: B"] ;
* b -> d ;
* d [label="IService :: C"] ;
* c [label="IService :: B"] ;
* c -> f ;
* f [label="IService :: C"] ;
* }
*/
var store = new ComponentStore();
store.Add <IService, ClassWithTwoDependenciesOnItsOwnService>();
store.Add <IService, ClassWithDependencyOnItsOwnService>();
store.Add <IService, ClassWithNoDependencies>();
var container = new PandoraContainer(store);
var service = container.Resolve <IService>();
Assert.IsType(typeof(ClassWithTwoDependenciesOnItsOwnService), service);
}
public void CanInsertServiceTwice()
{
var store = new ComponentStore();
store.Add <IService, ClassWithNoDependencies>();
Assert.DoesNotThrow(() => store.Add <IService, ClassWithNoDependencies>());
}
public void CanInsertServiceTwice()
{
var store = new ComponentStore();
store.Add <IService, ClassWithNoDependencies>();
store.Add <IService, ClassWithNoDependencies>();
}
public void CannotInsertOneNameTwice()
{
var store = new ComponentStore();
var name = "test";
store.Add <IService, ClassWithNoDependencies>(name);
Assert.Throws <NameAlreadyRegisteredException>(() => store.Add <IService, ClassWithNoDependencies>(name));
}
public void CanResolveClassWithOneDependency()
{
IComponentStore componentStore = new ComponentStore();
componentStore.Add<IService, ClassWithNoDependencies>();
componentStore.Add<IService2, ClassWithOneDependency>();
PandoraContainer locator = new PandoraContainer(componentStore);
var result = locator.Resolve<IService2>();
Assert.IsType<ClassWithOneDependency>(result);
}
public void CanResolveClassWithTwoDependenciesOnItsOwnServiceWithOnlyOneSubdependencyRegistration()
{
var store = new ComponentStore();
store.Add<IService, ClassWithTwoDependenciesOnItsOwnService>();
store.Add<IService, ClassWithNoDependencies>();
var container = new PandoraContainer(store);
var service = container.Resolve<IService>();
Assert.IsType(typeof (ClassWithTwoDependenciesOnItsOwnService), service);
}
public void CanRetrieveServiceByName()
{
var store = new ComponentStore();
//This registration is to give the container something to choose from, in case named lookup won't work
store.Add<IService, ClassWithDependencyOnItsOwnService>("memory.repository");
store.Add<IService, ClassWithNoDependencies>("db.repository");
var container = new PandoraContainer(store);
var service = container.Resolve<IService>("db.repository");
Assert.IsType<ClassWithNoDependencies>(service);
}
public void DependencyMissingExceptionPropagatesThroughMultipleLevels()
{
var store = new ComponentStore();
store.Add <IService3, ClassDependingOnClassWithOneDependency>();
store.Add <IService2, ClassWithOneDependency>();
var container = new PandoraContainer(store);
Assert.Throws <DependencyMissingException>(() => container.Resolve <IService3>());
}
public void ReturnsAllServicesForGivenType()
{
var store = new ComponentStore();
store.Add<IService, ClassWithNoDependencies>("test1");
store.Add<IService, ClassWithDependencyOnItsOwnService>();
store.Add<IService2, ClassWithOneDependency>();
var container = new PandoraContainer(store);
var enumerable = container.ResolveAll<IService>();
Assert.Equal(2, enumerable.Count());
}
public void CanResolveClassWithOneDependency()
{
IComponentStore componentStore = new ComponentStore();
componentStore.Add <IService, ClassWithNoDependencies>();
componentStore.Add <IService2, ClassWithOneDependency>();
PandoraContainer locator = new PandoraContainer(componentStore);
var result = locator.Resolve <IService2>();
Assert.IsType <ClassWithOneDependency>(result);
}
public void CanResolveClassWithMultipleDependencies()
{
var store = new ComponentStore();
store.Add<IService, ClassWithNoDependencies>();
store.Add<IService2, ClassWithOneDependency>();
store.Add<IService3, ClassDependingOnClassWithOneDependency>();
var container = new PandoraContainer(store);
var result = container.Resolve<IService3>();
Assert.IsType<ClassDependingOnClassWithOneDependency>(result);
}
public void CanResolveClassWithMultipleDependencies()
{
var store = new ComponentStore();
store.Add <IService, ClassWithNoDependencies>();
store.Add <IService2, ClassWithOneDependency>();
store.Add <IService3, ClassDependingOnClassWithOneDependency>();
var container = new PandoraContainer(store);
var result = container.Resolve <IService3>();
Assert.IsType <ClassDependingOnClassWithOneDependency>(result);
}
public void CanRetrieveServiceByName()
{
var store = new ComponentStore();
//This registration is to give the container something to choose from, in case named lookup won't work
store.Add <IService, ClassWithDependencyOnItsOwnService>("memory.repository");
store.Add <IService, ClassWithNoDependencies>("db.repository");
var container = new PandoraContainer(store);
var service = container.Resolve <IService>("db.repository");
Assert.IsType <ClassWithNoDependencies>(service);
}
public void CanSpecifyDependencyByName()
{
var store = new ComponentStore();
store.Add<IService, ClassWithNoDependencies>("service1");
store.Add<IService, ClassWithNoDependencies2>("service2");
store.Add<ClassWithOneDependency, ClassWithOneDependency>()
.Parameters["dependency"] = "service2";
var container = new PandoraContainer(store);
var service2 = container.Resolve<ClassWithOneDependency>();
Assert.IsType<ClassWithNoDependencies2>(service2.Dependency);
}
public void ReturnsAllServicesForGivenType()
{
var store = new ComponentStore();
store.Add <IService, ClassWithNoDependencies>("test1");
store.Add <IService, ClassWithDependencyOnItsOwnService>();
store.Add <IService2, ClassWithOneDependency>();
var container = new PandoraContainer(store);
var enumerable = container.ResolveAll <IService>();
Assert.Equal(2, enumerable.Count());
}
public void CanResolveClassWithTwoDependenciesOnItsOwnServiceWithOnlyOneSubdependencyRegistration()
{
var store = new ComponentStore();
store.Add <IService, ClassWithTwoDependenciesOnItsOwnService>();
store.Add <IService, ClassWithNoDependencies>();
var container = new PandoraContainer(store);
var service = container.Resolve <IService>();
Assert.IsType(typeof(ClassWithTwoDependenciesOnItsOwnService), service);
}
public void CanSpecifyDependencyByName()
{
var store = new ComponentStore();
store.Add <IService, ClassWithNoDependencies>("service1");
store.Add <IService, ClassWithNoDependencies2>("service2");
store.Add <ClassWithOneDependency, ClassWithOneDependency>()
.Parameters["dependency"] = "service2";
var container = new PandoraContainer(store);
var service2 = container.Resolve <ClassWithOneDependency>();
Assert.IsType <ClassWithNoDependencies2>(service2.Dependency);
}
public void CanResolveDependencyChainOfSameService()
{
var store = new ComponentStore();
store.Add <IService, ClassWithDependencyOnItsOwnService>();
store.Add <IService, ClassWithNoDependencies>();
var container = new PandoraContainer(store);
var service = container.Resolve <IService>();
Assert.IsType(typeof(ClassWithDependencyOnItsOwnService), service);
var ownService = (ClassWithDependencyOnItsOwnService)service;
Assert.IsType(typeof(ClassWithNoDependencies), ownService.SubService);
}
public void CanResolveConcreteType()
{
var store = new ComponentStore();
store.Add<ClassWithNoDependencies, ClassWithNoDependencies>();
var container = new PandoraContainer(store);
Assert.DoesNotThrow(() => container.Resolve<ClassWithNoDependencies>());
}
public void ThrowsExceptionIfDependencyCouldNotBeSatisfied()
{
var store = new ComponentStore();
store.Add <ClassWithOneDependency, ClassWithOneDependency>();
var container = new PandoraContainer(store);
Assert.Throws <DependencyMissingException>(() => container.Resolve <ClassWithOneDependency>());
}
public void CanResolveConcreteType()
{
var store = new ComponentStore();
store.Add <ClassWithNoDependencies, ClassWithNoDependencies>();
var container = new PandoraContainer(store);
container.Resolve <ClassWithNoDependencies>();
}
public void CanResolveWhenGivenTwoConstructorsWhereOneCantBeSatisfied()
{
var store = new ComponentStore();
store.Add <IService4, ClassWithMultipleConstructors>();
var container = new PandoraContainer(store);
container.Resolve <IService4>();
}
public void CanInsertRegistration()
{
var store = new ComponentStore();
store.Add <IService, ClassWithNoDependencies>();
var registration = store.GetRegistrationsForService <IService>()[0];
Assert.Equal(registration.Implementor, typeof(ClassWithNoDependencies));
}
public void ExcludesServicesThatCantBeCreated()
{
var store = new ComponentStore();
store.Add<IService, ClassWithDependencyOnItsOwnService>();
var container = new PandoraContainer(store);
var enumerable = container.ResolveAll<IService>();
Assert.Equal(0, enumerable.Count());
}
public void CanResolveClassWithoutDependencies()
{
var componentStore = new ComponentStore();
componentStore.Add<IService, ClassWithNoDependencies>();
var container = new PandoraContainer(componentStore);
var result = container.Resolve<IService>();
Assert.IsType<ClassWithNoDependencies>(result);
}
public void ThrowsDependencyMissingExceptionIfDependencyChainCannotBeSatisfied()
{
var store = new ComponentStore();
store.Add <IService, ClassWithDependencyOnItsOwnService>();
var container = new PandoraContainer(store);
Assert.Throws <DependencyMissingException>(() => container.Resolve <IService>());
}
public void ExcludesServicesThatCantBeCreated()
{
var store = new ComponentStore();
store.Add <IService, ClassWithDependencyOnItsOwnService>();
var container = new PandoraContainer(store);
var enumerable = container.ResolveAll <IService>();
Assert.Equal(0, enumerable.Count());
}
public void CanResolveDependencyChainOfSameServiceWithMultipleLevels()
{
var store = new ComponentStore();
store.Add <IService, ClassWithDependencyOnItsOwnService>();
store.Add <IService, ClassWithDependencyOnItsOwnService>();
store.Add <IService, ClassWithNoDependencies>();
var container = new PandoraContainer(store);
var service = container.Resolve <IService>();
var level1 = (ClassWithDependencyOnItsOwnService)service;
var level2 = (ClassWithDependencyOnItsOwnService)level1.SubService;
var level3 = (ClassWithNoDependencies)level2.SubService;
Assert.IsType(typeof(ClassWithDependencyOnItsOwnService), level1);
Assert.IsType(typeof(ClassWithDependencyOnItsOwnService), level2);
Assert.IsType(typeof(ClassWithNoDependencies), level3);
}
public void CanInsertRegistration()
{
var store = new ComponentStore();
Assert.DoesNotThrow(() =>
store.Add<IService, ClassWithNoDependencies>()
);
var registration = store.GetRegistrationsForService<IService>()[0];
Assert.Equal(registration.Implementor, typeof(ClassWithNoDependencies));
}
public void CanResolveClassWithoutDependencies()
{
var componentStore = new ComponentStore();
componentStore.Add <IService, ClassWithNoDependencies>();
var container = new PandoraContainer(componentStore);
var result = container.Resolve <IService>();
Assert.IsType <ClassWithNoDependencies>(result);
}
public void ActivationHappensEveryTime()
{
var store = new ComponentStore();
var registration = store.Add<IService, ClassWithNoDependencies>();
registration.Lifestyle = ComponentLifestyles.Transient;
var container = new PandoraContainer(store);
var service = container.Resolve<IService>();
var service2 = container.Resolve<IService>();
Assert.NotSame(service, service2);
}
public void ActivationHappensEveryTime()
{
var store = new ComponentStore();
var registration = store.Add<IService, ClassWithNoDependencies>();
registration.Lifestyle = ComponentLifestyles.Transient;
var container = new PandoraContainer(store);
var service = container.Resolve<IService>();
var service2 = container.Resolve<IService>();
Assert.NotSame(service, service2);
}
public void Update(GameTime gameTime)
{
var asteroids = _components.GetAllOfType <Asteroid>();
foreach (var asteroid in asteroids)
{
if (asteroid.Destroyed)
{
if (asteroid.Size == 5)
{
_components.Add(new Asteroid(asteroid.Texture, Asteroid.AsteroidSize.Medium, asteroid.Position));
_components.Add(new Asteroid(asteroid.Texture, Asteroid.AsteroidSize.Medium, asteroid.Position));
_components.Add(new Asteroid(asteroid.Texture, Asteroid.AsteroidSize.Medium, asteroid.Position));
}
else if (asteroid.Size == 3)
{
_components.Add(new Asteroid(asteroid.Texture, Asteroid.AsteroidSize.Small, asteroid.Position));
_components.Add(new Asteroid(asteroid.Texture, Asteroid.AsteroidSize.Small, asteroid.Position));
_components.Add(new Asteroid(asteroid.Texture, Asteroid.AsteroidSize.Small, asteroid.Position));
}
_components.Remove <Asteroid>(asteroid);
}
}
}
public void ActivationHappensOnlyOnceForSingletonComponents()
{
var store = new ComponentStore();
var registration = store.Add <IService, ClassWithNoDependencies>("test");
registration.Lifestyle = ComponentLifestyles.Singleton;
var container = new PandoraContainer(store);
var service = container.Resolve <IService>("test");
var service2 = container.Resolve <IService>("test");
Assert.Same(service, service2);
}
public void Fire()
{
var fireball = _components.GetSingleOrDefault <Fireball>();
if (fireball == null)
{
var ship = _components.GetSingle <Ship>();
_components.Add(new Fireball(_gameScreen.Textures["Fireball"], ship.Position, ship.Direction, ship.Rotation));
}
else
// fireball.Update(gameTime);
if (fireball.Destroyed)
{
_components.Remove <Fireball>(fireball);
}
}
public void CannotInsertInterfaceAsImplementor()
{
var store = new ComponentStore();
Assert.Throws <RegistrationException>(() => store.Add <IService, IService>());
}
public void CannotInsertInterfaceAsImplementor()
{
var store = new ComponentStore();
Assert.Throws<RegistrationException>(() => store.Add<IService, IService>());
}
public void CanResolveDependencyChainOfSameServiceWithMultipleLevels()
{
var store = new ComponentStore();
store.Add<IService, ClassWithDependencyOnItsOwnService>();
store.Add<IService, ClassWithDependencyOnItsOwnService>();
store.Add<IService, ClassWithNoDependencies>();
var container = new PandoraContainer(store);
var service = container.Resolve<IService>();
var level1 = (ClassWithDependencyOnItsOwnService) service;
var level2 = (ClassWithDependencyOnItsOwnService) level1.SubService;
var level3 = (ClassWithNoDependencies)level2.SubService;
Assert.IsType(typeof (ClassWithDependencyOnItsOwnService), level1);
Assert.IsType(typeof(ClassWithDependencyOnItsOwnService), level2);
Assert.IsType(typeof(ClassWithNoDependencies), level3);
}
public void CanResolveWhenGivenTwoConstructorsWhereOneCantBeSatisfied()
{
var store = new ComponentStore();
store.Add<IService4, ClassWithMultipleConstructors>();
var container = new PandoraContainer(store);
Assert.DoesNotThrow(() => container.Resolve<IService4>());
}
public void CanSplitGraph()
{
/*
* Dotty Graph:
*
digraph G {
a [label="IService :: A"] ;
a -> b [label="service1"] ;
a -> c [label="service2"] ;
b [label="IService :: B"] ;
b -> d ;
d [label="IService :: C"] ;
c [label="IService :: B"] ;
c -> f ;
f [label="IService :: C"] ;
}
*/
var store = new ComponentStore();
store.Add<IService, ClassWithTwoDependenciesOnItsOwnService>();
store.Add<IService, ClassWithDependencyOnItsOwnService>();
store.Add<IService, ClassWithNoDependencies>();
var container = new PandoraContainer(store);
var service = container.Resolve<IService>();
Assert.IsType(typeof (ClassWithTwoDependenciesOnItsOwnService), service);
}
public void DependencyMissingExceptionPropagatesThroughMultipleLevels()
{
var store = new ComponentStore();
store.Add<IService3, ClassDependingOnClassWithOneDependency>();
store.Add<IService2, ClassWithOneDependency>();
var container = new PandoraContainer(store);
Assert.Throws<DependencyMissingException>(() => container.Resolve<IService3>());
}
public void ThrowsDependencyMissingExceptionIfDependencyChainCannotBeSatisfied()
{
var store = new ComponentStore();
store.Add<IService, ClassWithDependencyOnItsOwnService>();
var container = new PandoraContainer(store);
Assert.Throws<DependencyMissingException>(() => container.Resolve<IService>());
}
public void ThrowsExceptionIfDependencyCouldNotBeSatisfied()
{
var store = new ComponentStore();
store.Add<ClassWithOneDependency, ClassWithOneDependency>();
var container = new PandoraContainer(store);
Assert.Throws<DependencyMissingException>(() => container.Resolve<ClassWithOneDependency>());
}
public void CanResolveDependencyChainOfSameService()
{
var store = new ComponentStore();
store.Add<IService, ClassWithDependencyOnItsOwnService>();
store.Add<IService, ClassWithNoDependencies>();
var container = new PandoraContainer(store);
var service = container.Resolve<IService>();
Assert.IsType(typeof (ClassWithDependencyOnItsOwnService), service);
var ownService = (ClassWithDependencyOnItsOwnService)service;
Assert.IsType(typeof (ClassWithNoDependencies), ownService.SubService);
}