adding the new test for #535

Author: dadhi

test/DryIoc.IssuesTests/GHIssue535_Property_injection_does_not_work_when_appending_implementation_for_multiple_registration.cs

@@ -8,26 +8,69 @@ public class GHIssue535_Property_injection_does_not_work_when_appending_implemen
     {
         public int Run()
         {
-            Test();
+            // Test1();
+            Test2();
             return 1;
         }
 
-        [Test]
-        [Ignore("fixme")]
-        public void Test()
+        // [Test]
+        public void Test1()
         {
             // ARRANGE
             const string testFoo1 = "TF1";
             const string testFoo2 = "TF2";
 
             var container = new Container();
 
-            container.RegisterMany(new[] { typeof(Foo1), typeof(IFoo) }, typeof(Foo1), reuse: Reuse.Singleton);
             var propertiesAndFieldsSelector = PropertiesAndFields.Of.Name(nameof(IFoo.Test), _ => testFoo1);
-            container.RegisterMany(new[] { typeof(Foo1), typeof(IFoo) }, typeof(Foo1), reuse: Reuse.Singleton, 
+            container.RegisterMany(new[] { typeof(Foo1), typeof(IFoo) }, typeof(Foo1), reuse: Reuse.Singleton,
+                made: propertiesAndFieldsSelector, ifAlreadyRegistered: IfAlreadyRegistered.AppendNewImplementation);
+
+            propertiesAndFieldsSelector = PropertiesAndFields.Of.Name(nameof(IFoo.Test), _ => testFoo2);
+            container.RegisterMany(new[] { typeof(Foo2), typeof(IFoo) }, typeof(Foo2), reuse: Reuse.Singleton, 
+                made: propertiesAndFieldsSelector, ifAlreadyRegistered: IfAlreadyRegistered.AppendNewImplementation);
+
+            // ACT
+            var foo1 = container.Resolve<Foo1>();
+            var foo2 = container.Resolve<Foo2>();
+            var foos = container.Resolve<IEnumerable<IFoo>>();
+
+            // ASSERT
+            Assert.AreEqual(testFoo1, foo1.Test);
+            Assert.AreEqual(testFoo2, foo2.Test);
+
+            foreach (var foo in foos)
+            {
+                switch (foo)
+                {
+                    case Foo1 foo1FromEnumerable:
+                        Assert.AreEqual(testFoo1, foo.Test);
+                        Assert.AreEqual(foo1, foo1FromEnumerable);
+                        break;
+                    case Foo2 foo2FromEnumerable:
+                        Assert.AreEqual(testFoo2, foo.Test);
+                        Assert.AreEqual(foo2, foo2FromEnumerable);
+                        break;
+                }
+            }
+        }
+
+        // [Test]
+        public void Test2()
+        {
+            // ARRANGE
+            const string testFoo1 = "TF1";
+            const string testFoo2 = "TF2";
+
+            var container = new Container();
+
+            // container.RegisterMany(new[] { typeof(Foo1), typeof(IFoo) }, typeof(Foo1), reuse: Reuse.Singleton);
+            var propertiesAndFieldsSelector = PropertiesAndFields.Of.Name(nameof(IFoo.Test), _ => testFoo1);
+            container.RegisterMany(new[] { typeof(Foo1), typeof(IFoo) }, typeof(Foo1), reuse: Reuse.Singleton,
                 made: propertiesAndFieldsSelector, ifAlreadyRegistered: IfAlreadyRegistered.AppendNewImplementation);
 
             container.RegisterMany(new[] { typeof(Foo2), typeof(IFoo) }, typeof(Foo2), reuse: Reuse.Singleton);
+
             propertiesAndFieldsSelector = PropertiesAndFields.Of.Name(nameof(IFoo.Test), _ => testFoo2);
             container.RegisterMany(new[] { typeof(Foo2), typeof(IFoo) }, typeof(Foo2), reuse: Reuse.Singleton, 
                 made: propertiesAndFieldsSelector, ifAlreadyRegistered: IfAlreadyRegistered.AppendNewImplementation);