- add all existing test cases that use current factory implementation and substitute it with generated factories

Test.LightweightIocContainer.FactoryGenerator/AsyncFactoryTest.cs

@@ -0,0 +1,60 @@
+// Author: Simon.Gockner
+// Created: 2025-12-03
+// Copyright(c) 2025 SimonG. All Rights Reserved.
+
+using LightweightIocContainer;
+using LightweightIocContainer.FactoryGenerator;
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses;
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Factories;
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator;
+
+[TestFixture]
+public class AsyncFactoryTest
+{
+    [Test]
+    public async Task TestAsyncFactoryResolve()
+    {
+        IocContainer container = new();
+        container.Register(r => r.Add<IAsyncTest, AsyncTest>().WithGeneratedFactory<IAsyncTestFactory>());
+
+        IAsyncTestFactory testFactory = container.Resolve<IAsyncTestFactory>();
+        IAsyncTest test = await testFactory.Create();
+        
+        Assert.That(test, Is.InstanceOf<AsyncTest>());
+    }
+    
+    [Test]
+    public async Task TestAsyncFactoryResolveOnCreateCalled()
+    {
+        IocContainer container = new();
+        container.Register(r => r.Add<IAsyncTest, AsyncTest>().OnCreateAsync(t => t.Initialize()).WithGeneratedFactory<IAsyncTestFactory>());
+
+        IAsyncTestFactory testFactory = container.Resolve<IAsyncTestFactory>();
+        IAsyncTest test = await testFactory.Create();
+        
+        Assert.That(test, Is.InstanceOf<AsyncTest>());
+        Assert.That(test.IsInitialized, Is.True);
+    }
+
+    [Test]
+    public async Task TestAsyncMultitonFactoryResolveOnCreateCalledCorrectly()
+    {
+        IocContainer container = new();
+        container.Register(r => r.AddMultiton<IAsyncTest, AsyncMultitonTest, int>().OnCreateAsync(t => t.Initialize()).WithGeneratedFactory<IAsyncMultitonTestFactory>());
+        
+        IAsyncMultitonTestFactory testFactory = container.Resolve<IAsyncMultitonTestFactory>();
+        IAsyncTest test1 = await testFactory.Create(1);
+        IAsyncTest test2 = await testFactory.Create(2);
+        IAsyncTest anotherTest1 = await testFactory.Create(1);
+        
+        Assert.That(test1, Is.InstanceOf<AsyncTest>());
+        Assert.That(test1.IsInitialized, Is.True);
+        
+        Assert.That(test2, Is.InstanceOf<AsyncTest>());
+        Assert.That(test2.IsInitialized, Is.True);
+
+        Assert.That(test1, Is.SameAs(anotherTest1));
+    }
+}

Test.LightweightIocContainer.FactoryGenerator/FluentFactoryRegistrationTest.cs

