fixing things on CI

maximv · maximv · commit abbd27d01553 · 2020-08-27T15:14:26.000+03:00
diff --git a/docs/DryIoc.Docs/SpecifyDependencyAndPrimitiveValues.cs b/docs/DryIoc.Docs/SpecifyDependencyAndPrimitiveValues.cs
@@ -365,7 +365,7 @@ [Test] public void Example_via_strongly_typed_spec_and_direct_argument_spec()
     {
         var c = new Container();
 
-        c.Register<Foo>(Made.Of(() => new Foo(Arg.Index<string>(0)), _ => "someString"));
+        c.Register<Foo>(Made.Of(() => new Foo(Arg.Index<string>(0)), _ => "my string"));
 
         Assert.AreEqual("my string", c.Resolve<Foo>().Name);
     }
@@ -375,7 +375,7 @@ [Test] public void Example_via_RegisterDelegate()
     {
         var c = new Container();
 
-        c.RegisterDelegate<Foo>(() => new Foo("someString"));
+        c.RegisterDelegate<Foo>(() => new Foo("my string"));
 
         Assert.AreEqual("my string", c.Resolve<Foo>().Name);
     }
@@ -438,12 +438,13 @@ class Injecting_the_custom_value_with_condition_setup
     [Test] public void Example()
     {
         var container = new Container();
+        container.Register<IBigFish, Tuna>();
 
         container.Register<ILogger, FileLogger>(
-            setup: Setup.With(condition: request => request.Parent.ServiceType.IsAssignableTo(typeof(ISmallFish))));
+            setup: Setup.With(condition: request => request.Parent.ServiceType.IsAssignableTo<ISmallFish>()));
         
         container.Register<ILogger, DbLogger>(
-            setup: Setup.With(condition: request => request.Parent.ServiceType.IsAssignableTo(typeof(IBigFish))));
+            setup: Setup.With(condition: request => request.Parent.ServiceType.IsAssignableTo<IBigFish>()));
 
         var fish = container.Resolve<IBigFish>();
         Assert.IsInstanceOf<DbLogger>((fish as Tuna).Logger);
diff --git a/docs/DryIoc.Docs/SpecifyDependencyAndPrimitiveValues.md b/docs/DryIoc.Docs/SpecifyDependencyAndPrimitiveValues.md
@@ -356,7 +356,7 @@ class Injecting_the_value_of_a_primitive_type
     {
         var c = new Container();
 
-        c.Register<Foo>(Made.Of(() => new Foo(Arg.Index<string>(0)), _ => "someString"));
+        c.Register<Foo>(Made.Of(() => new Foo(Arg.Index<string>(0)), _ => "my string"));
 
         Assert.AreEqual("my string", c.Resolve<Foo>().Name);
     }
@@ -366,7 +366,7 @@ class Injecting_the_value_of_a_primitive_type
     {
         var c = new Container();
 
-        c.RegisterDelegate<Foo>(() => new Foo("someString"));
+        c.RegisterDelegate<Foo>(() => new Foo("my string"));
 
         Assert.AreEqual("my string", c.Resolve<Foo>().Name);
     }
@@ -427,12 +427,13 @@ class Injecting_the_custom_value_with_condition_setup
     [Test] public void Example()
     {
         var container = new Container();
+        container.Register<IBigFish, Tuna>();
 
         container.Register<ILogger, FileLogger>(
-            setup: Setup.With(condition: request => request.Parent.ServiceType.IsAssignableTo(typeof(ISmallFish))));
+            setup: Setup.With(condition: request => request.Parent.ServiceType.IsAssignableTo<ISmallFish>()));
         
         container.Register<ILogger, DbLogger>(
-            setup: Setup.With(condition: request => request.Parent.ServiceType.IsAssignableTo(typeof(IBigFish))));
+            setup: Setup.With(condition: request => request.Parent.ServiceType.IsAssignableTo<IBigFish>()));
 
         var fish = container.Resolve<IBigFish>();
         Assert.IsInstanceOf<DbLogger>((fish as Tuna).Logger);
