Enable nullable in tests (#144)

src/Jab.FunctionalTests.Common/CompilerFeatureRequiredAttribute.cs

@@ -0,0 +1,37 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Runtime.CompilerServices
+{
+    /// <summary>
+    /// Indicates that compiler support for a particular feature is required for the location where this attribute is applied.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
+    public sealed class CompilerFeatureRequiredAttribute : Attribute
+    {
+        public CompilerFeatureRequiredAttribute(string featureName)
+        {
+            FeatureName = featureName;
+        }
+
+        /// <summary>
+        /// The name of the compiler feature.
+        /// </summary>
+        public string FeatureName { get; }
+
+        /// <summary>
+        /// If true, the compiler can choose to allow access to the location where this attribute is applied if it does not understand <see cref="FeatureName"/>.
+        /// </summary>
+        public bool IsOptional { get; init; }
+
+        /// <summary>
+        /// The <see cref="FeatureName"/> used for the ref structs C# feature.
+        /// </summary>
+        public const string RefStructs = nameof(RefStructs);
+
+        /// <summary>
+        /// The <see cref="FeatureName"/> used for the required members C# feature.
+        /// </summary>
+        public const string RequiredMembers = nameof(RequiredMembers);
+    }
+}

src/Jab.FunctionalTests.Common/ContainerTests.cs

@@ -1,3 +1,4 @@
+#nullable enable
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
@@ -63,8 +64,10 @@ internal partial class CanCreateSingletonContainer { }
         [Fact]
         public void CanUseSingletonInstance()
         {
-            CanUseSingletonInstanceContainer c = new();
-            c.MyIServiceInstance = new AnotherServiceImplementation();
+            CanUseSingletonInstanceContainer c = new()
+            {
+                MyIServiceInstance = new AnotherServiceImplementation()
+            };
             var implementationWithParameter = Assert.IsType<ServiceImplementationWithParameter>(c.GetService<IService>());
             var anotherImplementation = c.GetService<IAnotherService>();
 
@@ -78,9 +81,9 @@ public void CanUseSingletonInstance()
         [Singleton(typeof(IAnotherService), Instance = "MyIServiceInstance")]
         internal partial class CanUseSingletonInstanceContainer
         {
-            public IAnotherService MyIServiceInstance { get; set; }
+            public required IAnotherService MyIServiceInstance { get; set; }
         }
-        
+
         [Fact]
         public void CanUseStaticSingletonInstance()
         {
@@ -218,12 +221,14 @@ public IService<T> CreateMyIServiceInstance<T>()
         [Fact]
         public void CanUseFuncFactory()
         {
-            CanUseFuncFactoryContainer c = new();
             int invocationCount = 0;
-            c.Factory = (IAnotherService s) =>
+            CanUseFuncFactoryContainer c = new()
             {
-                invocationCount++;
-                return new ServiceImplementation<IAnotherService>(s);
+                Factory = (IAnotherService s) =>
+                {
+                    invocationCount++;
+                    return new ServiceImplementation<IAnotherService>(s);
+                }
             };
             var service = c.GetService<IService<IAnotherService>>();
             Assert.NotNull(service.InnerService);
@@ -236,7 +241,7 @@ public void CanUseFuncFactory()
         internal partial class CanUseFuncFactoryContainer
         {
             public delegate IService<IAnotherService> FactoryDelegate(IAnotherService s);
-            public FactoryDelegate Factory;
+            public required FactoryDelegate Factory;
         }
 
         [Fact]
@@ -343,8 +348,10 @@ internal partial class CanResolveOpenGenericServiceContainer { }
         [Fact]
         public void CanResolveEnumerableOfMixedOpenGenericService()
         {
-            CanResolveEnumerableOfMixedOpenGenericServiceContainer c = new();
-            c.Instance = new ServiceImplementation<IAnotherService>(new AnotherServiceImplementation());
+            CanResolveEnumerableOfMixedOpenGenericServiceContainer c = new()
+            {
+                Instance = new ServiceImplementation<IAnotherService>(new AnotherServiceImplementation())
+            };
 
             var services = c.GetService<IEnumerable<IService<IAnotherService>>>();
             var array = Assert.IsType<IService<IAnotherService>[]>(services);
@@ -358,7 +365,7 @@ public void CanResolveEnumerableOfMixedOpenGenericService()
         [Transient(typeof(IAnotherService), typeof(AnotherServiceImplementation))]
         internal partial class CanResolveEnumerableOfMixedOpenGenericServiceContainer
         {
-            public IService<IAnotherService> Instance { get; set; }
+            public required IService<IAnotherService> Instance { get; set; }
         }
 
         [Fact]
@@ -1175,13 +1182,14 @@ public void CanUseModuleWithStaticFactory()
             CanUseModuleWithStaticFactoryContainer c = new();
 
             var service = c.GetService<IService<IService>>();
+            var provider = c.GetService<IService<IServiceProvider>>();
             Assert.IsType<ServiceImplementation>(service.InnerService);
         }
-        
+
         [ServiceProvider]
         [Import(typeof(IModuleWithStaticFactory))]
         internal partial class CanUseModuleWithStaticFactoryContainer { }
-        
+
         [ServiceProviderModule]
         [Singleton(typeof(IService<>), Factory = nameof(Factory))]
         [Singleton(typeof(IService), Instance = nameof(Instance))]

src/Jab.FunctionalTests.Common/RequiredMemberAttribute.cs

@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+using System.ComponentModel;
+namespace System.Runtime.CompilerServices
+{
+    /// <summary>Specifies that a type has required members or that a member is required.</summary>
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+#if SYSTEM_PRIVATE_CORELIB
+    public
+#else
+    internal
+#endif
+        sealed class RequiredMemberAttribute : Attribute
+    { }
+}