private static object[] BuildDefaultTestCase(FailureLevel level, ResultKind kind = ResultKind.Fail)
{
string lineLabel = level != FailureLevel.None
? level.ToString().ToLowerInvariant()
: kind.ToString().ToLowerInvariant();
if (kind == ResultKind.Informational)
{
// Console reporting historically abbreviates this term
lineLabel = "info";
}
if (level == FailureLevel.None && kind == ResultKind.None)
{
// No good information? Mark it as informational.
lineLabel = "info";
}
return(new object[]
{
level,
kind,
MultiLineTestRegion,
$"{TestData.TestAnalysisTarget}(2,4,3,5): {lineLabel} {TestData.TestRuleId}: First: 42, Second: 54",
TestData.TestAnalysisTarget
});
}
internal static Result CreateResult(FailureLevel level, ResultKind kind, Region region, string path)
{
return(new Result
{
RuleId = TestRuleId,
Level = level,
Kind = kind,
Locations = new List <Location>
{
new Location
{
PhysicalLocation = new PhysicalLocation
{
ArtifactLocation = new ArtifactLocation
{
Uri = new Uri(path, UriKind.RelativeOrAbsolute)
},
Region = region
}
}
},
Message = new Message
{
Arguments = new List <string>
{
"42",
"54"
},
Id = TestMessageStringId
}
});
}
/// <summary>
/// Constructs a new RecognitionResult.
/// </summary>
public RecognitionResult()
{
TypeKind = ResultKind.RecognitionUnavailable;
ResultDetailKinds = new ResultDetailKind[0];
AudioMeasure = new AudioQuality();
Message = string.Empty;
}
private static FailureLevel GetFailureLevelFrom(string level, out ResultKind resultKind)
{
resultKind = ResultKind.Fail;
FailureLevel failureLevel = FailureLevel.None;
switch (level)
{
// Failure cases. ResultKind.Fail + specific failure level
case "warning": { failureLevel = FailureLevel.Warning; break; }
case "error": { failureLevel = FailureLevel.Error; break; }
case "note": { failureLevel = FailureLevel.Note; break; }
// Non-failure cases. FailureLevel.None + specific result kind
case "notapplicable": { resultKind = ResultKind.NotApplicable; break; }
case "info": { resultKind = ResultKind.Informational; break; }
case "pass": { resultKind = ResultKind.Pass; break; }
case "review": { resultKind = ResultKind.Review; break; }
case "open": { resultKind = ResultKind.Open; break; }
default: { failureLevel = FailureLevel.Warning; break; }
}
return(failureLevel);
}
public void Log(ResultKind messageKind, IAnalysisContext context, string message)
{
switch (messageKind)
{
case ResultKind.Pass:
{
PassTargets.Add(context.TargetUri.LocalPath);
break;
}
case ResultKind.Error:
{
FailTargets.Add(context.TargetUri.LocalPath);
break;
}
case ResultKind.NotApplicable:
{
NotApplicableTargets.Add(context.TargetUri.LocalPath);
break;
}
case ResultKind.Note:
case ResultKind.InternalError:
case ResultKind.ConfigurationError:
{
throw new NotImplementedException();
}
default:
{
throw new InvalidOperationException();
}
}
}
public void Log(ResultKind messageKind, IAnalysisContext context, Region region, string formatSpecifierId, params string[] arguments)
{
foreach (IResultLogger logger in Loggers)
{
logger.Log(messageKind, context, region, formatSpecifierId, arguments);
}
}
public void NoteTestResult(ResultKind messageKind, string targetPath)
{
switch (messageKind)
{
case ResultKind.Pass:
{
PassTargets.Add(targetPath);
break;
}
case ResultKind.Error:
{
FailTargets.Add(targetPath);
break;
}
case ResultKind.NotApplicable:
{
NotApplicableTargets.Add(targetPath);
break;
}
case ResultKind.Note:
case ResultKind.InternalError:
case ResultKind.ConfigurationError:
{
throw new NotImplementedException();
}
default:
{
throw new InvalidOperationException();
}
}
}
private void WriteJsonIssue(string binary, string ruleId, string message, ResultKind issueKind)
{
Result result = new Result();
result.RuleId = ruleId;
result.FullMessage = message;
result.Kind = issueKind;
result.Locations = new[] {
new Sarif.Sdk.Location {
AnalysisTarget = new[]
{
new PhysicalLocationComponent
{
// Why? When NewtonSoft serializes this Uri, it will use the
// original string used to construct the Uri. For a file path,
// this will be the local file path. We want to persist this
// information using the file:// protocol rendering, however.
Uri = binary.CreateUriForJsonSerialization(),
MimeType = MimeType.Binary
}
}
}
};
_issueLogJsonWriter.WriteResult(result);
}
public void Log(ResultKind messageKind, IAnalysisContext context, string message)
{
switch (messageKind)
{
case ResultKind.Pass:
{
PassTargets.Add(context.TargetUri.LocalPath);
break;
}
case ResultKind.Error:
{
FailTargets.Add(context.TargetUri.LocalPath);
break;
}
case ResultKind.NotApplicable:
{
NotApplicableTargets.Add(context.TargetUri.LocalPath);
break;
}
case ResultKind.Note:
case ResultKind.InternalError:
case ResultKind.ConfigurationError:
{
throw new NotImplementedException();
}
default:
{
throw new InvalidOperationException();
}
}
}
public void Log(ResultKind messageKind, IAnalysisContext context, string message)
{
switch (messageKind)
{
// These result types are optionally emitted
case ResultKind.Pass:
case ResultKind.Note:
case ResultKind.NotApplicable:
{
if (Verbose)
{
Console.WriteLine(GetMessageText(context, message, messageKind));
}
break;
}
// These result types are alwayss emitted
case ResultKind.Error:
case ResultKind.Warning:
case ResultKind.InternalError:
case ResultKind.ConfigurationError:
{
Console.WriteLine(GetMessageText(context, message, messageKind));
break;
}
default:
{
throw new InvalidOperationException();
}
}
}
private void LogJsonIssue(ResultKind messageKind, string targetPath, Region region, string ruleId, string formatId, params string[] arguments)
{
if (!ShouldLog(messageKind))
{
return;
}
Result result = new Result();
result.RuleId = ruleId;
result.FormattedRuleMessage = new FormattedRuleMessage()
{
FormatId = formatId,
Arguments = arguments
};
result.Kind = messageKind;
if (targetPath != null)
{
result.Locations = new HashSet <Location> {
new Sarif.Location {
AnalysisTarget = new PhysicalLocation
{
Uri = new Uri(targetPath),
Region = region
}
}
};
}
_issueLogJsonWriter.WriteResult(result);
}
public bool ShouldLog(ResultKind messageKind)
{
switch (messageKind)
{
case ResultKind.Note:
case ResultKind.Pass:
case ResultKind.NotApplicable:
{
if (!Verbose)
{
return(false);
}
break;
}
case ResultKind.Error:
case ResultKind.Warning:
case ResultKind.InternalError:
case ResultKind.ConfigurationError:
{
break;
}
default:
{
throw new InvalidOperationException();
}
}
return(true);
}
private void WriteToConsole(ResultKind messageKind, Uri uri, Region region, string ruleId, string message)
{
switch (messageKind)
{
// These result types are optionally emitted
case ResultKind.Pass:
case ResultKind.Note:
case ResultKind.NotApplicable:
{
if (Verbose)
{
Console.WriteLine(GetMessageText(uri, region, ruleId, message, messageKind));
}
break;
}
// These result types are alwayss emitted
case ResultKind.Error:
case ResultKind.Warning:
case ResultKind.InternalError:
case ResultKind.ConfigurationError:
{
Console.WriteLine(GetMessageText(uri, region, ruleId, message, messageKind));
break;
}
default:
{
throw new InvalidOperationException();
}
}
}
public void NoteTestResult(ResultKind kind, string targetPath)
{
switch (kind)
{
case ResultKind.Pass:
{
PassTargets.Add(targetPath);
break;
}
case ResultKind.Fail:
{
FailTargets.Add(targetPath);
break;
}
case ResultKind.NotApplicable:
{
NotApplicableTargets.Add(targetPath);
break;
}
default:
{
throw new InvalidOperationException();
}
}
}
public void Log(ResultKind messageKind, IAnalysisContext context, string message)
{
foreach (IResultLogger logger in Loggers)
{
logger.Log(messageKind, context, message);
}
}
private static bool IsError(ResultKind kind)
{
return
(kind == ResultKind.ConfigurationError ||
kind == ResultKind.Error ||
kind == ResultKind.InternalError);
}
public SearchData(string item, int startIndex, int itemIndex, ResultKind kind)
{
Item = item;
StartIndex = startIndex;
ItemIndex = itemIndex;
Kind = kind;
}
private __VSERRORCATEGORY GetSeverity(ResultKind kind)
{
switch (kind)
{
case ResultKind.ConfigurationError:
case ResultKind.InternalError:
case ResultKind.Error:
{
return(__VSERRORCATEGORY.EC_ERROR);
}
case ResultKind.Warning:
{
return(__VSERRORCATEGORY.EC_WARNING);
}
case ResultKind.NotApplicable:
case ResultKind.Pass:
case ResultKind.Note:
{
return(__VSERRORCATEGORY.EC_MESSAGE);
}
}
return(__VSERRORCATEGORY.EC_WARNING);
}
public void Log(ResultKind messageKind, IAnalysisContext context, string message)
{
foreach (IResultLogger logger in Loggers)
{
logger.Log(messageKind, context, message);
}
}
public void Log(ResultKind messageKind, IAnalysisContext context, string message)
{
switch (messageKind)
{
// These result types are optionally emitted
case ResultKind.Pass:
case ResultKind.Note:
case ResultKind.NotApplicable:
{
if (Verbose)
{
Console.WriteLine(GetMessageText(context, message, messageKind));
}
break;
}
// These result types are alwayss emitted
case ResultKind.Error:
case ResultKind.Warning:
case ResultKind.InternalError:
case ResultKind.ConfigurationError:
{
Console.WriteLine(GetMessageText(context, message, messageKind));
break;
}
default:
{
throw new InvalidOperationException();
}
}
}
private void WriteToConsole(ResultKind kind, FailureLevel level, Uri uri, Region region, string ruleId, string message)
{
ValidateKindAndLevel(kind, level);
switch (level)
{
// These result types are optionally emitted.
case FailureLevel.None:
case FailureLevel.Note:
{
if (Verbose)
{
Console.WriteLine(GetMessageText(uri, region, ruleId, message, kind, level));
}
break;
}
// These result types are always emitted.
case FailureLevel.Error:
case FailureLevel.Warning:
{
Console.WriteLine(GetMessageText(uri, region, ruleId, message, kind, level));
break;
}
default:
{
throw new InvalidOperationException();
}
}
}
private Result MakeResultFromTestCase(ResultKind kind, Region region)
{
return(new Result
{
RuleId = TestRuleId,
Kind = kind,
Locations = new List <Location>
{
new Location
{
AnalysisTarget = new PhysicalLocation
{
Uri = new Uri(TestAnalysisTarget),
Region = region
}
}
},
FormattedMessage = new FormattedMessage
{
FormatId = TestFormatId,
Arguments = new List <string>
{
"42",
"54"
}
}
});
}
public ExpressionResult(Type valueType, Register64 ptr, int offset, Segment segment = Segment.DS)
{
ValueType = valueType ?? throw new ArgumentNullException(nameof(valueType));
Ptr = ptr;
Offset = offset;
Segment = segment;
Kind = ResultKind.Pointer;
}
public void Result_FormatForVisualStudioTests(ResultKind kind, Region region, string expected)
{
Result result = MakeResultFromTestCase(kind, region);
string actual = result.FormatForVisualStudio(TestRule);
actual.Should().Be(expected);
}
public void Log(ResultKind messageKind, IAnalysisContext context, Region region, string formatSpecifierId, params string[] arguments)
{
formatSpecifierId = RuleUtilities.NormalizeFormatSpecifierId(context.Rule.Id, formatSpecifierId);
string formatSpecifier = context.Rule.FormatSpecifiers[formatSpecifierId];
string message = String.Format(formatSpecifier, arguments);
WriteToConsole(messageKind, context.TargetUri, region, context.Rule.Id, message);
}
public static Result BuildResult(FailureLevel level, ResultKind kind, IAnalysisContext context, Region region, string ruleMessageId, params string[] arguments)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (arguments == null)
{
throw new ArgumentNullException(nameof(arguments));
}
ruleMessageId = NormalizeRuleMessageId(ruleMessageId, context.Rule.Id);
Result result = new Result
{
RuleId = context.Rule.Id,
Message = new Message
{
MessageId = ruleMessageId,
Arguments = arguments
},
Level = level,
Kind = kind
};
string targetPath = context.TargetUri?.LocalPath;
if (targetPath != null)
{
result.Locations = new List <Location> {
new Sarif.Location {
PhysicalLocation = new PhysicalLocation
{
ArtifactLocation = new ArtifactLocation
{
Uri = new Uri(targetPath)
},
Region = region
}
}
};
}
if (level == FailureLevel.Warning)
{
context.RuntimeErrors |= RuntimeConditions.OneOrMoreWarningsFired;
}
if (level == FailureLevel.Error)
{
context.RuntimeErrors |= RuntimeConditions.OneOrMoreErrorsFired;
}
return(result);
}
private ConsoleColor GetColorForResult(ResultKind result)
{
return(result switch
{
ResultKind.Pass => passColor,
ResultKind.Fail => failColor,
ResultKind.Error => errorColor,
_ => throw new ArgumentOutOfRangeException(nameof(result), "Unexpected enum value"),
});
public static TestOutcome ToTestOutcome(this ResultKind @this)
{
return(@this switch
{
ResultKind.Pass => TestOutcome.Passed,
ResultKind.Fail => TestOutcome.Failed,
ResultKind.Error => TestOutcome.Failed,
_ => TestOutcome.None
});
public void Log(ResultKind messageKind, IAnalysisContext context, Region region, string formatSpecifierId, params string[] arguments)
{
this.ruleDescriptors.Add(context.Rule);
formatSpecifierId = RuleUtilities.NormalizeFormatSpecifierId(context.Rule.Id, formatSpecifierId);
LogJsonIssue(messageKind, context.TargetUri?.LocalPath, region, context.Rule.Id, formatSpecifierId, arguments);
this.ruleDescriptors.Add(context.Rule);
}
public ControlForDisplayingTheFileOpenDialog()
{
ResultKind = FileOpenDialog.ResultKind.Text; //Note: this is to set the default value of the property.
CSharpXamlForHtml5.DomManagement.SetHtmlRepresentation(this,
"<input type='file'>");
this.Loaded += ControlForDisplayingAFileOpenDialog_Loaded;
}
private static string GetMessageText(
string toolName,
Uri uri,
Region region,
string ruleId,
string message,
ResultKind kind,
FailureLevel level)
{
string path = ConstructPathFromUri(uri);
string issueType = null;
switch (level)
{
case FailureLevel.Note:
issueType = "note";
break;
case FailureLevel.Error:
issueType = "error";
break;
case FailureLevel.Warning:
issueType = "warning";
break;
case FailureLevel.None:
issueType = kind.ToString().ToLowerInvariant();
// Shorten to 'info' for compatibility with previous behavior.
if (issueType == "informational")
{
issueType = "info";
}
break;
default:
throw new InvalidOperationException("Unknown message level:" + level.ToString());
}
string detailedDiagnosis = NormalizeMessage(message, enquote: false);
string location = "";
if (region != null)
{
// TODO: FormatForVisualStudio doesn't handle
// binary and char offsets only.
location = region.FormatForVisualStudio();
}
return((path != null ? (path + location) : toolName)
+ $": {issueType} "
+ (!string.IsNullOrEmpty(ruleId) ? (ruleId + ": ") : "")
+ detailedDiagnosis);
}
public void Log(ResultKind messageKind, IAnalysisContext context, string message)
{
switch (messageKind)
{
case ResultKind.Pass:
{
if (Verbose)
{
WriteJsonIssue(context.TargetUri.LocalPath, context.Rule.Id, message, ResultKind.Pass);
}
break;
}
case ResultKind.Error:
case ResultKind.Warning:
{
WriteJsonIssue(context.TargetUri.LocalPath, context.Rule.Id, message, ResultKind.Error);
break;
}
case ResultKind.NotApplicable:
{
if (Verbose)
{
WriteJsonIssue(context.TargetUri.LocalPath, context.Rule.Id, message, ResultKind.NotApplicable);
}
break;
}
case ResultKind.Note:
{
if (Verbose)
{
WriteJsonIssue(context.TargetUri.LocalPath, context.Rule.Id, message, ResultKind.Note);
}
break;
}
case ResultKind.ConfigurationError:
{
WriteJsonIssue(context.TargetUri.LocalPath, context.Rule.Id, message, ResultKind.ConfigurationError);
break;
}
case ResultKind.InternalError:
{
WriteJsonIssue(context.TargetUri.LocalPath, context.Rule.Id, message, ResultKind.InternalError);
break;
}
default:
{
throw new InvalidOperationException();
}
}
}
public static Result BuildResult(ResultKind kind, IAnalysisContext context, Region region, string ruleMessageId, params string[] arguments)
{
// If kind indicates a failure, but we have no explicit failure
// level, we'll fall back to the default of Warning
FailureLevel level = (kind != ResultKind.Fail)
? FailureLevel.None
: FailureLevel.Warning;
return BuildResult(level, kind, context, region, ruleMessageId, arguments);
}
public void Log(ResultKind messageKind, IAnalysisContext context, string message)
{
switch (messageKind)
{
case ResultKind.Pass:
{
break;
}
case ResultKind.Error:
{
break;
}
case ResultKind.Warning:
{
break;
}
case ResultKind.NotApplicable:
{
if (context.Rule.Id == NoteDescriptors.InvalidTarget.Id)
{
_invalidTargetsCount++;
}
break;
}
case ResultKind.Note:
{
if (context.Rule.Id == NoteDescriptors.AnalyzingTarget.Id)
{
_targetsCount++;
}
break;
}
case ResultKind.InternalError:
{
break;
}
case ResultKind.ConfigurationError:
{
break;
}
default:
{
throw new InvalidOperationException();
}
}
}
public Result(string platform, ResultKind kind, DateTime startTime, DateTime endTime, IAssertionHelper helper)
{
Platform = platform;
Kind = kind;
StartTime = startTime;
EndTime = endTime;
Output = helper.Log.ToString();
if (Assert._globalStyleUsed && helper.Assert.AssertCount == 0)
AssertCount = -1;
else
AssertCount = helper.Assert.AssertCount;
}
public void NoteTestResult(ResultKind messageKind, string targetPath)
{
switch (messageKind)
{
case ResultKind.Pass:
{
PassTargets.Add(targetPath);
break;
}
case ResultKind.ConfigurationError:
{
ConfigurationErrorTargets.Add(targetPath);
break;
}
case ResultKind.Error:
{
FailTargets.Add(targetPath);
break;
}
case ResultKind.NotApplicable:
{
NotApplicableTargets.Add(targetPath);
break;
}
case ResultKind.Note:
case ResultKind.InternalError:
{
throw new NotImplementedException();
}
default:
{
throw new InvalidOperationException();
}
}
}
public static string GetMessageText(
IAnalysisContext context,
string message,
ResultKind messageKind,
Region region = null)
{
string path = null;
Uri uri = context.TargetUri;
if (uri != null)
{
// If a path refers to a URI of form file://blah, we will convert to the local path
if (uri.IsAbsoluteUri && uri.Scheme == Uri.UriSchemeFile)
{
path = uri.LocalPath;
}
else
{
path = uri.ToString();
}
}
string issueType = null;
switch (messageKind)
{
case ResultKind.ConfigurationError:
{
issueType = "CONFIGURATION ERROR";
break;
}
case ResultKind.InternalError:
{
issueType = "INTERNAL ERROR";
break;
}
case ResultKind.Error:
{
issueType = "error";
break;
}
case ResultKind.Warning:
{
issueType = "warning";
break;
}
case ResultKind.NotApplicable:
case ResultKind.Note:
{
issueType = "note";
break;
}
default:
{
throw new InvalidOperationException("Unknown message kind:" + messageKind.ToString());
}
}
string detailedDiagnosis = NormalizeMessage(message, enquote: false);
string location = "";
if (region != null)
{
// TODO
if (region.Offset > 0 || region.StartColumn == 0) { throw new NotImplementedException(); }
if (region.StartLine == 0) { throw new InvalidOperationException(); }
// VS supports the following formatting options:
// (startLine)
// (startLine-endLine)
// (startLine,startColumn)
// (startLine,startColumn-endColumn)
// (startLine,startColumn,endLine,endColumn
//
// For expedience, we'll convert everything to the most fully qualified format
string start = region.StartLine.ToString() + "," +
(region.StartColumn > 0 ? region.StartColumn.ToString() : "1");
string end = (region.EndLine > region.StartLine ? region.EndLine.ToString() : region.StartLine.ToString()) + "," +
(region.EndColumn > 0 ? region.EndColumn.ToString() : region.StartColumn.ToString());
location =
"(" +
start + (end != start ? "," + end : "") +
")";
}
return (path != null ? (path + location + ": ") : "") +
issueType + " " +
context.Rule.Id + ": " +
detailedDiagnosis;
}
public void Log(ResultKind messageKind, IAnalysisContext context, string message)
{
switch (messageKind)
{
case ResultKind.Pass:
{
if (Verbose)
{
WriteJsonIssue(context.TargetUri.LocalPath, context.Rule.Id, message, ResultKind.Pass);
}
break;
}
case ResultKind.Error:
case ResultKind.Warning:
{
WriteJsonIssue(context.TargetUri.LocalPath, context.Rule.Id, message, ResultKind.Error);
break;
}
case ResultKind.NotApplicable:
{
if (Verbose)
{
WriteJsonIssue(context.TargetUri.LocalPath, context.Rule.Id, message, ResultKind.NotApplicable);
}
break;
}
case ResultKind.Note:
{
if (Verbose)
{
WriteJsonIssue(context.TargetUri.LocalPath, context.Rule.Id, message, ResultKind.Note);
}
break;
}
case ResultKind.ConfigurationError:
{
WriteJsonIssue(context.TargetUri.LocalPath, context.Rule.Id, message, ResultKind.ConfigurationError);
break;
}
case ResultKind.InternalError:
{
WriteJsonIssue(context.TargetUri.LocalPath, context.Rule.Id, message, ResultKind.InternalError);
break;
}
default:
{
throw new InvalidOperationException();
}
}
}
private TestState StateForResult(ResultKind kind)
{
switch (kind)
{
case ResultKind.Success:
case ResultKind.NoError:
return TestState.Passed;
case ResultKind.Ignore:
return TestState.Ignored;
default:
return TestState.Failed;
}
}
private static void PostTestResultToAppveyor(Result result, ResultKind match)
{
var fullName = string.Format("{0}.{1}.{2} [{3}]", result.Test.Name, result.Test.Fixture.Name,
result.Test.Fixture.Assembly.Name, result.Platform);
string outcome = null;
switch (match)
{
case ResultKind.Success:
outcome = "Passed";
break;
case ResultKind.Fail:
outcome = "Failed";
break;
case ResultKind.Error:
outcome = "NotRunnable";
break;
case ResultKind.Ignore:
outcome = "Ignored";
break;
case ResultKind.NoError:
outcome = "Inconclusive";
break;
}
var json = string.Format(@"{{
'testName': '{0}',
'testFramework': '{1}',
'fileName': '{2}',
'outcome': '{3}',
'durationMilliseconds': '{4}',
'ErrorMessage': '',
'ErrorStackTrace': '',
'StdOut': '{5}',
'StdErr': ''
}}",
fullName.EscapeJson(),
"PclUnit",
result.Test.Fixture.Assembly.Name.EscapeJson(),
outcome.EscapeJson(),
(result.EndTime - result.StartTime).Milliseconds,
result.Output.EscapeJson()
);
PostToAppVeyor(json);
}
public void Log(ResultKind messageKind, IAnalysisContext context, FormattedMessage message)
{
throw new NotImplementedException();
}
public void Log(ResultKind resultKind, IAnalysisContext context, string message)
{
Result result = new Result();
result.RuleId = context.Rule.Id;
result.FullMessage = message;
result.Kind = resultKind;
result.Locations = new[]{
new Sarif.Sdk.Location {
AnalysisTarget = new[]
{
new PhysicalLocationComponent
{
// Why? When NewtonSoft serializes this Uri, it will use the
// original string used to construct the Uri. For a file path,
// this will be the local file path. We want to persist this
// information using the file:// protocol rendering, however.
Uri = context.TargetUri.LocalPath.CreateUriForJsonSerialization(),
MimeType = MimeType.Binary
}
}
}
};
_issueLogJsonWriter.WriteResult(result);
}
