Inheritance: IAnalysisLogger
コード例 #1
0
ファイル: RuleTests.cs プロジェクト: mmg1/binskim
        private void VerifyThrows <ExceptionType>(
            BinarySkimmer skimmer,
            bool useDefaultPolicy = false) where ExceptionType : Exception
        {
            var    targets  = new List <string>();
            string ruleName = skimmer.GetType().Name;

            string baseFilesDirectory = GetTestDirectoryFor(ruleName);

            baseFilesDirectory = Path.Combine(Environment.CurrentDirectory, "FunctionalTestsData", baseFilesDirectory);

            string[] testFilesDirectories =
                new string[]
            {
                Path.Combine(baseFilesDirectory, "Pass"),
                Path.Combine(baseFilesDirectory, "Fail"),
                Path.Combine(baseFilesDirectory, "NotApplicable")
            };

            foreach (string testDirectory in testFilesDirectories)
            {
                if (Directory.Exists(testDirectory))
                {
                    foreach (string target in Directory.GetFiles(testDirectory, "*", SearchOption.AllDirectories))
                    {
                        targets.Add(target);
                    }
                }
            }
            var context = new BinaryAnalyzerContext();
            var logger  = new TestMessageLogger();

            context.Logger = logger;
            PropertiesDictionary policy = null;

            if (useDefaultPolicy)
            {
                policy = new PropertiesDictionary();
            }
            context.Policy = policy;

            skimmer.Initialize(context);

            foreach (string target in targets)
            {
                context = this.CreateContext(logger, policy, target);

                context.Rule = skimmer;

                if (skimmer.CanAnalyze(context, out string reasonForNotAnalyzing) != AnalysisApplicability.ApplicableToSpecifiedTarget)
                {
                    continue;
                }
                Assert.Throws <ExceptionType>(() => skimmer.Analyze(context));
            }
        }
コード例 #2
0
ファイル: RuleTests.cs プロジェクト: junk13/binskim
        private BinaryAnalyzerContext CreateContext(TestMessageLogger logger, PropertyBag policy, string target)
        {
            var context = new BinaryAnalyzerContext();

            context.Logger = logger;
            context.Policy = policy;

            if (target != null)
            {
                context.TargetUri = new Uri(target);
            }

            return(context);
        }
コード例 #3
0
ファイル: RuleTests.cs プロジェクト: mmg1/binskim
        private BinaryAnalyzerContext CreateContext(TestMessageLogger logger, PropertiesDictionary policy, string target)
        {
            var context = new BinaryAnalyzerContext
            {
                Logger = logger,
                Policy = policy
            };

            if (target != null)
            {
                context.TargetUri = new Uri(target);
            }

            return(context);
        }
コード例 #4
0
ファイル: RuleTests.cs プロジェクト: junk13/binskim
        private void Verify(
            IBinarySkimmer skimmer,
            IEnumerable <string> additionalTestFiles,
            bool useDefaultPolicy,
            bool expectToPass)
        {
            var    targets            = new List <string>();
            string ruleName           = skimmer.GetType().Name;
            string testFilesDirectory = ruleName;

            testFilesDirectory = Path.Combine(Environment.CurrentDirectory, "FunctionalTestsData", testFilesDirectory);
            testFilesDirectory = Path.Combine(testFilesDirectory, expectToPass ? "Pass" : "Fail");

            Assert.True(Directory.Exists(testFilesDirectory));

            foreach (string target in Directory.GetFiles(testFilesDirectory, "*", SearchOption.AllDirectories))
            {
                if (AnalyzeCommand.ValidAnalysisFileExtensions.Contains(Path.GetExtension(target)))
                {
                    targets.Add(target);
                }
            }

            if (additionalTestFiles != null)
            {
                foreach (string additionalTestFile in additionalTestFiles)
                {
                    targets.Add(additionalTestFile);
                }
            }

            var context = new BinaryAnalyzerContext();
            var logger  = new TestMessageLogger();

            context.Logger = logger;
            PropertyBag policy = null;

            if (useDefaultPolicy)
            {
                policy = new PropertyBag();
            }
            context.Policy = policy;

            skimmer.Initialize(context);

            foreach (string target in targets)
            {
                PE pe = new PE(target);
                if (!pe.IsPEFile)
                {
                    continue;
                }

                context = CreateContext(logger, policy, target);

                context.Rule = skimmer;

                string reasonForNotAnalyzing;
                if (skimmer.CanAnalyze(context, out reasonForNotAnalyzing) != AnalysisApplicability.ApplicableToSpecifiedTarget)
                {
                    continue;
                }

                skimmer.Analyze(context);
            }

            HashSet <string> expected     = expectToPass ? logger.PassTargets : logger.FailTargets;
            HashSet <string> other        = expectToPass ? logger.FailTargets : logger.PassTargets;
            HashSet <string> configErrors = logger.ConfigurationErrorTargets;

            string expectedText = expectToPass ? "success" : "failure";
            string actualText   = expectToPass ? "failed" : "succeeded";
            var    sb           = new StringBuilder();

            foreach (string target in targets)
            {
                if (expected.Contains(target))
                {
                    expected.Remove(target);
                    continue;
                }
                bool missingEntirely = !other.Contains(target);

                if (missingEntirely && !expectToPass && target.Contains("Pdb"))
                {
                    // Missing pdbs provoke configuration errors;
                    if (configErrors.Contains(target))
                    {
                        missingEntirely = false;
                        configErrors.Remove(target);
                        continue;
                    }
                }

                if (missingEntirely)
                {
                    sb.AppendLine("Expected '" + ruleName + "' " + expectedText + " but saw no result at all for file: " + Path.GetFileName(target));
                }
                else
                {
                    other.Remove(target);
                    sb.AppendLine("Expected '" + ruleName + "' " + expectedText + " but check " + actualText + " for: " + Path.GetFileName(target));
                }
            }

            if (sb.Length > 0)
            {
                _testOutputHelper.WriteLine(sb.ToString());
            }

            Assert.Equal(0, sb.Length);
            Assert.Equal(0, expected.Count);
            Assert.Equal(0, other.Count);
        }