diff --git a/docs/DryIoc.Docs/ThreadSafety.cs b/docs/DryIoc.Docs/ThreadSafety.cs
@@ -21,32 +21,35 @@
 The above guaranties are possible because of the Container data-structure. 
 In a pseudo code and simplifying things a lot the DryIoc Container may be represented as following:
 ```cs md*/
+//md{ usings ...
 using System;
 using System.Linq.Expressions;
 using System.Threading.Tasks;
 using NUnit.Framework;
 using ImTools;
 using DryIoc;
+#pragma warning disable CS0649
 // ReSharper disable UnusedVariable
+//md}
 
 class Oversimplified_container 
 {
-    class Ref<T> { T Value; } // represents CAS (compare-and-swap) box for the referenced value
+    class Ref<T> { public T Value; } // represents the CAS (compare-and-swap) box for the referenced value
 
     class Container 
     { 
-        Ref<Registry> registry; 
+        public Ref<Registry> Registry;
     }
 
     class Registry 
     {
-        ImHashMap<object, Expression<Func<Container, object>>> registrations;
-        Ref<ResolutionCache> resolutionCache;
+        public ImHashMap<object, Expression<Func<Container, object>>> Registrations;
+        public Ref<ResolutionCache> ResolutionCache;
     }
 
     class ResolutionCache 
     {
-        ImHashMap<object, Func<Container, object>> cache;
+        public ImHashMap<object, Func<Container, object>> Cache;
     }
 }
 /*md
@@ -71,9 +74,11 @@ [Test] public void Example()
 
         container.Register<A>(Reuse.Singleton);
 
-        Task.Run(() => container.Resolve<A>());
-        Task.Run(() => container.Resolve<A>());
-        Task.Run(() => container.Resolve<A>());
+        Task.WaitAll(
+            Task.Run(() => container.Resolve<A>()),
+            Task.Run(() => container.Resolve<A>()),
+            Task.Run(() => container.Resolve<A>())
+        );
 
         Assert.AreEqual(1, A.InstanceCount);
     }
diff --git a/docs/DryIoc.Docs/ThreadSafety.md b/docs/DryIoc.Docs/ThreadSafety.md
@@ -20,32 +20,35 @@ DryIoc ensures that:
 The above guaranties are possible because of the Container data-structure. 
 In a pseudo code and simplifying things a lot the DryIoc Container may be represented as following:
 ```cs 
+//md{ usings ...
 using System;
 using System.Linq.Expressions;
 using System.Threading.Tasks;
 using NUnit.Framework;
 using ImTools;
 using DryIoc;
+#pragma warning disable CS0649
 // ReSharper disable UnusedVariable
