public void Initialize(IAuditor auditor)
        {
            var assemblies = AppDomain.CurrentDomain.GetAssemblies();

            m_Assemblies.Add(assemblies.First(a => a.Location.Contains("UnityEngine.dll")));
            m_Assemblies.Add(assemblies.First(a => a.Location.Contains("UnityEditor.dll")));

            // UnityEditor
            m_ProjectSettingsMapping.Add(new KeyValuePair <string, string>("UnityEditor.PlayerSettings",
                                                                           "Project/Player"));
            m_ProjectSettingsMapping.Add(
                new KeyValuePair <string, string>("UnityEditor.Rendering.EditorGraphicsSettings", "Project/Graphics"));

            // UnityEngine
            m_ProjectSettingsMapping.Add(new KeyValuePair <string, string>("UnityEngine.Physics", "Project/Physics"));
            m_ProjectSettingsMapping.Add(
                new KeyValuePair <string, string>("UnityEngine.Physics2D", "Project/Physics 2D"));
            m_ProjectSettingsMapping.Add(new KeyValuePair <string, string>("UnityEngine.Time", "Project/Time"));
            m_ProjectSettingsMapping.Add(new KeyValuePair <string, string>("UnityEngine.QualitySettings",
                                                                           "Project/Quality"));

            m_ProblemDescriptors = ProblemDescriptorLoader.LoadFromJson(ProjectAuditor.DataPath, "ProjectSettings");
            foreach (var descriptor in m_ProblemDescriptors)
            {
                auditor.RegisterDescriptor(descriptor);
            }
        }
        public void Reload(string path)
        {
            m_ProblemDescriptors = ProblemDescriptorLoader.LoadFromJson(path, "ProjectSettings");

            foreach (var type in AssemblyHelper.GetAllTypesInheritedFromInterface <ISettingsAnalyzer>())
            {
                AddAnalyzer(Activator.CreateInstance(type) as ISettingsAnalyzer);
            }
        }
        public void ProblemDescriptorAnyPlatform()
        {
            var desc = new ProblemDescriptor
                       (
                102001,
                "test",
                new[] { Area.CPU }
                       );

            Assert.True(ProblemDescriptorLoader.IsPlatformCompatible(desc));
        }
        public void ProblemDescriptorUnsupportedPlatform()
        {
            var desc = new ProblemDescriptor
                       (
                102001,
                "test",
                new[] { Area.CPU }
                       )
            {
                platforms = new[] { BuildTarget.Android.ToString() }  // assuming Android is not installed by default
            };

            Assert.False(ProblemDescriptorLoader.IsPlatformCompatible(desc));
        }
Beispiel #5
0
        public void ProblemDescriptorVersionIsCompatible()
        {
            var desc = new ProblemDescriptor
                       (
                102001,
                "test",
                Area.CPU,
                "this is not actually a problem",
                "do nothing"
                       );

            // check default values
            Assert.True(ProblemDescriptorLoader.IsVersionCompatible(desc));

            desc.minimumVersion = string.Empty;
            desc.maximumVersion = string.Empty;
            Assert.True(ProblemDescriptorLoader.IsVersionCompatible(desc));

            desc.minimumVersion = "0.0";
            desc.maximumVersion = null;
            Assert.True(ProblemDescriptorLoader.IsVersionCompatible(desc));

            desc.minimumVersion = null;
            desc.maximumVersion = "0.0";
            Assert.False(ProblemDescriptorLoader.IsVersionCompatible(desc));

            desc.minimumVersion = null;
            desc.maximumVersion = "9999.9";
            Assert.True(ProblemDescriptorLoader.IsVersionCompatible(desc));

            desc.minimumVersion = "9999.9";
            desc.maximumVersion = null;
            Assert.False(ProblemDescriptorLoader.IsVersionCompatible(desc));

            desc.minimumVersion = InternalEditorUtility.GetUnityVersion().ToString();
            desc.maximumVersion = null;
            Assert.True(ProblemDescriptorLoader.IsVersionCompatible(desc));

            desc.minimumVersion = null;
            desc.maximumVersion = InternalEditorUtility.GetUnityVersion().ToString();
            Assert.True(ProblemDescriptorLoader.IsVersionCompatible(desc));

            desc.minimumVersion = "1.1";
            desc.maximumVersion = "1.0";
            var result = ProblemDescriptorLoader.IsVersionCompatible(desc);

            LogAssert.Expect(LogType.Error, "Descriptor (102001) minimumVersion (1.1) is greater than maximumVersion (1.0).");
            Assert.False(result);
        }
        public void ProblemDescriptorSupportedPlatform()
        {
            var desc = new ProblemDescriptor
                       (
                102001,
                "test",
                new[] { Area.CPU }
                       )
            {
#if UNITY_EDITOR_WIN
                platforms = new[] { BuildTarget.StandaloneWindows64.ToString() }
#else
                platforms = new[] { BuildTarget.StandaloneOSX.ToString() }
#endif
            };

            Assert.True(ProblemDescriptorLoader.IsPlatformCompatible(desc));
        }
Beispiel #7
0
        Dictionary <string, ProblemDescriptor> m_WholeNamespaceDescriptors; // namespace as key

        public void Initialize(IAuditor auditor)
        {
            var descriptors = ProblemDescriptorLoader.LoadFromJson(ProjectAuditor.DataPath, "ApiDatabase");

            foreach (var descriptor in descriptors)
            {
                auditor.RegisterDescriptor(descriptor);
            }

            var methodDescriptors = descriptors.Where(descriptor => !descriptor.method.Equals("*") && !string.IsNullOrEmpty(descriptor.type));

            m_Descriptors = new Dictionary <string, List <ProblemDescriptor> >();
            foreach (var d in methodDescriptors)
            {
                if (!m_Descriptors.ContainsKey(d.method))
                {
                    m_Descriptors.Add(d.method, new List <ProblemDescriptor>());
                }
                m_Descriptors[d.method].Add(d);
            }

            m_WholeNamespaceDescriptors = auditor.GetDescriptors().Where(descriptor => descriptor.method.Equals("*")).ToDictionary(d => d.type);
        }