Add comprehensive type candidate service tests

Introduces new unit tests for DefaultIntrinsicTypePolicy and TypeCandidateService, covering intrinsic type policy, base type inclusion, generic variance (Unity 2023.2+), and non-generic candidate filtering. Also expands TypeCandidateTestTypes with various test types to support these scenarios.

Author: mackysoft

Assets/MackySoft/MackySoft.SerializeReferenceExtensions/Tests/Editor/DefaultIntrinsicTypePolicyTests.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using MackySoft.SerializeReferenceExtensions.Editor;
+using NUnit.Framework;
+
+namespace MackySoft.SerializeReferenceExtensions.Tests
+{
+    public sealed class DefaultIntrinsicTypePolicyTests
+    {
+        public static IEnumerable<TestCaseData> Cases ()
+        {
+            yield return new TestCaseData(typeof(PublicSerializableClass), true).SetName("Intrinsic_PublicSerializableClass_OK");
+            yield return new TestCaseData(typeof(SerializableStruct), true).SetName("Intrinsic_ValueTypeStruct_OK");
+            yield return new TestCaseData(typeof(Outer.NestedPublicSerializableClass), true).SetName("Intrinsic_NestedPublic_OK");
+            yield return new TestCaseData(Outer.NestedPrivateType, true).SetName("Intrinsic_NestedPrivate_OK");
+
+            yield return new TestCaseData(typeof(InternalSerializableClass), false).SetName("Intrinsic_Internal_NG");
+            yield return new TestCaseData(typeof(AbstractSerializableClass), false).SetName("Intrinsic_Abstract_NG");
+            yield return new TestCaseData(typeof(NonSerializableClass), false).SetName("Intrinsic_NoSerializableAttribute_NG");
+            yield return new TestCaseData(typeof(HiddenSerializableClass), false).SetName("Intrinsic_HideInTypeMenu_NG");
+            yield return new TestCaseData(typeof(UnityObjectDerived), false).SetName("Intrinsic_UnityObjectDerived_NG");
+
+            yield return new TestCaseData(typeof(GenericCandidate<int>), false).SetName("Intrinsic_GenericClosed_NG");
+        }
+
+        [TestCaseSource(nameof(Cases))]
+        public void IsAllowed_MatchesExpected (Type type, bool expected)
+        {
+            bool actual = DefaultIntrinsicTypePolicy.Instance.IsAllowed(type);
+            Assert.That(actual, Is.EqualTo(expected), type.FullName);
+        }
+    }
+}

Assets/MackySoft/MackySoft.SerializeReferenceExtensions/Tests/Editor/DefaultIntrinsicTypePolicyTests.cs.meta

@@ -0,0 +1,20 @@
+using System.Linq;
+using MackySoft.SerializeReferenceExtensions.Editor;
+using NUnit.Framework;
+
+namespace MackySoft.SerializeReferenceExtensions.Tests
+{
+    [TestFixture]
+    public sealed class TypeCandidateService_BaseTypeSelfTests
+    {
+        [Test]
+        public void ConcreteBaseType_IsIncluded ()
+        {
+            var set = TypeSearchService.TypeCandiateService.GetDisplayableTypes(typeof(ConcreteBaseType)).ToHashSet();
+
+            Assert.That(set, Does.Contain(typeof(ConcreteBaseType)));
+            Assert.That(set, Does.Contain(typeof(ConcreteDerivedType)));
+            Assert.That(set, !Does.Contain(typeof(ConcreteInternalDerivedType)));
+        }
+    }
+}

Assets/MackySoft/MackySoft.SerializeReferenceExtensions/Tests/Editor/TypeCandidateService_BaseTypeSelfTests.cs

