public void TestInNamespace()
{
Container.Bind <IFoo>()
.To(x => x.AllTypes().DerivingFrom <IFoo>().InNamespace("UniDi.Tests.Convention.NamespaceTest")).AsTransient();
Assert.IsEqual(Container.ResolveAll <IFoo>().Count(), 1);
}
public void TestAttributeWhereFilter()
{
Container.Bind <IFoo>()
.To(x => x.AllTypes().WithAttributeWhere <ConventionTestAttribute>(a => a.Num == 1)).AsTransient();
Assert.IsEqual(Container.ResolveAll <IFoo>().Count(), 1);
}
public void TestMatchAll()
{
// Should automatically filter by contract types
Container.Bind <IFoo>().To(x => x.AllNonAbstractClasses()).AsTransient();
Assert.IsEqual(Container.ResolveAll <IFoo>().Count(), 4);
}
public void TestDerivingFrom2()
{
Container.Bind <IFoo>()
.To(x => x.AllTypes().DerivingFrom <IFoo>()).AsTransient();
Assert.IsEqual(Container.ResolveAll <IFoo>().Count(), 4);
}
static List <Type> GetDependencies(
DiContainer container, Type type)
{
var dependencies = new List <Type>();
foreach (var contractType in container.GetDependencyContracts(type))
{
List <Type> dependTypes;
if (contractType.FullName.StartsWith("System.Collections.Generic.List"))
{
var subTypes = contractType.GenericArguments();
Assert.IsEqual(subTypes.Length, 1);
var subType = subTypes[0];
dependTypes = container.ResolveTypeAll(subType);
}
else
{
dependTypes = container.ResolveTypeAll(contractType);
Assert.That(dependTypes.Count <= 1);
}
foreach (var dependType in dependTypes)
{
dependencies.Add(dependType);
}
}
return(dependencies);
}
public void Test3()
{
FooFactory.InstanceCount = 0;
Container.Bind <Foo>().FromIFactory(b => b.To <FooFactory>().AsTransient()).AsCached();
Container.Resolve <Foo>();
Container.Resolve <Foo>();
Container.Resolve <Foo>();
Assert.IsEqual(FooFactory.InstanceCount, 1);
}
public void TestConcreteSingle()
{
FooFactory.InstanceCount = 0;
Container.Bind <IFoo>().To <Foo>().FromIFactory(b => b.To <FooFactory>().AsCached()).AsSingle().NonLazy();
Assert.IsEqual(Container.Resolve <IFoo>(), StaticFoo);
Container.Resolve <IFoo>();
Container.Resolve <IFoo>();
Container.Resolve <IFoo>();
Assert.IsEqual(FooFactory.InstanceCount, 1);
}
public void TestOldVersion()
{
FooFactory.InstanceCount = 0;
Container.Bind <Foo>().FromFactory <FooFactory>();
Assert.IsEqual(Container.Resolve <Foo>(), StaticFoo);
Container.Resolve <Foo>();
Container.Resolve <Foo>();
Container.Resolve <Foo>();
Assert.IsEqual(FooFactory.InstanceCount, 1);
}
public void Test1()
{
FooFactory.InstanceCount = 0;
Container.Bind <Foo>().FromIFactory(b => b.To <FooFactory>().AsCached());
Assert.IsEqual(Container.Resolve <Foo>(), StaticFoo);
Container.Resolve <Foo>();
Container.Resolve <Foo>();
Container.Resolve <Foo>();
Assert.IsEqual(FooFactory.InstanceCount, 1);
}
public void Test1()
{
ReflectionTypeAnalyzer.AddCustomInjectAttribute(typeof(InjectCustomAttribute));
Container.Bind <Bar>().AsSingle();
Container.Bind <Foo>().AsSingle();
var foo = Container.Resolve <Foo>();
var bar = Container.Resolve <Bar>();
Assert.IsEqual(foo.BarProperty, bar);
Assert.IsEqual(foo.BarField, bar);
Assert.IsEqual(foo.BarMethod, bar);
Assert.IsEqual(foo.BarParam, bar);
}
public static string ConvertFullAbsolutePathToAssetPath(string fullPath)
{
fullPath = Path.GetFullPath(fullPath);
var assetFolderFullPath = Path.GetFullPath(Application.dataPath);
if (fullPath.Length == assetFolderFullPath.Length)
{
Assert.IsEqual(fullPath, assetFolderFullPath);
return("Assets");
}
var assetPath = fullPath.Remove(0, assetFolderFullPath.Length + 1).Replace("\\", "/");
return("Assets/" + assetPath);
}
protected void PreInstall()
{
Assert.That(!_hasStartedInstall, "Called PreInstall twice in test '{0}'!", TestContext.CurrentContext.Test.Name);
_hasStartedInstall = true;
Assert.That(!ProjectContext.HasInstance);
var shouldValidate = CurrentTestHasAttribute <ValidateOnlyAttribute>();
ProjectContext.ValidateOnNextRun = shouldValidate;
Assert.That(_sceneContext == null);
_sceneContext = SceneContext.Create();
_sceneContext.Install();
Assert.That(ProjectContext.HasInstance);
Assert.IsEqual(shouldValidate, ProjectContext.Instance.Container.IsValidating);
Assert.IsEqual(shouldValidate, _sceneContext.Container.IsValidating);
}
public void TestMoveIntoSubcontainers()
{
FooFactory.InstanceCount = 0;
Container.Bind <Foo>().FromIFactory(b => b.To <FooFactory>().AsCached()).MoveIntoDirectSubContainers();
Assert.That(Container.AllContracts.Where(x => x.Type == typeof(IFactory <Foo>)).IsEmpty());
Assert.IsNull(Container.TryResolve <Foo>());
var subContainer = Container.CreateSubContainer();
Assert.IsEqual(subContainer.Resolve <Foo>(), StaticFoo);
Assert.That(subContainer.AllContracts.Where(x => x.Type == typeof(IFactory <Foo>)).Count() == 1);
subContainer.Resolve <Foo>();
subContainer.Resolve <Foo>();
subContainer.Resolve <Foo>();
Assert.IsEqual(FooFactory.InstanceCount, 1);
}