@@ -0,0 +1,212 @@
+// Author: Simon.Gockner
+// Created: 2025-12-03
+// Copyright(c) 2025 SimonG. All Rights Reserved.
+
+using LightweightIocContainer;
+using LightweightIocContainer.Exceptions;
+using LightweightIocContainer.FactoryGenerator;
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses;
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Factories;
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator;
+
+[TestFixture]
+public class FluentFactoryRegistrationTest
+{
+    private IocContainer _iocContainer;
+
+    [SetUp]
+    public void SetUp() => _iocContainer = new IocContainer();
+
+    [TearDown]
+    public void TearDown() => _iocContainer.Dispose();
+        
+    [Test]
+    public void TestFluentFactoryRegistration()
+    {
+        _iocContainer.Register(r => r.Add<IDefaultTest, DefaultTest>().WithGeneratedFactory<IDefaultTestFactory>());
+
+        IDefaultTestFactory factory = _iocContainer.Resolve<IDefaultTestFactory>();
+        IDefaultTest test = factory.Create();
+        
+        Assert.That(factory, Is.InstanceOf<IDefaultTestFactory>());
+        Assert.That(test, Is.InstanceOf<IDefaultTest>());
+    }
+        
+    [Test]
+    public void TestFluentFactoryRegistrationResolveWithoutFactoryFails()
+    {
+        _iocContainer.Register(r => r.Add<IDefaultTest, DefaultTest>().WithGeneratedFactory<IDefaultTestFactory>());
+        Assert.Throws<DirectResolveWithRegisteredFactoryNotAllowed>(()=>_iocContainer.Resolve<IDefaultTest>());
+    }
+        
+    [Test]
+    public void TestRegisterFactoryWithoutCreate() => Assert.Throws<InvalidFactoryRegistrationException>(() => _iocContainer.Register(r => r.Add<IDefaultTest, DefaultTest>().WithGeneratedFactory<ITestFactoryNoCreate>()));
+        
+    [Test]
+    public void TestResolveFromFactory()
+    {
+        _iocContainer.Register(r => r.Add<IDefaultTest, DefaultTest>().WithGeneratedFactory<IDefaultTestFactory>());
+        
+        IDefaultTestFactory testFactory = _iocContainer.Resolve<IDefaultTestFactory>();
+        IDefaultTest createdTest = testFactory.Create();
+        
+        Assert.That(createdTest, Is.InstanceOf<DefaultTest>());
+    }
+        
+    [Test]
+    public void TestResolveFromFactoryWithParams()
+    {
+        _iocContainer.Register(r => r.Add<IDefaultTest, TestConstructor>().WithGeneratedFactory<IDefaultTestFactory>());
+        _iocContainer.Register(r => r.Add<DefaultTest, DefaultTest>()); //this registration is abnormal and should only be used in unit tests
+        
+        IDefaultTestFactory testFactory = _iocContainer.Resolve<IDefaultTestFactory>();
+        IDefaultTest createdTest = testFactory.Create("Test");
+        
+        Assert.That(createdTest, Is.InstanceOf<TestConstructor>());
+    }
+        
+    [Test]
+    public void TestResolveFromFactoryWithDefaultParamCreate()
+    {
+        _iocContainer.Register(r => r.Add<IDefaultTest, TestConstructor>().WithGeneratedFactory<IDefaultTestFactory>());
+        _iocContainer.Register(r => r.Add<DefaultTest, DefaultTest>()); //this registration is abnormal and should only be used in unit tests
+        
+        IDefaultTestFactory testFactory = _iocContainer.Resolve<IDefaultTestFactory>();
+        IDefaultTest createdTest = testFactory.CreateTest();
+        
+        Assert.That(createdTest, Is.InstanceOf<TestConstructor>());
+    }
+        
+    [Test]
+    public void TestResolveFromFactoryWithDefaultParamCtor()
+    {
+        _iocContainer.Register(r => r.Add<IDefaultTest, TestConstructor>().WithGeneratedFactory<IDefaultTestFactory>());
+        _iocContainer.Register(r => r.Add<DefaultTest, DefaultTest>()); //this registration is abnormal and should only be used in unit tests
+        
+        IDefaultTestFactory testFactory = _iocContainer.Resolve<IDefaultTestFactory>();
+        IDefaultTest createdTest = testFactory.Create();
+        
+        Assert.That(createdTest, Is.InstanceOf<TestConstructor>());
+    }
+        
+    [Test]
+    public void TestResolveFromFactoryWithByte()
+    {
+        _iocContainer.Register(r => r.Add<IDefaultTest, TestByte>().WithGeneratedFactory<IDefaultTestFactory>());
+        
+        IDefaultTestFactory testFactory = _iocContainer.Resolve<IDefaultTestFactory>();
+        IDefaultTest createdTest = testFactory.Create(1);
+        
+        Assert.That(createdTest, Is.InstanceOf<TestByte>());
+    }
+
+    [Test]
+    public void TestPassingNullAsMiddleParameter()
+    {
+        _iocContainer.Register(r => r.Add<IDefaultTest, TestNull>().WithGeneratedFactory<ITestNullFactory>());
+
+        ITestNullFactory testNullFactory = _iocContainer.Resolve<ITestNullFactory>();
+
+        object obj = new();
+        string content = "TestContent";
+        string optional2 = "optionalParameter2";
+
+        IDefaultTest createdTest = testNullFactory.Create(obj, content, null!, optional2);
+        if (createdTest is not TestNull testNull)
+        {
+            Assert.Fail();
+            return;
+        }
+        
+        Assert.That(testNull.Obj, Is.SameAs(obj));
+        Assert.That(testNull.Content, Is.EqualTo(content));
+        Assert.That(testNull.Optional1, Is.Null);
+        Assert.That(testNull.Optional2, Is.EqualTo(optional2));
+    }
+    
+    [Test]
+    public void TestPassingNullAsDefaultParameter()
+    {
+        _iocContainer.Register(r => r.Add<IDefaultTest, TestNull>().WithGeneratedFactory<ITestDefaultFactory>());
+
+        ITestDefaultFactory testDefaultFactory = _iocContainer.Resolve<ITestDefaultFactory>();
+
+        object obj = new();
+        string content = "TestContent";
+        string optional2 = "optionalParameter2";
+
+        IDefaultTest createdTest = testDefaultFactory.Create(obj, content, null!, optional2);
+        if (createdTest is not TestNull testNull)
+        {
+            Assert.Fail();
+            return;
+        }
+        
+        Assert.That(testNull.Obj, Is.SameAs(obj));
+        Assert.That(testNull.Content, Is.EqualTo(content));
+        Assert.That(testNull.Optional1, Is.Null);
+        Assert.That(testNull.Optional2, Is.EqualTo(optional2));
+        Assert.That(testNull.TestNullFactory, Is.Null);
+    }
+        
+    [Test]
+    public void TestResolveMultitonFromFactory()
+    {
+        _iocContainer.Register(r => r.AddMultiton<IDefaultTest, TestMultiton, MultitonScope>().WithGeneratedFactory<IMultitonTestFactory>());
+        
+        MultitonScope scope1 = new();
+        MultitonScope scope2 = new();
+        
+        IMultitonTestFactory testFactory = _iocContainer.Resolve<IMultitonTestFactory>();
+        
+        IDefaultTest resolvedTest1 = testFactory.Create(scope1);
+        IDefaultTest resolvedTest2 = testFactory.Create(scope1);
+        IDefaultTest resolvedTest3 = testFactory.Create(scope2);
+        
+        Assert.That(resolvedTest1, Is.SameAs(resolvedTest2));
+        Assert.That(resolvedTest1, Is.Not.SameAs(resolvedTest3));
+        Assert.That(resolvedTest2, Is.Not.SameAs(resolvedTest3));
+    }
+        
+    [Test]
+    public void TestResolveMultitonFromFactoryClearInstances()
+    {
+        _iocContainer.Register(r => r.AddMultiton<IDefaultTest, TestMultiton, MultitonScope>().WithGeneratedFactory<IMultitonTestFactory>());
+        
+        MultitonScope scope1 = new();
+        MultitonScope scope2 = new();
+        
+        IMultitonTestFactory testFactory = _iocContainer.Resolve<IMultitonTestFactory>();
+        
+        IDefaultTest resolvedTest1 = testFactory.Create(scope1);
+        IDefaultTest resolvedTest2 = testFactory.Create(scope1);
+        IDefaultTest resolvedTest3 = testFactory.Create(scope2);
+        
+        Assert.That(resolvedTest1, Is.SameAs(resolvedTest2));
+        Assert.That(resolvedTest1, Is.Not.SameAs(resolvedTest3));
+        Assert.That(resolvedTest2, Is.Not.SameAs(resolvedTest3));
+        
+        testFactory.ClearMultitonInstance<IDefaultTest>();
+        
+        IDefaultTest resolvedTest4 = testFactory.Create(scope1);
+        IDefaultTest resolvedTest5 = testFactory.Create(scope2);
+        
+        Assert.That(resolvedTest1, Is.Not.SameAs(resolvedTest4));
+        Assert.That(resolvedTest2, Is.Not.SameAs(resolvedTest4));
+        Assert.That(resolvedTest3, Is.Not.SameAs(resolvedTest5));
+    }
+
+    [Test]
+    public void InvalidMultitonFactoryRegistrationFactoryWithoutParameter() => 
+        Assert.Throws<InvalidFactoryRegistrationException>(() => _iocContainer.Register(r => r.AddMultiton<IDefaultTest, DefaultTest, MultitonScope>().WithGeneratedFactory<IDefaultTestFactory>()));
+        
+    [Test]
+    public void InvalidMultitonFactoryRegistrationFactoryWithoutScopeAsFirstParameter() => 
+        Assert.Throws<InvalidFactoryRegistrationException>(() => _iocContainer.Register(r => r.AddMultiton<IDefaultTest, DefaultTest, MultitonScope>().WithGeneratedFactory<IInvalidMultitonTestFactory>()));
+
+    [Test]
+    public void TestInvalidCreateMethodReturnType() => 
+        Assert.Throws<InvalidFactoryRegistrationException>(() => _iocContainer.Register(r => r.Add<IDefaultTest, DefaultTest>().WithGeneratedFactory<ITestFactoryWrongReturn>()));
+}