コード例 #5
0
ファイル: RuleTests.cs プロジェクト: junk13/binskim
        private void VerifyNotApplicable(
            IBinarySkimmer skimmer,
            HashSet <string> notApplicableConditions,
            AnalysisApplicability expectedApplicability = AnalysisApplicability.NotApplicableToSpecifiedTarget)
        {
            string ruleName           = skimmer.GetType().Name;
            string testFilesDirectory = ruleName;

            testFilesDirectory = Path.Combine(Environment.CurrentDirectory, "FunctionalTestsData", testFilesDirectory);
            testFilesDirectory = Path.Combine(testFilesDirectory, "NotApplicable");

            var context = new BinaryAnalyzerContext();

            HashSet <string> targets = GetTestFilesMatchingConditions(notApplicableConditions);

            if (Directory.Exists(testFilesDirectory))
            {
                foreach (string target in Directory.GetFiles(testFilesDirectory, "*", SearchOption.AllDirectories))
                {
                    if (AnalyzeCommand.ValidAnalysisFileExtensions.Contains(Path.GetExtension(target)))
                    {
                        targets.Add(target);
                    }
                }
            }

            var logger = new TestMessageLogger();

            context.Logger = logger;

            var sb = new StringBuilder();

            foreach (string target in targets)
            {
                string extension = Path.GetExtension(target);
                if (!AnalyzeCommand.ValidAnalysisFileExtensions.Contains(extension))
                {
                    Assert.True(false, "Test file with unexpected extension encountered: " + target);
                }

                context = CreateContext(logger, null, target);
                if (!context.PE.IsPEFile)
                {
                    continue;
                }

                context.Rule = skimmer;

                string reasonForNotAnalyzing;
                AnalysisApplicability applicability;
                applicability = skimmer.CanAnalyze(context, out reasonForNotAnalyzing);
                if (applicability != expectedApplicability)
                {
                    sb.AppendLine("CanAnalyze did not indicate target was invalid for analysis (return was " +
                                  applicability + "): " +
                                  Path.GetFileName(target));
                    continue;
                }
            }

            if (sb.Length > 0)
            {
                _testOutputHelper.WriteLine(sb.ToString());
            }

            Assert.Equal(0, sb.Length);
        }
コード例 #6
0
ファイル: RuleTests.cs プロジェクト: henryzz0/binskim
        private void VerifyApplicability(
            BinarySkimmer skimmer,
            HashSet <string> applicabilityConditions,
            AnalysisApplicability expectedApplicability = AnalysisApplicability.NotApplicableToSpecifiedTarget,
            bool useDefaultPolicy = false)
        {
            string ruleName           = skimmer.GetType().Name;
            string testFilesDirectory = GetTestDirectoryFor(ruleName);

            testFilesDirectory = Path.Combine(Environment.CurrentDirectory, "FunctionalTestsData", testFilesDirectory);
            testFilesDirectory = Path.Combine(testFilesDirectory, "NotApplicable");

            var context = new BinaryAnalyzerContext();

            HashSet <string> targets = this.GetTestFilesMatchingConditions(applicabilityConditions);

            if (Directory.Exists(testFilesDirectory))
            {
                foreach (string target in Directory.GetFiles(testFilesDirectory, "*", SearchOption.AllDirectories))
                {
                    if (AnalyzeCommand.ValidAnalysisFileExtensions.Contains(Path.GetExtension(target)))
                    {
                        targets.Add(target);
                    }
                }
            }

            var logger = new TestMessageLogger();

            context.Logger = logger;

            var sb = new StringBuilder();

            foreach (string target in targets)
            {
                string extension = Path.GetExtension(target);

                context = this.CreateContext(logger, null, target);
                if (!context.IsValidAnalysisTarget)
                {
                    continue;
                }

                if (useDefaultPolicy)
                {
                    context.Policy = new PropertiesDictionary();
                }

                context.Rule = skimmer;

                AnalysisApplicability applicability;
                applicability = skimmer.CanAnalyze(context, out string reasonForNotAnalyzing);
                if (applicability != expectedApplicability)
                {
                    sb.AppendLine("CanAnalyze did not correct indicate target applicability (unexpected return was " +
                                  applicability + "): " +
                                  Path.GetFileName(target));
                    continue;
                }
            }

            if (sb.Length > 0)
            {
                this.testOutputHelper.WriteLine(sb.ToString());
            }

            Assert.Equal(0, sb.Length);
        }