+//md}
 
 class Oversimplified_container 
 {
-    class Ref<T> { T Value; } // represents CAS (compare-and-swap) box for the referenced value
+    class Ref<T> { public T Value; } // represents the CAS (compare-and-swap) box for the referenced value
 
     class Container 
     { 
-        Ref<Registry> registry; 
+        public Ref<Registry> Registry;
     }
 
     class Registry 
     {
-        ImHashMap<object, Expression<Func<Container, object>>> registrations;
-        Ref<ResolutionCache> resolutionCache;
+        public ImHashMap<object, Expression<Func<Container, object>>> Registrations;
+        public Ref<ResolutionCache> ResolutionCache;
     }
 
     class ResolutionCache 
     {
-        ImHashMap<object, Func<Container, object>> cache;
+        public ImHashMap<object, Func<Container, object>> Cache;
     }
 }
 ```
@@ -69,9 +72,11 @@ class Resolving_singleton_in_parallel
 
         container.Register<A>(Reuse.Singleton);
 
-        Task.Run(() => container.Resolve<A>());
-        Task.Run(() => container.Resolve<A>());
-        Task.Run(() => container.Resolve<A>());
+        Task.WaitAll(
+            Task.Run(() => container.Resolve<A>()),
+            Task.Run(() => container.Resolve<A>()),
+            Task.Run(() => container.Resolve<A>())
+        );
 
         Assert.AreEqual(1, A.InstanceCount);
     }

Original file line number	Diff line number	Diff line change
`@@ -365,7 +365,7 @@ [Test] public void Example_via_strongly_typed_spec_and_direct_argument_spec()`
`365`	`365`	`{`
`366`	`366`	`var c = new Container();`
`367`	`367`
`368`		`- c.Register<Foo>(Made.Of(() => new Foo(Arg.Index<string>(0)), _ => "someString"));`
	`368`	`+ c.Register<Foo>(Made.Of(() => new Foo(Arg.Index<string>(0)), _ => "my string"));`
`369`	`369`
`370`	`370`	`Assert.AreEqual("my string", c.Resolve<Foo>().Name);`
`371`	`371`	`}`
`@@ -375,7 +375,7 @@ [Test] public void Example_via_RegisterDelegate()`
`375`	`375`	`{`
`376`	`376`	`var c = new Container();`
`377`	`377`
`378`		`- c.RegisterDelegate<Foo>(() => new Foo("someString"));`
	`378`	`+ c.RegisterDelegate<Foo>(() => new Foo("my string"));`
`379`	`379`
`380`	`380`	`Assert.AreEqual("my string", c.Resolve<Foo>().Name);`
`381`	`381`	`}`
`@@ -438,12 +438,13 @@ class Injecting_the_custom_value_with_condition_setup`
`438`	`438`	`[Test] public void Example()`
`439`	`439`	`{`
`440`	`440`	`var container = new Container();`
	`441`	`+ container.Register<IBigFish, Tuna>();`
`441`	`442`
`442`	`443`	`container.Register<ILogger, FileLogger>(`
`443`		`- setup: Setup.With(condition: request => request.Parent.ServiceType.IsAssignableTo(typeof(ISmallFish))));`
	`444`	`+ setup: Setup.With(condition: request => request.Parent.ServiceType.IsAssignableTo<ISmallFish>()));`
`444`	`445`
`445`	`446`	`container.Register<ILogger, DbLogger>(`
`446`		`- setup: Setup.With(condition: request => request.Parent.ServiceType.IsAssignableTo(typeof(IBigFish))));`
	`447`	`+ setup: Setup.With(condition: request => request.Parent.ServiceType.IsAssignableTo<IBigFish>()));`
`447`	`448`
`448`	`449`	`var fish = container.Resolve<IBigFish>();`
`449`	`450`	`Assert.IsInstanceOf<DbLogger>((fish as Tuna).Logger);`
Original file line number	Diff line number	Diff line change
`@@ -356,7 +356,7 @@ class Injecting_the_value_of_a_primitive_type`
`356`	`356`	`{`
`357`	`357`	`var c = new Container();`
`358`	`358`
`359`		`- c.Register<Foo>(Made.Of(() => new Foo(Arg.Index<string>(0)), _ => "someString"));`
	`359`	`+ c.Register<Foo>(Made.Of(() => new Foo(Arg.Index<string>(0)), _ => "my string"));`
`360`	`360`
`361`	`361`	`Assert.AreEqual("my string", c.Resolve<Foo>().Name);`
`362`	`362`	`}`
`@@ -366,7 +366,7 @@ class Injecting_the_value_of_a_primitive_type`
`366`	`366`	`{`
`367`	`367`	`var c = new Container();`
`368`	`368`
`369`		`- c.RegisterDelegate<Foo>(() => new Foo("someString"));`
	`369`	`+ c.RegisterDelegate<Foo>(() => new Foo("my string"));`
`370`	`370`
`371`	`371`	`Assert.AreEqual("my string", c.Resolve<Foo>().Name);`
`372`	`372`	`}`
`@@ -427,12 +427,13 @@ class Injecting_the_custom_value_with_condition_setup`
`427`	`427`	`[Test] public void Example()`
`428`	`428`	`{`
`429`	`429`	`var container = new Container();`
	`430`	`+ container.Register<IBigFish, Tuna>();`
`430`	`431`
`431`	`432`	`container.Register<ILogger, FileLogger>(`
`432`		`- setup: Setup.With(condition: request => request.Parent.ServiceType.IsAssignableTo(typeof(ISmallFish))));`
	`433`	`+ setup: Setup.With(condition: request => request.Parent.ServiceType.IsAssignableTo<ISmallFish>()));`
`433`	`434`
`434`	`435`	`container.Register<ILogger, DbLogger>(`
`435`		`- setup: Setup.With(condition: request => request.Parent.ServiceType.IsAssignableTo(typeof(IBigFish))));`
	`436`	`+ setup: Setup.With(condition: request => request.Parent.ServiceType.IsAssignableTo<IBigFish>()));`
`436`	`437`
`437`	`438`	`var fish = container.Resolve<IBigFish>();`
`438`	`439`	`Assert.IsInstanceOf<DbLogger>((fish as Tuna).Logger);`
Original file line number	Diff line number	Diff line change
`@@ -21,32 +21,35 @@`
`21`	`21`	`The above guaranties are possible because of the Container data-structure.`
`22`	`22`	`In a pseudo code and simplifying things a lot the DryIoc Container may be represented as following:`
`23`	`23`	```cs md*/
	`24`	`+//md{ usings ...`
`24`	`25`	`using System;`
`25`	`26`	`using System.Linq.Expressions;`
`26`	`27`	`using System.Threading.Tasks;`
`27`	`28`	`using NUnit.Framework;`
`28`	`29`	`using ImTools;`
`29`	`30`	`using DryIoc;`
	`31`	`+#pragma warning disable CS0649`
`30`	`32`	`// ReSharper disable UnusedVariable`
	`33`	`+//md}`
`31`	`34`
`32`	`35`	`class Oversimplified_container`
`33`	`36`	`{`
`34`		`- class Ref<T> { T Value; } // represents CAS (compare-and-swap) box for the referenced value`
	`37`	`+ class Ref<T> { public T Value; } // represents the CAS (compare-and-swap) box for the referenced value`