Test.LightweightIocContainer.FactoryGenerator/MultiLayerResolveTest.cs

@@ -0,0 +1,40 @@
+// Author: Simon.Gockner
+// Created: 2025-12-03
+// Copyright(c) 2025 SimonG. All Rights Reserved.
+
+using LightweightIocContainer;
+using LightweightIocContainer.FactoryGenerator;
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses;
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Factories;
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator;
+
+[TestFixture]
+public class MultiLayerResolveTest
+{
+    [Test]
+    public void TestResolveFactoryAsCtorParameter()
+    {
+        IocContainer container = new();
+        container.Register(r => r.Add<IA, A>().WithGeneratedFactory<IAFactory>());
+        container.Register(r => r.Add<IB, B>().WithGeneratedFactory<IBFactory>());
+
+        IAFactory aFactory = container.Resolve<IAFactory>();
+        IA a = aFactory.Create();
+        Assert.That(a, Is.InstanceOf<A>());
+    }
+
+    [Test]
+    public void TestResolveSingleTypeRegistrationAsCtorParameter()
+    {
+        IocContainer container = new();
+        container.Register(r => r.Add<IA, A>());
+        container.Register(r => r.Add<IB, B>().WithGeneratedFactory<IBFactory>());
+        container.Register(r => r.Add<C>().WithFactoryMethod(_ => new C("test")));
+
+        IBFactory bFactory = container.Resolve<IBFactory>();
+        IB b = bFactory.Create();
+        Assert.That(b, Is.InstanceOf<B>());
+    }
+}