@@ -0,0 +1,44 @@
+#if UNITY_2023_2_OR_NEWER
+using System.Linq;
+using MackySoft.SerializeReferenceExtensions.Editor;
+using NUnit.Framework;
+
+namespace MackySoft.SerializeReferenceExtensions.Tests
+{
+    [TestFixture]
+    public sealed class TypeCandidateService_GenericVarianceTests
+    {
+        [Test]
+        public void Contravariance_IsSupported ()
+        {
+            // baseType: IContravariance<INetworkActor>
+            var set = TypeSearchService.TypeCandiateService.GetDisplayableTypes(typeof(IContravariant<INetworkActor>)).ToHashSet();
+
+            Assert.That(set, Does.Contain(typeof(Contravariant_NetworkActor)), "Exact match should be included.");
+            Assert.That(set, Does.Contain(typeof(Contravariant_Actor)), "Contravariant match should be included.");
+            Assert.That(set, !Does.Contain(typeof(Contravariant_DerivedNetworkActor)), "Narrower type argument should be excluded.");
+        }
+
+        [Test]
+        public void Covariance_IsSupported ()
+        {
+            // baseType: ICovariant<IActor>
+            var set = TypeSearchService.TypeCandiateService.GetDisplayableTypes(typeof(ICovariant<IActor>)).ToHashSet();
+
+            Assert.That(set, Does.Contain(typeof(Covariant_Actor)), "Exact match should be included.");
+            Assert.That(set, Does.Contain(typeof(Covariant_NetworkActor)), "Covariant match should be included.");
+            Assert.That(set, !Does.Contain(typeof(Covariant_Object)), "Wider type argument should be excluded.");
+        }
+
+        [Test]
+        public void Invariance_RemainsStrict ()
+        {
+            // baseType: IInvariant<IActor>
+            var set = TypeSearchService.TypeCandiateService.GetDisplayableTypes(typeof(IInvariant<IActor>)).ToHashSet();
+
+            Assert.That(set, Does.Contain(typeof(Invariant_Actor)));
+            Assert.That(set, !Does.Contain(typeof(Invariant_NetworkActor)));
+        }
+    }
+}
+#endif

Assets/MackySoft/MackySoft.SerializeReferenceExtensions/Tests/Editor/TypeCandidateService_BaseTypeSelfTests.cs.meta

@@ -0,0 +1,56 @@
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using System.Linq;
+using MackySoft.SerializeReferenceExtensions.Editor;
+using NUnit.Framework;
+
+namespace MackySoft.SerializeReferenceExtensions.Tests
+{
+    [TestFixture]
+    public sealed class TypeCandidateService_NonGenericTests
+    {
+        private HashSet<Type> candidates;
+
+        [OneTimeSetUp]
+        public void OneTimeSetUp ()
+        {
+            candidates = TypeSearchService.TypeCandiateService.GetDisplayableTypes(typeof(ITestBase)).ToHashSet();
+        }
+
+        public static IEnumerable<TestCaseData> Cases ()
+        {
+            yield return new TestCaseData(typeof(PublicSerializableClass), true).SetName("Candidates_ITestBase_PublicSerializable_OK");
+            yield return new TestCaseData(typeof(SerializableStruct), true).SetName("Candidates_ITestBase_ValueTypeStruct_OK");
+            yield return new TestCaseData(typeof(Outer.NestedPublicSerializableClass), true).SetName("Candidates_ITestBase_NestedPublic_OK");
+            yield return new TestCaseData(Outer.NestedPrivateType, true).SetName("Candidates_ITestBase_NestedPrivate_OK");
+
+            yield return new TestCaseData(typeof(InternalSerializableClass), false).SetName("Candidates_ITestBase_Internal_NG");
+            yield return new TestCaseData(typeof(AbstractSerializableClass), false).SetName("Candidates_ITestBase_Abstract_NG");
+            yield return new TestCaseData(typeof(NonSerializableClass), false).SetName("Candidates_ITestBase_NoSerializable_NG");
+            yield return new TestCaseData(typeof(HiddenSerializableClass), false).SetName("Candidates_ITestBase_HideInTypeMenu_NG");
+            yield return new TestCaseData(typeof(UnityObjectDerived), false).SetName("Candidates_ITestBase_UnityObjectDerived_NG");
+            yield return new TestCaseData(typeof(GenericCandidate<int>), false).SetName("Candidates_ITestBase_GenericClosed_NG");
+        }
+
+        [TestCaseSource(nameof(Cases))]
+        public void CandidatesContainment_IsExpected (Type type, bool expected)
+        {
+            if (expected)
+            {
+                Assert.That(candidates, Does.Contain(type), $"Expected to contain: {type.FullName}");
+            }
+            else
+            {
+                Assert.That(candidates, !Does.Contain(type), $"Expected NOT to contain: {type.FullName}");
+            }
+        }
+
+        [Test]
+        public void Candidates_HaveNoDuplicates ()
+        {
+            var list = TypeSearchService.TypeCandiateService.GetDisplayableTypes(typeof(ITestBase)).ToList();
+            Assert.That(list.Count, Is.EqualTo(list.Distinct().Count()));
+        }
+    }
+}

