public void AssetReferenceUtilityGetSurrogate_PassNullArgument_ReturnsNull()
        {
            var surrogate = AssetReferenceUtility.GetSurrogate(null);

            Assert.IsNull(surrogate);
            LogAssert.Expect(LogType.Error, "targetType cannot be null");
        }
        static internal List <AssetReferenceUIRestrictionSurrogate> GatherFilters(SerializedProperty property)
        {
            List <AssetReferenceUIRestrictionSurrogate> restrictions = new List <AssetReferenceUIRestrictionSurrogate>();
            var o = property.serializedObject.targetObject;

            if (o != null)
            {
                var       t    = o.GetType();
                FieldInfo info = null;

                // We need to look into sub types, if any.
                string[] pathParts = property.propertyPath.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
                for (int i = 0; i < pathParts.Length; i++)
                {
                    FieldInfo f = t.GetField(pathParts[i],
                                             BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                    if (f != null)
                    {
                        t    = f.FieldType;
                        info = f;
                    }
                }

                if (info != null)
                {
                    var a = info.GetCustomAttributes(false);
                    foreach (var attr in a)
                    {
                        var uiRestriction = attr as AssetReferenceUIRestriction;
                        if (uiRestriction != null)
                        {
                            var surrogate = AssetReferenceUtility.GetSurrogate(uiRestriction.GetType());

                            if (surrogate != null)
                            {
                                var surrogateInstance =
                                    Activator.CreateInstance(surrogate) as AssetReferenceUIRestrictionSurrogate;
                                if (surrogateInstance != null)
                                {
                                    surrogateInstance.Init(uiRestriction);
                                    restrictions.Add(surrogateInstance);
                                }
                            }
                            else
                            {
                                AssetReferenceUIRestrictionSurrogate restriction =
                                    new AssetReferenceUIRestrictionSurrogate();
                                restriction.Init(uiRestriction);
                                restrictions.Add(restriction);
                            }
                        }
                    }
                }
            }

            return(restrictions);
        }
        public void AssetReferenceUIRestriction_Surrogate_Initializes()
        {
            var surrogate = AssetReferenceUtility.GetSurrogate(typeof(AssetReferenceUILabelRestriction));

            Assert.IsNotNull(surrogate);
            var surrogateInstance = Activator.CreateInstance(surrogate) as AssetReferenceUIRestrictionSurrogate;

            Assert.IsNotNull(surrogateInstance);
            surrogateInstance.Init(new AssetReferenceUILabelRestriction());
        }
        public void AssetReferenceUtilityGetSurrogate_IfSurrogateNotStronglyTyped_ReturnsSurrogateLowestInHierarchy()
        {
            var surrogate = AssetReferenceUtility.GetSurrogate(typeof(TestAssetReferenceUICustomRestriction));

            Assert.AreEqual(typeof(TestAssetReferenceUIRestrictionSurrogate3), surrogate);
        }
        public void AssetReferenceUtilityGetSurrogate_IfSurrogateExistsInDifferentAssembly_ReturnsSurrogate()
        {
            var surrogate = AssetReferenceUtility.GetSurrogate(typeof(AssetReferenceUILabelRestriction));

            Assert.AreEqual(typeof(AssetReferenceUILabelRestrictionSurrogate), surrogate);
        }
        public void AssetReferenceUtilityGetSurrogate_PassValidType_ReturnsSurrogate()
        {
            var surrogate = AssetReferenceUtility.GetSurrogate(typeof(AssetReferenceUILabelRestriction));

            Assert.IsNotNull(surrogate);
        }
        public void AssetReferenceUtilityGetSurrogate_PassInvalidType_ReturnsNull()
        {
            var surrogate = AssetReferenceUtility.GetSurrogate(typeof(NUnit.Env));

            Assert.IsNull(surrogate);
        }