Test.LightweightIocContainer.FactoryGenerator/OpenGenericRegistrationTest.cs

@@ -0,0 +1,41 @@
+// Author: Simon.Gockner
+// Created: 2025-12-03
+// Copyright(c) 2025 SimonG. All Rights Reserved.
+
+using LightweightIocContainer;
+using LightweightIocContainer.FactoryGenerator;
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses;
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Factories;
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator;
+
+[TestFixture]
+public class OpenGenericRegistrationTest
+{
+    private IocContainer _iocContainer;
+
+    [SetUp]
+    public void SetUp() => _iocContainer = new IocContainer();
+
+    [TearDown]
+    public void TearDown() => _iocContainer.Dispose();
+    
+    [Test]
+    public void TestRegisterFactoryOfOpenGenericType()
+    {
+        _iocContainer.Register(r => r.AddOpenGenerics(typeof(IGenericTest<>), typeof(GenericTest<>)).WithGeneratedFactory<IGenericTestFactory>());
+        IGenericTestFactory testFactory = _iocContainer.Resolve<IGenericTestFactory>();
+        IGenericTest<Constraint> test = testFactory.Create<Constraint>();
+        Assert.That(test, Is.InstanceOf<GenericTest<Constraint>>());
+    }
+
+    [Test]
+    public void TestRegisterFactoryOfOpenGenericTypeWithCtorParameter()
+    {
+        _iocContainer.Register(r => r.AddOpenGenerics(typeof(IGenericTest<>), typeof(CtorGenericTest<>)).WithGeneratedFactory<ICtorGenericTestFactory>());
+        ICtorGenericTestFactory testFactory = _iocContainer.Resolve<ICtorGenericTestFactory>();
+        IGenericTest<Constraint> test = testFactory.Create(new Constraint());
+        Assert.That(test, Is.InstanceOf<CtorGenericTest<Constraint>>());
+    }
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/A.cs

@@ -0,0 +1,10 @@
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Factories;
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses;
+
+public class A : IA
+{
+    public A(IBFactory bFactory) => BProperty = bFactory.Create(new C("from A"));
+    public IB BProperty { get; }
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/AsyncMultitonTest.cs

@@ -0,0 +1,13 @@
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses;
+
+public class AsyncMultitonTest(int id) : AsyncTest
+{
+    public int Id { get; } = id;
+    public override async Task Initialize()
+    {
+        if (IsInitialized)
+            throw new Exception();
+            
+        await base.Initialize();
+    }
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/AsyncTest.cs

@@ -0,0 +1,14 @@
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses;
+
+public class AsyncTest : IAsyncTest
+{
+    public bool IsInitialized { get; private set; }
+
+    public virtual async Task Initialize()
+    {
+        await Task.Delay(200);
+        IsInitialized = true;
+    }
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/B.cs

@@ -0,0 +1,10 @@
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses;
+
+public class B : IB
+{
+    public B(C c) => C = c;
+
+    public C C { get; }
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/C.cs

@@ -0,0 +1,9 @@
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses;
+
+public class C
+{
+    public C(string test)
+    {
+            
+    }
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Constraint.cs

@@ -0,0 +1,9 @@
+// Author: Simon.Gockner
+// Created: 2025-12-03
+// Copyright(c) 2025 SimonG. All Rights Reserved.
+
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses;
+
+public class Constraint : IConstraint;

Test.LightweightIocContainer.FactoryGenerator/TestClasses/CtorGenericTest.cs

@@ -0,0 +1,11 @@
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses;
+
+public class CtorGenericTest<T> : IGenericTest<T> where T : IConstraint, new()
+{
+    public CtorGenericTest(T item)
+    {
+            
+    }
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/DefaultTest.cs

@@ -0,0 +1,5 @@
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses;
+
+public class DefaultTest : IDefaultTest;

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Factories/IAFactory.cs

@@ -0,0 +1,10 @@
+using JetBrains.Annotations;
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses.Factories;
+
+[UsedImplicitly]
+public interface IAFactory
+{
+    IA Create();
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Factories/IAsyncMultitonTestFactory.cs

@@ -0,0 +1,8 @@
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses.Factories;
+
+public interface IAsyncMultitonTestFactory
+{
+    Task<IAsyncTest> Create(int id);
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Factories/IAsyncTestFactory.cs

@@ -0,0 +1,8 @@
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses.Factories;
+
+public interface IAsyncTestFactory
+{
+    Task<IAsyncTest> Create();
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Factories/IBFactory.cs

@@ -0,0 +1,9 @@
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses.Factories;
+
+public interface IBFactory
+{
+    IB Create();
+    IB Create(C c);
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Factories/ICtorGenericTestFactory.cs

@@ -0,0 +1,8 @@
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses.Factories;
+
+public interface ICtorGenericTestFactory
+{
+    IGenericTest<T> Create<T>(T item) where T : IConstraint, new();
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Factories/IDefaultTestFactory.cs

@@ -0,0 +1,11 @@
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses.Factories;
+
+public interface IDefaultTestFactory
+{
+    IDefaultTest Create();
+    IDefaultTest Create(string name);
+    IDefaultTest CreateTest(string name = null!);
+    IDefaultTest Create(byte id);
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Factories/IGenericTestFactory.cs

@@ -0,0 +1,8 @@
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses.Factories;
+
+public interface IGenericTestFactory
+{
+    IGenericTest<T> Create<T>() where T : IConstraint, new();
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Factories/IInvalidMultitonTestFactory.cs

@@ -0,0 +1,9 @@
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses.Factories;
+
+public interface IInvalidMultitonTestFactory
+{
+    IDefaultTest Create(MultitonScope scope);
+    IDefaultTest Create(int number);
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Factories/IMultitonTestFactory.cs

@@ -0,0 +1,9 @@
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses.Factories;
+
+public interface IMultitonTestFactory
+{
+    IDefaultTest Create(MultitonScope scope);
+    void ClearMultitonInstance<T>();
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Factories/ITestDefaultFactory.cs

@@ -0,0 +1,8 @@
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses.Factories;
+
+public interface ITestDefaultFactory
+{
+    IDefaultTest Create(object obj, string content, string optional1, string optional2, ITestNullFactory testNullFactory = null!);
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Factories/ITestFactoryNoCreate.cs

@@ -0,0 +1,3 @@
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses.Factories;
+
+public interface ITestFactoryNoCreate;

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Factories/ITestFactoryWrongReturn.cs

@@ -0,0 +1,6 @@
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses.Factories;
+
+public interface ITestFactoryWrongReturn
+{
+    public MultitonScope Create();
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Factories/ITestNullFactory.cs

@@ -0,0 +1,8 @@
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses.Factories;
+
+public interface ITestNullFactory
+{
+    IDefaultTest Create(object obj, string content, string optional1, string optional2);
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/GenericTest.cs

@@ -0,0 +1,5 @@
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses;
+
+public class GenericTest<T> : IGenericTest<T> where T : IConstraint, new();

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Interfaces/IA.cs

@@ -0,0 +1,6 @@
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+public interface IA
+{
+    IB BProperty { get; }
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Interfaces/IAsyncTest.cs

@@ -0,0 +1,7 @@
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+public interface IAsyncTest
+{
+    bool IsInitialized { get; }
+    Task Initialize();
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Interfaces/IB.cs

@@ -0,0 +1,6 @@
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+public interface IB
+{
+    C C { get; }
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Interfaces/IConstraint.cs

@@ -0,0 +1,3 @@
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+public interface IConstraint;

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Interfaces/IDefaultTest.cs

@@ -0,0 +1,3 @@
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+public interface IDefaultTest;

Test.LightweightIocContainer.FactoryGenerator/TestClasses/Interfaces/IGenericTest.cs

@@ -0,0 +1,3 @@
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+public interface IGenericTest<T> where T : IConstraint, new();

Test.LightweightIocContainer.FactoryGenerator/TestClasses/MultitonScope.cs

@@ -0,0 +1,3 @@
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses;
+
+public class MultitonScope;

Test.LightweightIocContainer.FactoryGenerator/TestClasses/TestByte.cs

@@ -0,0 +1,12 @@
+using JetBrains.Annotations;
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses;
+
+public class TestByte : IDefaultTest
+{
+    [UsedImplicitly]
+    private readonly byte _id;
+
+    public TestByte(byte id) => _id = id;
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/TestConstructor.cs

@@ -0,0 +1,16 @@
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses;
+
+public class TestConstructor : IDefaultTest
+{
+    public TestConstructor(string name, DefaultTest test)
+    {
+
+    }
+
+    public TestConstructor(DefaultTest test, string name = null!)
+    {
+
+    }
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/TestMultiton.cs

@@ -0,0 +1,11 @@
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses;
+
+public class TestMultiton : IDefaultTest
+{
+    public TestMultiton(MultitonScope scope)
+    {
+            
+    }
+}

Test.LightweightIocContainer.FactoryGenerator/TestClasses/TestNull.cs

@@ -0,0 +1,23 @@
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Factories;
+using Test.LightweightIocContainer.FactoryGenerator.TestClasses.Interfaces;
+
+namespace Test.LightweightIocContainer.FactoryGenerator.TestClasses;
+
+public class TestNull : IDefaultTest
+{
+
+    public TestNull(object obj, string content, string optional1, string optional2, ITestNullFactory testNullFactory)
+    {
+        Obj = obj;
+        Content = content;
+        Optional1 = optional1;
+        Optional2 = optional2;
+        TestNullFactory = testNullFactory;
+    }
+        
+    public object Obj { get; }
+    public string Content { get; }
+    public string Optional1 { get; }
+    public string Optional2 { get; }
+    public ITestNullFactory TestNullFactory { get; }
+}