public void TestBaseType()
{
_counter = 0;
var container = new CryoContainer();
container.RegisterType <MyBaseClass, MyClass>(CreateMyClass);
var a = container.Resolve <MyBaseClass>();
Assert.IsNotNull(a);
Assert.IsInstanceOf(typeof(MyClass), a);
Assert.AreEqual(1, ((MyClass)a).InstanceId);
Assert.AreEqual(1, _counter);
a = container.Resolve <MyBaseClass>();
Assert.IsNotNull(a);
Assert.IsInstanceOf(typeof(MyClass), a);
Assert.AreEqual(2, ((MyClass)a).InstanceId);
Assert.AreEqual(2, _counter);
a = container.Resolve <MyBaseClass>();
Assert.IsNotNull(a);
Assert.IsInstanceOf(typeof(MyClass), a);
Assert.AreEqual(3, ((MyClass)a).InstanceId);
Assert.AreEqual(3, _counter);
}
public void TestSingletonByName()
{
var container = new CryoContainer();
container.RegisterSingleton <MyClazz>("MyClazz");
Assert.IsNull(container.WeakResolveByName <MyClazz>("MyClazz"));
var clazz = container.ResolveByName <MyClazz>("MyClazz");
Assert.IsNotNull(clazz);
var clazz2 = container.WeakResolveByName <MyClazz>("MyClazz");
Assert.IsNotNull(clazz2);
Assert.AreSame(clazz, clazz2);
try
{
container.WeakResolve <MyClazz>();
Assert.Fail("Exception expected");
//ascxasxasxasx
}
catch (ContainerException)
{
return;
}
}
public object GetObject(object owner, CryoContainer container, params object[] parameters)
{
if (IsDestroyed())
{
_cached = FindObject();
if (_cached is CryoBehaviour cryoBehaviour)
{
if (!cryoBehaviour.BuiltUp)
{
cryoBehaviour.BuildUp();
}
}
else if (_cached is Component component)
{
var cryoBuilder = component.GetComponent <CryoBuilder>();
if (cryoBuilder != null && !cryoBuilder.BuiltUp)
{
cryoBuilder.BuildUp();
}
}
LifeTimeManager.TryToAdd(this, LifeTime);
}
return(_cached);
}
public object GetObject(object owner, CryoContainer container, params object[] parameters)
{
var component = FindComponentAt(owner);
if (component is CryoBehaviour cryoBehaviour)
{
if (!cryoBehaviour.BuiltUp)
{
cryoBehaviour.BuildUp();
}
}
else
{
var cryoBuilder = component.GetComponent <CryoBuilder>();
if (cryoBuilder != null && !cryoBuilder.BuiltUp)
{
cryoBuilder.BuildUp();
}
}
if (component is IDisposable disposable)
{
_lifeTimeManager.Add(disposable, LifeTime);
}
return(component);
}
public object WeakGetObject(CryoContainer container, params object[] unused)
{
if (_disposed)
{
return(null);
}
return(_instance);
}
public object GetObject(object owner, CryoContainer container, params object[] unused)
{
if (_disposed)
{
throw new ContainerException("Instance of type " + typeof(T) + " already disposed");
}
return(_instance);
}
public object GetObject(CryoContainer container, params object[] parameters)
{
var obj = _factoryMethod();
container.BuildUp(obj, parameters);
LifeTimeManager.TryToAdd(obj, LifeTime);
return(obj);
}
public void SelfReference()
{
var container = new CryoContainer {
CircularDependencyReaction = Reaction.LogWarning
};
container.RegisterSingleton <ClassC>();
container.Resolve <ClassC>();
}
public void OnSetup()
{
var container = new CryoContainer();
container.RegisterInstance(new Mock <IErrorMessageController>().Object);
container.RegisterSingleton <IPathfindingAlgorithm, AstarAlgorithm>();
_pathfindingAlgorithm = container.Resolve <IPathfindingAlgorithm>();
}
public object WeakGetObject(CryoContainer container, params object[] parameters)
{
if (_exist)
{
return(_instance);
}
return(null);
}
public void ExternalInGlobal()
{
var container = new CryoContainer {
LifetimeErrorReaction = Reaction.ThrowException
};
container.RegisterSingleton <MySingleton>(LifeTime.External);
container.RegisterType <MyInstance>(LifeTime.Global);
container.Resolve <MyInstance>();
}
public void SceneInExternal()
{
var container = new CryoContainer {
OnLifetimeError = Reaction.ThrowException
};
container.RegisterSingleton <MySingleton>(LifeTime.Scene);
container.RegisterType <MyInstance>(LifeTime.External);
container.Resolve <MyInstance>();
}
public object GetObject(CryoContainer container, params object[] parameters)
{
if (!_exist)
{
_instance = _factoryMethod();
_exist = true;
container.BuildUp(_instance, parameters);
LifeTimeManager.TryToAdd(this, LifeTime);
}
return(_instance);
}
public object GetObject(object owner, CryoContainer container, params object[] parameters)
{
var obj = _factoryMethod();
container.BuildUp(obj, parameters);
if (obj is IDisposable disposable)
{
_lifeTimeManager.Add(disposable, LifeTime);
}
return(obj);
}
public void TestType()
{
var container = new CryoContainer();
container.RegisterType <MyClazz>();
Assert.IsNull(container.TryResolve <MyClazz>());
var clazz = container.Resolve <MyClazz>();
Assert.IsNotNull(clazz);
Assert.IsNull(container.TryResolve <MyClazz>());
}
public void TestInstance()
{
var container = new CryoContainer();
var myClazz = new MyClazz();
container.RegisterInstance(myClazz);
var myClazz2 = container.TryResolve <MyClazz>();
Assert.IsNotNull(myClazz2);
Assert.AreSame(myClazz, myClazz2);
}
public void LongChain()
{
var container = new CryoContainer {
CircularDependencyReaction = Reaction.LogWarning
};
container.RegisterSingleton <Class1>();
container.RegisterSingleton <Class2>();
container.RegisterSingleton <Class3>();
container.RegisterSingleton <Class4>();
container.Resolve <Class2>();
}
public void TestSimplePropertiesBuildup()
{
var container = new CryoContainer();
container.RegisterInstance("private base", "PrivateBase");
container.RegisterInstance("protected base", "ProtectedBase");
container.RegisterInstance("public base", "PublicBase");
var a = new ClassBase();
container.BuildUp(a);
a.Check();
}
public void TestBuildUpSimilarParams()
{
var container = new CryoContainer();
var val = new ClassWithSimilarParams();
container.BuildUp(val, new Param {
Name = "Two", Value = 2
}, "Hello, world!", new Param("One", 1));
Assert.AreEqual(1, val.One);
Assert.AreEqual(2, val.Two);
Assert.AreEqual("Hello, world!", val.Str);
}
public void TestSimplePropertiesResolve()
{
var container = new CryoContainer();
container.RegisterInstance("private base", "PrivateBase");
container.RegisterInstance("protected base", "ProtectedBase");
container.RegisterInstance("public base", "PublicBase");
container.RegisterType <ClassBase>();
var a = container.Resolve <ClassBase>();
a.Check();
}
public void InitializeCalled()
{
var container = new CryoContainer {
CircularDependencyReaction = Reaction.LogWarning
};
container.RegisterSingleton <ClassA>();
container.RegisterSingleton <ClassB>();
var a = container.Resolve <ClassA>();
Assert.IsTrue(a.InitializeCalled);
Assert.IsTrue(a.ClassB.InitializeCalled);
}
public void TestBuildUpFailed()
{
var container = new CryoContainer();
try
{
var val = new ClassWithParams();
container.BuildUp(val);
Assert.Fail("Expected exception not happened");
}
catch (ContainerException)
{
}
}
public void TestResolveSimilarParams()
{
var container = new CryoContainer();
container.RegisterType <ClassWithSimilarParams>();
var val = container.Resolve <ClassWithSimilarParams>(new Param {
Name = "Two", Value = 2
}, "Hello, world!", new Param("One", 1));
Assert.AreEqual(1, val.One);
Assert.AreEqual(2, val.Two);
Assert.AreEqual("Hello, world!", val.Str);
}
private static void CreateContainer()
{
_container = new CryoContainer();
_container.RegisterSingleton <SingletonCounter>(GlobalSingleton, LifeTime.Global);
_container.RegisterSingleton <SingletonCounter>(SceneSingleton, LifeTime.Scene);
_container.RegisterSingleton <SingletonCounter>(ExternalSingleton, LifeTime.External);
_container.RegisterType <TypeCounter>(GlobalType, LifeTime.Global);
_container.RegisterType <TypeCounter>(SceneType, LifeTime.Scene);
_container.RegisterType <TypeCounter>(ExternalType, LifeTime.External);
_container.RegisterInstance(new InstanceCounter(), GlobalInstance, LifeTime.Global);
_container.RegisterInstance(new InstanceCounter(), SceneInstance, LifeTime.Scene);
_container.RegisterInstance(new InstanceCounter(), ExternalInstance, LifeTime.External);
}
public void TestSingleton()
{
var container = new CryoContainer();
container.RegisterSingleton <MainClass>();
container.RegisterAlias <IFirstInterface, MainClass>();
container.RegisterAlias <ISecondInterface, MainClass>();
var firstInterface = container.Resolve <IFirstInterface>();
var secondInterface = container.Resolve <ISecondInterface>();
var mainClass = container.Resolve <MainClass>();
Assert.AreSame(mainClass, firstInterface);
Assert.AreSame(mainClass, secondInterface);
}
public void TestResolveFailed()
{
var container = new CryoContainer();
container.RegisterType <ClassWithParams>();
try
{
container.Resolve <ClassWithParams>();
Assert.Fail("Expected exception not happened");
}
catch (ContainerException)
{
}
}
public void TestResolveSimilarParamsFailed2()
{
var container = new CryoContainer();
container.RegisterType <ClassWithSimilarParams>();
try
{
container.Resolve <ClassWithSimilarParams>(1, "Hello, world!", 2);
Assert.Fail("Expected exception not happened");
}
catch (ContainerException)
{
}
}
protected override void SetupContainer(CryoContainer container)
{
base.SetupContainer(container);
var colorDatabase = ColorDatabaseLoader.LoadDatabase();
container.RegisterInstance <IColorDatabase>(colorDatabase, LifeTime.Global);
container.RegisterSingleton <IPathfindingAlgorithm, AstarAlgorithm>(LifeTime.Scene);
container.RegisterSingleton <IErrorMessageFactory, ErrorMessageFactory>(LifeTime.Global);
container.RegisterSingleton <IErrorMessageController, ErrorMessageController>(LifeTime.Global);
container.RegisterSceneObject <UIGridView>(LifeTime.Scene);
}
public void TestBuildUpSimilarParamsFailed2()
{
var container = new CryoContainer();
var val = new ClassWithSimilarParams();
try
{
container.BuildUp(val, 1, "Hello, world!", 2);
Assert.Fail("Expected exception not happened");
}
catch (ContainerException)
{
}
}
public void RefResolved()
{
var container = new CryoContainer {
CircularDependencyReaction = Reaction.LogWarning
};
container.RegisterSingleton <ClassA>();
container.RegisterSingleton <ClassB>();
var a = container.Resolve <ClassA>();
Assert.IsNotNull(a);
Assert.IsNotNull(a.ClassB);
Assert.IsNotNull(a.ClassB.ClassA);
Assert.AreSame(a, a.ClassB.ClassA);
}
public void ContainerDrained(CryoContainer container)
{
microGame.mechanic.loseCondition.AddAmt(1);
ChangeContainers(false);
}
