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 InvalidCommandLineOption()
{
var options = new TestAnalyzeOptions
{
RegardOptionsAsInvalid = true
};
ExceptionTestHelper(
ExceptionCondition.ValidatingOptions,
RuntimeConditions.InvalidCommandLineOption,
ExitReason.InvalidCommandLineOption,
options);
}
public void ParseTargetException()
{
var options = new TestAnalyzeOptions()
{
TargetFileSpecifiers = new string[] { this.GetType().Assembly.Location },
};
ExceptionTestHelper(
ExceptionCondition.ParsingTarget,
RuntimeConditions.TargetParseError,
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 LoadPdbException()
{
var options = new TestAnalyzeOptions()
{
TargetFileSpecifiers = new string[] { this.GetType().Assembly.Location },
};
ExceptionTestHelper(
ExceptionCondition.LoadingPdb,
RuntimeConditions.ExceptionLoadingPdb,
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
);
}