Assets/MackySoft/MackySoft.SerializeReferenceExtensions/Tests/Editor/TypeCandidateService_GenericVarianceTests.cs

@@ -1,8 +1,94 @@
+using System;
 using System.Collections;
-using System.Collections.Generic;
+using System.Reflection;
 using UnityEngine;
 
 namespace MackySoft.SerializeReferenceExtensions.Tests
 {
 
+    public interface ITestBase { }
+
+    [Serializable]
+    public sealed class PublicSerializableClass : ITestBase { }
+
+    [Serializable]
+    internal sealed class InternalSerializableClass : ITestBase { }
+
+    [Serializable]
+    public abstract class AbstractSerializableClass : ITestBase { }
+
+    public sealed class NonSerializableClass : ITestBase { }
+
+    [Serializable, HideInTypeMenu]
+    public sealed class HiddenSerializableClass : ITestBase { }
+
+    [Serializable]
+    public sealed class UnityObjectDerived : ScriptableObject, ITestBase { }
+
+    public sealed class Outer
+    {
+        [Serializable]
+        public sealed class NestedPublicSerializableClass : ITestBase { }
+
+        [Serializable]
+        private sealed class NestedPrivateSerializableClass : ITestBase { }
+
+        public static Type NestedPrivateType => typeof(Outer).GetNestedType(nameof(NestedPrivateSerializableClass), BindingFlags.NonPublic);
+    }
+
+    [Serializable]
+    public sealed class GenericCandidate<T> : ITestBase { }
+
+    [Serializable]
+    public struct SerializableStruct : ITestBase { }
+
+    [Serializable]
+    public class ConcreteBaseType { }
+
+    [Serializable]
+    public sealed class ConcreteDerivedType : ConcreteBaseType { }
+
+    [Serializable]
+    internal sealed class ConcreteInternalDerivedType : ConcreteBaseType { }
+
+    // ------------------------
+    // Generic variance test types (2023.2+)
+    // ------------------------
+    public interface IActor { }
+    public interface INetworkActor : IActor { }
+    public interface IDerivedNetworkActor : INetworkActor { }
+
+    public interface IContravariant<in T> { }
+    public interface ICovariant<out T> { T Create (); }
+    public interface IInvariant<T> { }
+
+    [Serializable]
+    public sealed class Contravariant_Actor : IContravariant<IActor> { }
+
+    [Serializable]
+    public sealed class Contravariant_NetworkActor : IContravariant<INetworkActor> { }
+
+    [Serializable]
+    public sealed class Contravariant_DerivedNetworkActor : IContravariant<IDerivedNetworkActor> { }
+
+    [Serializable]
+    public sealed class Covariant_Actor : ICovariant<IActor> {
+        public IActor Create () => null;
+    }
+
+    [Serializable]
+    public sealed class Covariant_NetworkActor : ICovariant<INetworkActor> {
+        public INetworkActor Create () => null;
+    }
+    
+    [Serializable]
+    public sealed class Covariant_Object : ICovariant<object> {
+        public object Create () => null;
+    }
+
+    [Serializable]
+    public sealed class Invariant_Actor : IInvariant<IActor> { }
+
+    [Serializable]
+    public sealed class Invariant_NetworkActor : IInvariant<INetworkActor> { }
 }