private void ExceptionTestHelper( ExceptionCondition exceptionCondition, RuntimeConditions runtimeConditions, ExitReason expectedExitReason = ExitReason.None, TestAnalyzeOptions analyzeOptions = null) { ExceptionRaisingRule.s_exceptionCondition = exceptionCondition; analyzeOptions = analyzeOptions ?? new TestAnalyzeOptions() { TargetFileSpecifiers = new string[0] }; analyzeOptions.Quiet = true; var command = new TestAnalyzeCommand(); Assembly[] plugInAssemblies = null; if (analyzeOptions.DefaultPlugInFilePaths != null) { var assemblies = new List <Assembly>(); foreach (string plugInFilePath in analyzeOptions.DefaultPlugInFilePaths) { assemblies.Add(Assembly.LoadFrom(plugInFilePath)); } plugInAssemblies = new Assembly[assemblies.Count]; assemblies.CopyTo(plugInAssemblies, 0); } else { plugInAssemblies = new Assembly[] { typeof(ExceptionRaisingRule).Assembly }; } command.DefaultPlugInAssemblies = plugInAssemblies; int result = command.Run(analyzeOptions); int expectedResult = (runtimeConditions & ~RuntimeConditions.Nonfatal) == RuntimeConditions.None ? TestAnalyzeCommand.SUCCESS : TestAnalyzeCommand.FAILURE; Assert.Equal(runtimeConditions, command.RuntimeErrors); Assert.Equal(expectedResult, result); if (expectedExitReason != ExitReason.None) { Assert.NotNull(command.ExecutionException); if (expectedExitReason != ExitReason.UnhandledExceptionInEngine) { var eax = command.ExecutionException as ExitApplicationException <ExitReason>; Assert.NotNull(eax); } } else { Assert.Null(command.ExecutionException); } ExceptionRaisingRule.s_exceptionCondition = ExceptionCondition.None; }
public void AnalyzeCommandBase_LoadConfigurationFile(string configValue, bool defaultFileExists, string expectedFileName) { var options = new TestAnalyzeOptions { TargetFileSpecifiers = new string[] { "" }, Verbose = true, Quiet = true, DataToInsert = new OptionallyEmittedData[] { OptionallyEmittedData.Hashes }, ConfigurationFilePath = configValue, Recurse = true, OutputFilePath = "", }; var mockFileSystem = new Mock <IFileSystem>(); mockFileSystem.Setup(x => x.FileExists(It.IsAny <string>())).Returns(defaultFileExists); var command = new TestAnalyzeCommand(mockFileSystem.Object); string fileName = command.GetConfigurationFileName(options); if (string.IsNullOrEmpty(expectedFileName)) { fileName.Should().BeNull(); } else { fileName.Should().EndWith(expectedFileName); } }
private static SarifLog RunAnalyzeCommand(TestAnalyzeOptions options, IFileSystem fileSystem, int expectedReturnCode) { // If no log file is specified, we will convert the console output into a log file bool captureConsoleOutput = string.IsNullOrEmpty(options.OutputFilePath); var command = new TestAnalyzeCommand(fileSystem) { _captureConsoleOutput = captureConsoleOutput }; command.DefaultPlugInAssemblies = new Assembly[] { typeof(AnalyzeCommandBaseTests).Assembly }; try { HashUtilities.FileSystem = fileSystem; command.Run(options).Should().Be(expectedReturnCode); } finally { HashUtilities.FileSystem = null; } return(captureConsoleOutput ? ConvertConsoleOutputToSarifLog(command._consoleLogger.CapturedOutput) : JsonConvert.DeserializeObject <SarifLog>(File.ReadAllText(options.OutputFilePath))); }
public void IOExceptionRaisedCreatingSarifLog() { string path = Path.GetTempFileName(); try { using (var stream = File.OpenWrite(path)) { // our log file is locked for write // causing exceptions at analysis time var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { GetThisTestAssemblyFilePath() }, OutputFilePath = path, Verbose = true, }; ExceptionTestHelper( ExceptionCondition.None, RuntimeConditions.ExceptionCreatingLogFile, expectedExitReason: ExitReason.ExceptionCreatingLogFile, analyzeOptions: options); } } finally { File.Delete(path); } }
public void ConvertingAnalyzeOptionsToLoggingOptions_ProducesExpectedLoggingOptions() { LoggingOptions loggingOptions; TestAnalyzeOptions analyzeOptions = new TestAnalyzeOptions() { Verbose = true }; loggingOptions = analyzeOptions.ConvertToLoggingOptions(); loggingOptions.Should().Be(LoggingOptions.Verbose); analyzeOptions = new TestAnalyzeOptions() { PrettyPrint = true }; loggingOptions = analyzeOptions.ConvertToLoggingOptions(); loggingOptions.Should().Be(LoggingOptions.PrettyPrint); analyzeOptions = new TestAnalyzeOptions() { Force = true }; loggingOptions = analyzeOptions.ConvertToLoggingOptions(); loggingOptions.Should().Be(LoggingOptions.OverwriteExistingOutputFile); }
public void MissingOutputFile() { string path = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData); path = Path.Combine(path, Guid.NewGuid().ToString()); try { var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { GetThisTestAssemblyFilePath() }, OutputFilePath = path, Verbose = true, }; // A missing output file is a good condition. :) ExceptionTestHelper( ExceptionCondition.None, RuntimeConditions.None, expectedExitReason: ExitReason.None, analyzeOptions: options); } finally { if (File.Exists(path)) { File.Delete(path); } } }
public void AnalyzeCommand_ReportsWarningOnUnsupportedPlatformForRuleAndNoRulesLoaded() { PropertiesDictionary allRulesDisabledConfiguration = ExportConfigurationCommandBaseTests.s_allRulesDisabledConfiguration; string path = Path.GetTempFileName() + ".xml"; try { allRulesDisabledConfiguration.SaveToXml(path); var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { GetThisTestAssemblyFilePath() }, ConfigurationFilePath = path }; // There are two default rules.One of which is disabled by configuration, // the other is disabled as unsupported on current platform. ExceptionTestHelper( ExceptionCondition.InvalidPlatform, RuntimeConditions.NoRulesLoaded | RuntimeConditions.RuleWasExplicitlyDisabled | RuntimeConditions.RuleCannotRunOnPlatform, expectedExitReason: ExitReason.NoRulesLoaded, analyzeOptions: options); } finally { if (File.Exists(path)) { File.Delete(path); } } }
public void AnalyzeCommand_LoadConfigurationFile(string configValue, bool defaultFileExists, string expectedFileName) { var options = new TestAnalyzeOptions { TargetFileSpecifiers = new string[] { "" }, Verbose = true, Statistics = true, Quiet = true, ComputeFileHashes = true, ConfigurationFilePath = configValue, Recurse = true, OutputFilePath = "", }; var command = new TestAnalyzeCommand(); string fileName = command.GetConfigurationFileName(options, defaultFileExists); if (string.IsNullOrEmpty(expectedFileName)) { fileName.Should().BeNull(); } else { fileName.Should().EndWith(expectedFileName); } }
public void ConvertAnalyzeOptionsToLoggingOptions() { LoggingOptions loggingOptions; var analyzeOptions = new TestAnalyzeOptions() { ComputeFileHashes = true }; loggingOptions = analyzeOptions.ConvertToLoggingOptions(); loggingOptions.Should().Be(LoggingOptions.ComputeFileHashes); analyzeOptions = new TestAnalyzeOptions() { LogEnvironment = true }; loggingOptions = analyzeOptions.ConvertToLoggingOptions(); loggingOptions.Should().Be(LoggingOptions.PersistEnvironment); analyzeOptions = new TestAnalyzeOptions() { PersistFileContents = true }; loggingOptions = analyzeOptions.ConvertToLoggingOptions(); loggingOptions.Should().Be(LoggingOptions.PersistFileContents); analyzeOptions = new TestAnalyzeOptions() { Verbose = true }; loggingOptions = analyzeOptions.ConvertToLoggingOptions(); loggingOptions.Should().Be(LoggingOptions.Verbose); }
private static void RunResultsCachingTestCase(ResultsCachingTestCase testCase) { // This makes sure that we will reinitialize the mock file system. This // allows callers to reuse test case instances, by adjusting specific // property values. The mock file system cannot be reused in this way, once // a test executes, it must be reset. testCase.FileSystem = null; var options = new TestAnalyzeOptions { TestRuleBehaviors = testCase.TestRuleBehaviors, OutputFilePath = testCase.PersistLogFileToDisk ? Guid.NewGuid().ToString() : null, TargetFileSpecifiers = new string[] { Guid.NewGuid().ToString() }, Verbose = testCase.Verbose, }; int expectedResultsCount = testCase.ExpectedWarningCount + testCase.ExpectedErrorCount; Run runWithoutCaching = RunAnalyzeCommand(options, testCase); options.DataToInsert = new OptionallyEmittedData[] { OptionallyEmittedData.Hashes }; Run runWithCaching = RunAnalyzeCommand(options, testCase); // Core static analysis results runWithCaching.Results.Should().BeEquivalentTo(runWithoutCaching.Results); // Tool configuration errors, such as 'Could not locate scan target PDB.' runWithoutCaching.Invocations?[0].ToolConfigurationNotifications?.Should() .BeEquivalentTo(runWithCaching.Invocations?[0].ToolConfigurationNotifications); // Not yet explicitly tested runWithoutCaching.Invocations?[0].ToolExecutionNotifications?.Should() .BeEquivalentTo(runWithCaching.Invocations?[0].ToolExecutionNotifications); }
private static Run RunTest(IFileSystem fileSystem, TestAnalyzeOptions options, int expectedResultsCount, int expectedReturnCode = 0) { SarifLog sarifLog = RunAnalyzeCommand(options, fileSystem, expectedReturnCode); Run run = sarifLog.Runs[0]; IList <Result> results = run.Results; results.Count.Should().Be(expectedResultsCount); return(run); }
public void AnalyzeCommandBase_ReportsErrorOnInvalidInvocationPropertyName() { var options = new TestAnalyzeOptions() { InvocationPropertiesToLog = new string[] { "CommandLine", "NoSuchProperty" } }; ExceptionTestHelper( RuntimeConditions.InvalidCommandLineOption, expectedExitReason: ExitReason.InvalidCommandLineOption, analyzeOptions: options); }
public void NotApplicableToTarget() { var options = new TestAnalyzeOptions() { TestRuleBehaviors = TestRuleBehaviors.RegardAnalysisTargetAsNotApplicable, TargetFileSpecifiers = new string[] { GetThisTestAssemblyFilePath() } }; ExceptionTestHelper( RuntimeConditions.RuleNotApplicableToTarget, analyzeOptions: options); }
public void ExceptionLoadingTarget() { var options = new TestAnalyzeOptions() { TestRuleBehaviors = TestRuleBehaviors.RegardAnalysisTargetAsCorrupted, TargetFileSpecifiers = new string[] { GetThisTestAssemblyFilePath() } }; ExceptionTestHelper( RuntimeConditions.ExceptionLoadingTargetFile, analyzeOptions: options); }
public void InvalidTarget() { var options = new TestAnalyzeOptions() { TestRuleBehaviors = TestRuleBehaviors.RegardAnalysisTargetAsInvalid, TargetFileSpecifiers = new string[] { GetThisTestAssemblyFilePath() }, }; ExceptionTestHelper( RuntimeConditions.TargetNotValidToAnalyze, analyzeOptions: options); }
public void ParseTargetException() { var options = new TestAnalyzeOptions() { TestRuleBehaviors = TestRuleBehaviors.RaiseTargetParseError, TargetFileSpecifiers = new string[] { GetThisTestAssemblyFilePath() }, }; ExceptionTestHelper( RuntimeConditions.TargetParseError, analyzeOptions: options ); }
public void ExceptionRaisedInvokingCanAnalyze() { var options = new TestAnalyzeOptions() { TestRuleBehaviors = TestRuleBehaviors.RaiseExceptionInvokingCanAnalyze, TargetFileSpecifiers = new string[] { GetThisTestAssemblyFilePath() }, }; ExceptionTestHelper( RuntimeConditions.ExceptionRaisedInSkimmerCanAnalyze, analyzeOptions: options ); }
public void ExceptionRaisedInvokingCanAnalyze() { var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { this.GetType().Assembly.Location }, }; ExceptionTestHelper( ExceptionCondition.InvokingCanAnalyze, RuntimeConditions.ExceptionRaisedInSkimmerCanAnalyze, analyzeOptions: options ); }
public void ParseTargetException() { var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { this.GetType().Assembly.Location }, }; ExceptionTestHelper( ExceptionCondition.ParsingTarget, RuntimeConditions.TargetParseError, analyzeOptions: options ); }
public void LoadPdbException() { var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { this.GetType().Assembly.Location }, }; ExceptionTestHelper( ExceptionCondition.LoadingPdb, RuntimeConditions.ExceptionLoadingPdb, analyzeOptions: options ); }
public void ExceptionLoadingTarget() { var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { GetThisTestAssemblyFilePath() }, RegardAnalysisTargetAsCorrupted = true }; ExceptionTestHelper( ExceptionCondition.None, RuntimeConditions.ExceptionLoadingTargetFile, analyzeOptions: options); }
public void ExceptionRaisedInstantiatingSkimmers() { var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { GetThisTestAssemblyFilePath() }, }; ExceptionTestHelper( ExceptionCondition.InvokingConstructor, RuntimeConditions.ExceptionInstantiatingSkimmers, ExitReason.UnhandledExceptionInstantiatingSkimmers, analyzeOptions: options); }
public void LoadPdbException() { var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { GetThisTestAssemblyFilePath() }, }; ExceptionTestHelper( ExceptionCondition.LoadingPdb, RuntimeConditions.ExceptionLoadingPdb, analyzeOptions: options ); }
public void ParseTargetException() { var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { GetThisTestAssemblyFilePath() }, }; ExceptionTestHelper( ExceptionCondition.ParsingTarget, RuntimeConditions.TargetParseError, analyzeOptions: options ); }
public void ExceptionRaisedInvokingAnalyze() { var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { GetThisTestAssemblyFilePath() }, }; ExceptionTestHelper( ExceptionCondition.InvokingAnalyze, RuntimeConditions.ExceptionInSkimmerAnalyze, analyzeOptions: options ); }
public void InvalidCommandLineOption() { var options = new TestAnalyzeOptions { RegardOptionsAsInvalid = true }; ExceptionTestHelper( ExceptionCondition.ValidatingOptions, RuntimeConditions.InvalidCommandLineOption, ExitReason.InvalidCommandLineOption, options); }
public void InvalidTarget() { var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { GetThisTestAssemblyFilePath() }, RegardAnalysisTargetAsValid = false }; ExceptionTestHelper( ExceptionCondition.None, RuntimeConditions.TargetNotValidToAnalyze, analyzeOptions: options); }
public void NotApplicableToTarget() { var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { GetThisTestAssemblyFilePath() }, RegardAnalysisTargetAsNotApplicable = true }; ExceptionTestHelper( ExceptionCondition.None, RuntimeConditions.RuleNotApplicableToTarget, analyzeOptions: options); }
public void FileUri() { Uri uri = new Uri(this.GetType().Assembly.Location); var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { uri.ToString() }, }; ExceptionTestHelper( RuntimeConditions.None, analyzeOptions: options ); }
public Run AnalyzeFile( string fileName, string configFileName = null, RuntimeConditions runtimeConditions = RuntimeConditions.None, int expectedReturnCode = TestAnalyzeCommand.SUCCESS) { string path = Path.GetTempFileName(); Run run = null; try { var options = new TestAnalyzeOptions { TargetFileSpecifiers = new string[] { fileName }, Verbose = true, Statistics = true, Quiet = true, ComputeFileHashes = true, ConfigurationFilePath = configFileName ?? TestAnalyzeCommand.DefaultPolicyName, Recurse = true, OutputFilePath = path, SarifVersion = SarifVersion.TwoZeroZero }; var command = new TestAnalyzeCommand(); command.DefaultPlugInAssemblies = new Assembly[] { this.GetType().Assembly }; int result = command.Run(options); result.Should().Be(expectedReturnCode); command.RuntimeErrors.Should().Be(runtimeConditions); JsonSerializerSettings settings = new JsonSerializerSettings() { ContractResolver = SarifContractResolver.Instance }; SarifLog log = JsonConvert.DeserializeObject <SarifLog>(File.ReadAllText(path), settings); Assert.NotNull(log); Assert.Equal <int>(1, log.Runs.Count); run = log.Runs.First(); } finally { File.Delete(path); } return(run); }
public Run AnalyzeFile(string fileName) { string path = Path.GetTempFileName(); Run run = null; try { var options = new TestAnalyzeOptions { TargetFileSpecifiers = new string[] { fileName }, Verbose = true, Statistics = true, Quiet = true, ComputeTargetsHash = true, ConfigurationFilePath = TestAnalyzeCommand.DEFAULT_POLICY_NAME, Recurse = true, OutputFilePath = path, }; var command = new TestAnalyzeCommand(); command.DefaultPlugInAssemblies = new Assembly[] { this.GetType().Assembly }; int result = command.Run(options); Assert.Equal(TestAnalyzeCommand.SUCCESS, result); JsonSerializerSettings settings = new JsonSerializerSettings() { ContractResolver = SarifContractResolver.Instance }; SarifLog log = JsonConvert.DeserializeObject<SarifLog>(File.ReadAllText(path), settings); Assert.NotNull(log); Assert.Equal<int>(1, log.Runs.Count); run = log.Runs.First(); } finally { File.Delete(path); } return run; }
public void FileUri() { Uri uri = new Uri(this.GetType().Assembly.Location); var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { uri.ToString() }, }; ExceptionTestHelper( ExceptionCondition.None, RuntimeConditions.None, analyzeOptions: options ); }
public void UnauthorizedAccessExceptionCreatingSarifLog() { string path = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData); path = Path.Combine(path, Guid.NewGuid().ToString()); using (var stream = File.Create(path, 1, FileOptions.DeleteOnClose)) { // attempt to persist to unauthorized location will raise exception var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { this.GetType().Assembly.Location }, OutputFilePath = path, Verbose = true, }; ExceptionTestHelper( ExceptionCondition.None, RuntimeConditions.ExceptionCreatingLogFile, expectedExitReason: ExitReason.ExceptionCreatingLogFile, analyzeOptions: options); } }
public void NotApplicableToTarget() { var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { this.GetType().Assembly.Location }, RegardAnalysisTargetAsNotApplicable = true }; ExceptionTestHelper( ExceptionCondition.None, RuntimeConditions.RuleNotApplicableToTarget, analyzeOptions: options); }
public void MissingPlugInFile() { string path = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData); path = Path.Combine(path, Guid.NewGuid().ToString()); var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { this.GetType().Assembly.Location }, PluginFilePaths = new string[] { path }, Verbose = true, }; ExceptionTestHelper( ExceptionCondition.None, RuntimeConditions.MissingFile, expectedExitReason: ExitReason.InvalidCommandLineOption, analyzeOptions: options); }
public void InvalidTarget() { var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { this.GetType().Assembly.Location }, RegardAnalysisTargetAsValid = false }; ExceptionTestHelper( ExceptionCondition.None, RuntimeConditions.TargetNotValidToAnalyze, analyzeOptions: options); }
public void IOExceptionRaisedCreatingSarifLog() { string path = Path.GetTempFileName(); try { using (var stream = File.OpenWrite(path)) { // our log file is locked for write // causing exceptions at analysis time var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { this.GetType().Assembly.Location }, OutputFilePath = path, Verbose = true, }; ExceptionTestHelper( ExceptionCondition.None, RuntimeConditions.ExceptionCreatingLogFile, expectedExitReason: ExitReason.ExceptionCreatingLogFile, analyzeOptions: options); } } finally { File.Delete(path); } }
public void MissingOutputFile() { string path = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData); path = Path.Combine(path, Guid.NewGuid().ToString()); try { var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { this.GetType().Assembly.Location }, OutputFilePath = path, Verbose = true, }; // A missing output file is a good condition. :) ExceptionTestHelper( ExceptionCondition.None, RuntimeConditions.None, expectedExitReason: ExitReason.None, analyzeOptions: options); } finally { if (File.Exists(path)) { File.Delete(path); } } }
public void ExceptionRaisedInEngine() { TestAnalyzeCommand.RaiseUnhandledExceptionInDriverCode = true; var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { this.GetType().Assembly.Location }, }; ExceptionTestHelper( ExceptionCondition.None, RuntimeConditions.ExceptionInEngine, ExitReason.UnhandledExceptionInEngine, analyzeOptions : options); TestAnalyzeCommand.RaiseUnhandledExceptionInDriverCode = false; }
public void ExceptionRaisedInvokingInitialize() { var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { this.GetType().Assembly.Location }, }; ExceptionTestHelper( ExceptionCondition.InvokingInitialize, RuntimeConditions.ExceptionInSkimmerInitialize, analyzeOptions: options ); }
public void ExceptionLoadingTarget() { var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { this.GetType().Assembly.Location }, RegardAnalysisTargetAsCorrupted = true }; ExceptionTestHelper( ExceptionCondition.None, RuntimeConditions.ExceptionLoadingTargetFile, analyzeOptions: options); }
public void ExceptionRaisedInstantiatingSkimmers() { var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { this.GetType().Assembly.Location }, }; ExceptionTestHelper( ExceptionCondition.InvokingConstructor, RuntimeConditions.ExceptionInstantiatingSkimmers, ExitReason.UnhandledExceptionInstantiatingSkimmers, analyzeOptions : options); }
private void ExceptionTestHelper( ExceptionCondition exceptionCondition, RuntimeConditions runtimeConditions, ExitReason expectedExitReason = ExitReason.None, TestAnalyzeOptions analyzeOptions = null) { ExceptionRaisingRule.s_exceptionCondition = exceptionCondition; analyzeOptions = analyzeOptions ?? new TestAnalyzeOptions() { TargetFileSpecifiers = new string[0] }; analyzeOptions.Quiet = true; var command = new TestAnalyzeCommand(); Assembly[] plugInAssemblies = null; if (analyzeOptions.DefaultPlugInFilePaths != null) { var assemblies = new List<Assembly>(); foreach (string plugInFilePath in analyzeOptions.DefaultPlugInFilePaths) { assemblies.Add(Assembly.LoadFrom(plugInFilePath)); } plugInAssemblies = new Assembly[assemblies.Count]; assemblies.CopyTo(plugInAssemblies, 0); } else { plugInAssemblies = new Assembly[] { typeof(ExceptionRaisingRule).Assembly }; } command.DefaultPlugInAssemblies = plugInAssemblies; int result = command.Run(analyzeOptions); int expectedResult = (runtimeConditions & ~RuntimeConditions.Nonfatal) == RuntimeConditions.None ? TestAnalyzeCommand.SUCCESS : TestAnalyzeCommand.FAILURE; Assert.Equal(runtimeConditions, command.RuntimeErrors); Assert.Equal(expectedResult, result); if (expectedExitReason != ExitReason.None) { Assert.NotNull(command.ExecutionException); if (expectedExitReason != ExitReason.UnhandledExceptionInEngine) { var eax = command.ExecutionException as ExitApplicationException<ExitReason>; Assert.NotNull(eax); } } else { Assert.Null(command.ExecutionException); } ExceptionRaisingRule.s_exceptionCondition = ExceptionCondition.None; }
public void MissingRequiredConfiguration() { var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { this.GetType().Assembly.Location }, RegardRequiredConfigurationAsMissing = true }; ExceptionTestHelper( ExceptionCondition.None, RuntimeConditions.RuleMissingRequiredConfiguration, analyzeOptions: options); }
public void NoRulesLoaded() { var options = new TestAnalyzeOptions() { TargetFileSpecifiers = new string[] { this.GetType().Assembly.Location }, DefaultPlugInFilePaths = new string[] { typeof(string).Assembly.Location }, }; ExceptionTestHelper( ExceptionCondition.None, RuntimeConditions.NoRulesLoaded, ExitReason.NoRulesLoaded, analyzeOptions : options ); }