`35`	`38`
`36`	`39`	`class Container`
`37`	`40`	`{`
`38`		`- Ref<Registry> registry;`
	`41`	`+ public Ref<Registry> Registry;`
`39`	`42`	`}`
`40`	`43`
`41`	`44`	`class Registry`
`42`	`45`	`{`
`43`		`- ImHashMap<object, Expression<Func<Container, object>>> registrations;`
`44`		`- Ref<ResolutionCache> resolutionCache;`
	`46`	`+ public ImHashMap<object, Expression<Func<Container, object>>> Registrations;`
	`47`	`+ public Ref<ResolutionCache> ResolutionCache;`
`45`	`48`	`}`
`46`	`49`
`47`	`50`	`class ResolutionCache`
`48`	`51`	`{`
`49`		`- ImHashMap<object, Func<Container, object>> cache;`
	`52`	`+ public ImHashMap<object, Func<Container, object>> Cache;`
`50`	`53`	`}`
`51`	`54`	`}`
`52`	`55`	`/*md`
`@@ -71,9 +74,11 @@ [Test] public void Example()`
`71`	`74`
`72`	`75`	`container.Register<A>(Reuse.Singleton);`
`73`	`76`
`74`		`- Task.Run(() => container.Resolve<A>());`
`75`		`- Task.Run(() => container.Resolve<A>());`
`76`		`- Task.Run(() => container.Resolve<A>());`
	`77`	`+ Task.WaitAll(`
	`78`	`+ Task.Run(() => container.Resolve<A>()),`
	`79`	`+ Task.Run(() => container.Resolve<A>()),`
	`80`	`+ Task.Run(() => container.Resolve<A>())`
	`81`	`+ );`
`77`	`82`
`78`	`83`	`Assert.AreEqual(1, A.InstanceCount);`
`79`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,32 +20,35 @@ DryIoc ensures that:`
`20`	`20`	`The above guaranties are possible because of the Container data-structure.`
`21`	`21`	`In a pseudo code and simplifying things a lot the DryIoc Container may be represented as following:`
`22`	`22`	```cs
	`23`	`+//md{ usings ...`
`23`	`24`	`using System;`
`24`	`25`	`using System.Linq.Expressions;`
`25`	`26`	`using System.Threading.Tasks;`
`26`	`27`	`using NUnit.Framework;`
`27`	`28`	`using ImTools;`
`28`	`29`	`using DryIoc;`
	`30`	`+#pragma warning disable CS0649`
`29`	`31`	`// ReSharper disable UnusedVariable`
	`32`	`+//md}`
`30`	`33`
`31`	`34`	`class Oversimplified_container`
`32`	`35`	`{`
`33`		`- class Ref<T> { T Value; } // represents CAS (compare-and-swap) box for the referenced value`
	`36`	`+ class Ref<T> { public T Value; } // represents the CAS (compare-and-swap) box for the referenced value`
`34`	`37`
`35`	`38`	`class Container`
`36`	`39`	`{`
`37`		`- Ref<Registry> registry;`
	`40`	`+ public Ref<Registry> Registry;`
`38`	`41`	`}`
`39`	`42`
`40`	`43`	`class Registry`
`41`	`44`	`{`
`42`		`- ImHashMap<object, Expression<Func<Container, object>>> registrations;`
`43`		`- Ref<ResolutionCache> resolutionCache;`
	`45`	`+ public ImHashMap<object, Expression<Func<Container, object>>> Registrations;`
	`46`	`+ public Ref<ResolutionCache> ResolutionCache;`
`44`	`47`	`}`
`45`	`48`
`46`	`49`	`class ResolutionCache`
`47`	`50`	`{`
`48`		`- ImHashMap<object, Func<Container, object>> cache;`
	`51`	`+ public ImHashMap<object, Func<Container, object>> Cache;`
`49`	`52`	`}`
`50`	`53`	`}`
`51`	`54`	```
`@@ -69,9 +72,11 @@ class Resolving_singleton_in_parallel`
`69`	`72`
`70`	`73`	`container.Register<A>(Reuse.Singleton);`
`71`	`74`
`72`		`- Task.Run(() => container.Resolve<A>());`
`73`		`- Task.Run(() => container.Resolve<A>());`
`74`		`- Task.Run(() => container.Resolve<A>());`
	`75`	`+ Task.WaitAll(`
	`76`	`+ Task.Run(() => container.Resolve<A>()),`
	`77`	`+ Task.Run(() => container.Resolve<A>()),`
	`78`	`+ Task.Run(() => container.Resolve<A>())`
	`79`	`+ );`
`75`	`80`
`76`	`81`	`Assert.AreEqual(1, A.InstanceCount);`
`77`	`82`	`}`