public void addMessage(DiagnosticMessage message)
{
lock (messageLocker)
{
messages.Add(message);
}
}
private static List <DiagnosticMessage> ValueAsCompilationMessages(JsonObject obj, string key)
{
var messages = new List <DiagnosticMessage>();
var arrayValue = obj.Value(key) as JsonArray;
for (int i = 0; i < arrayValue.Length; i++)
{
var item = arrayValue[i] as JsonObject;
var message = new DiagnosticMessage(
item.ValueAsString(nameof(DiagnosticMessage.Message)),
item.ValueAsString(nameof(DiagnosticMessage.FormattedMessage)),
item.ValueAsString(nameof(DiagnosticMessage.SourceFilePath)),
(DiagnosticMessageSeverity)item.ValueAsInt(nameof(DiagnosticMessage.Severity)),
item.ValueAsInt(nameof(DiagnosticMessage.StartColumn)),
item.ValueAsInt(nameof(DiagnosticMessage.StartLine)),
item.ValueAsInt(nameof(DiagnosticMessage.EndColumn)),
item.ValueAsInt(nameof(DiagnosticMessage.EndLine)));
messages.Add(message);
}
return(messages);
}
static DiagnosticMessage MakeInternal(DiagnosticType type, string errorCode, string messageData, MethodDefinition method, Instruction instruction)
{
var result = new DiagnosticMessage {
Column = 0, Line = 0, DiagnosticType = type, File = ""
};
var seq = instruction != null?CecilHelpers.FindBestSequencePointFor(method, instruction) : null;
if (errorCode.Contains("ICE"))
{
messageData = messageData + " Seeing this error indicates a bug in the dots compiler. We'd appreciate a bug report (About->Report a Bug...). Thnx! <3";
}
var errorType = type == DiagnosticType.Error ? "error" : "warning";
messageData = $"{errorType} {errorCode}: {messageData}";
if (seq != null)
{
result.File = seq.Document.Url;
result.Column = seq.StartColumn;
result.Line = seq.StartLine;
#if !UNITY_DOTSRUNTIME
var shortenedFilePath = seq.Document.Url.Replace($"{Environment.CurrentDirectory}{Path.DirectorySeparatorChar}", "");
result.MessageData = $"{shortenedFilePath}({seq.StartLine},{seq.StartColumn}): {messageData}";
#else
result.MessageData = messageData;
#endif
}
else
{
result.MessageData = messageData;
}
return(result);
}
public static DiagnosticMessage MakeError(string errorCode, string messageData, MethodDefinition method, Instruction instruction)
{
var result = new DiagnosticMessage {
Column = 0, Line = 0, DiagnosticType = DiagnosticType.Error, File = ""
};
var seq = instruction != null?CecilHelpers.FindBestSequencePointFor(method, instruction) : null;
if (errorCode.Contains("ICE"))
{
messageData = messageData + " Seeing this error indicates a bug in the dots compiler. We'd appreciate a bug report (About->Report a Problem). Thnx! <3";
}
messageData = $"error {errorCode}: {messageData}";
if (seq != null)
{
result.File = seq.Document.Url;
result.Column = seq.StartColumn;
result.Line = seq.StartLine;
result.MessageData = $"{seq.Document.Url}:({seq.StartLine},{seq.StartColumn}) {messageData}";
}
else
{
result.MessageData = messageData;
}
return(result);
}
private static DiagnosticMessage MakeInternal(DiagnosticType type, string errorCode, string messageData,
MethodDefinition method, Instruction instruction)
{
var result = new DiagnosticMessage {
Column = 0, Line = 0, DiagnosticType = type, File = ""
};
var seq = method != null?Helpers.FindBestSequencePointFor(method, instruction) : null;
messageData = $"error {errorCode}: {messageData}";
if (seq != null)
{
result.File = seq.Document.Url;
result.Column = seq.StartColumn;
result.Line = seq.StartLine;
#if UNITY_EDITOR
result.MessageData = $"{seq.Document.Url}({seq.StartLine},{seq.StartColumn}): {messageData}";
#else
result.MessageData = messageData;
#endif
}
else
{
result.MessageData = messageData;
}
return(result);
}
private static DiagnosticMessage Make(DiagnosticType type, string errorCode, string messageData,
SequencePoint seq)
{
var result = new DiagnosticMessage {
Column = 0, Line = 0, DiagnosticType = type, File = ""
};
messageData = $"error {errorCode}: {messageData}";
if (seq != null)
{
result.File = seq.Document.Url;
result.Column = seq.StartColumn;
result.Line = seq.StartLine;
#if UNITY_EDITOR
result.MessageData = $"{seq.Document.Url}({seq.StartLine},{seq.StartColumn}): {messageData}";
#else
result.MessageData = messageData;
#endif
}
else
{
result.MessageData = messageData;
}
return(result);
}
public QmlDiagnosticsTag(ITextSnapshot snapshot, DiagnosticMessage diagnosticMessage)
{
DiagnosticMessage = diagnosticMessage;
Span = snapshot.CreateTrackingSpan(
diagnosticMessage.Location.Offset, diagnosticMessage.Location.Length,
SpanTrackingMode.EdgeExclusive);
}
public RecordEntry(DiagnosticMessage message, double width, double height, Action <DiagnosticMessage> ClearMethod)
{
Width = width;
Height = height;
this.ClearMethod = ClearMethod;
this.message = message;
AddColumns();
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Configure the constraint from a diagnostic message properties.
/// </summary>
/// <param name="message">
/// A diagnostic message
/// </param>
/// <returns>
/// A ConstraintBuilder<T>
/// </returns>
///-------------------------------------------------------------------------------------------------
public ConstraintBuilder <T> Message(DiagnosticMessage message)
{
Contract.Requires(message, "message");
this._message = message.Message;
this._isWarning = message.MessageType == MessageType.Warning;
this._category = message.Category;
return(this);
}
public static void Throw(this DiagnosticMessage dm)
{
if (dm.DiagnosticType != DiagnosticType.Error)
{
throw new InvalidOperationException("We should never throw exceptions for non-error Entities.ForEach diagnostic messages.");
}
throw new FoundErrorInUserCodeException(new[] { dm });
}
private void Log(DiagnosticMessage diagnosticMessage)
{
if (diagnosticMessage == null)
{
throw new ArgumentNullException(nameof(diagnosticMessage));
}
_diagnostics.Add(diagnosticMessage);
}
public IEnumerable <TTestCase> OrderTestCases <TTestCase>(IEnumerable <TTestCase> testCases)
where TTestCase : ITestCase
{
var result = testCases.ToList(); // Run them in discovery order
var message = new DiagnosticMessage("Ordered {0} test cases", result.Count);
diagnosticMessageSink.OnMessage(message);
return(result);
}
public void AddGlobalDiagnostics(DiagnosticMessage message)
{
if (_diagnostics == null)
{
_diagnostics = new List<DiagnosticMessage>();
}
_diagnostics.Add(message);
}
public ILPostProcessResult PostProcessInternal(ICompiledAssembly compiledAssembly)
{
AssemblyDefinition assemblyDefinition;
#if MEDICINE_IL_DEBUG
using (NonAlloc.Benchmark.Start($"GetAssemblyDefinition ({compiledAssembly.Name})"))
#endif
assemblyDefinition = PostProcessorAssemblyResolver.GetAssemblyDefinitionFor(compiledAssembly);
try
{
CecilExtensions.CurrentModule = assemblyDefinition.MainModule;
PostProcessorContext context;
#if MEDICINE_IL_DEBUG
using (NonAlloc.Benchmark.Start($"CreatePostProcessorContext ({compiledAssembly.Name})"))
#endif
context = new PostProcessorContext(assemblyDefinition.MainModule);
#if MEDICINE_IL_DEBUG
using (NonAlloc.Benchmark.Start($"MedicineInjection ({compiledAssembly.Name})"))
#endif
new InjectionPostProcessor(context).ProcessAssembly();
var pe = new MemoryStream(capacity: 1024 * 64);
var pdb = new MemoryStream(capacity: 1024 * 16);
var writerParameters = new WriterParameters
{
SymbolWriterProvider = new PortablePdbWriterProvider(),
SymbolStream = pdb,
WriteSymbols = true,
};
assemblyDefinition.Write(pe, writerParameters);
var inMemoryAssembly = new InMemoryAssembly(pe.ToArray(), pdb.ToArray());
return(new ILPostProcessResult(inMemoryAssembly, context.DiagnosticMessages));
}
catch (Exception ex)
{
var error = new DiagnosticMessage
{
MessageData = $"Unexpected exception while post-processing assembly {compiledAssembly.Name}:\n{ex}",
DiagnosticType = DiagnosticType.Error,
};
return(new ILPostProcessResult(compiledAssembly.InMemoryAssembly, new List <DiagnosticMessage> {
error
}));
}
finally
{
CecilExtensions.CurrentModule.Dispose();
CecilExtensions.CurrentModule = null;
}
}
internal override void SetProtocolOp(Asn1ProtocolOp op)
{
op.BindResponse = new Asn1BindResponse
{
ResultCode = ResultCode,
MatchedDN = MatchedDN.GetBytes(),
DiagnosticMessage = DiagnosticMessage.LdapString(),
Referral = this.GetReferrals(Referrals),
ServerSaslCreds = ServerSaslCreds
};
}
internal override void SetProtocolOp(Asn1ProtocolOp op)
{
var asn = new Asn1LDAPResult
{
ResultCode = ResultCode,
MatchedDN = MatchedDN.GetBytes(),
DiagnosticMessage = DiagnosticMessage.LdapString(),
Referral = this.GetReferrals(Referrals),
};
SetProtocolOp(op, asn);
}
private void AddLogEntry(DiagnosticMessage record)
{
DiagnosticRecords.Add(new DiagnosticLogRecord()
{
Source = record.SourceString,
Type = record.TypeString,
MID = record.MidString,
Component = record.Component,
Mode = record.FmiString,
Date = record.TimeStamp.ToString("MM/dd/yyyy HH:mm:ss tt"),
});
}
private IObservable <Unit> ProcessQueue(IEnumerable <string> filePaths)
{
return(Observable.FromAsync(async() =>
{
var results = await Task.WhenAll(filePaths.Distinct().Select(ProcessNextItem));
var message = new DiagnosticMessage()
{
Results = results
};
_forwarder.Forward(message);
}));
}
protected override async Task <Tuple <decimal, string> > InvokeTestAsync(ExceptionAggregator aggregator)
{
BenchmarkEventSource.Log.BenchmarkStart(this.DisplayName, TestCase.Iterations);
//inject ITracer instance if test method defines single parameter of type ITracer
var testMethodParams = TestMethod.GetParameters();
var hasTracerParam = (testMethodParams.Length == 1 && testMethodParams[0].ParameterType == typeof(ITracer));
var args = hasTracerParam ? new object[] { NullTracer.Instance } : null;
//run the test once to make sure it's been jitted
await new BenchmarkTestInvoker(Test, MessageBus, TestClass, ConstructorArguments, TestMethod, args, aggregator, CancellationTokenSource).RunAsync();
decimal executionTime = 0;
//starting from 1 so that iteration number appears correctly in ETW log
for (int i = 1; i <= TestCase.Iterations; i++)
{
if (TestCase.CollectGargage)
{
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
}
var stopwatchTracer = new StopwatchTracer();
BenchmarkEventSource.Log.BenchmarkIterationStart(i);
var invokerTime = await new BenchmarkTestInvoker(Test, MessageBus, TestClass, ConstructorArguments, TestMethod, hasTracerParam ? new object[] { stopwatchTracer } : null, aggregator, CancellationTokenSource).RunAsync();
BenchmarkEventSource.Log.BenchmarkIterationStop(i);
var stopwatchTime = stopwatchTracer.GetElapsed();
if (stopwatchTime.HasValue)
{
executionTime += stopwatchTime.Value;
}
else
{
executionTime += invokerTime;
}
}
var message = new DiagnosticMessage("{0} , Iterations : {1} , TotalMilliseconds : {2}", this.DisplayName, TestCase.Iterations, executionTime * 1000);
diagnosticMessageSink.OnMessage(message);
BenchmarkEventSource.Log.BenchmarkStop(this.DisplayName, TestCase.Iterations);
return(Tuple.Create(executionTime, string.Empty));
}
internal override void SetProtocolOp(Asn1ProtocolOp op)
{
op.ExtendedResponse = new Asn1ExtendedResponse
{
ResultCode = ResultCode,
MatchedDN = MatchedDN.GetBytes(),
DiagnosticMessage = DiagnosticMessage.LdapString(),
Referral = this.GetReferrals(Referrals),
Value = Value
};
if (Name != null)
{
op.ExtendedResponse.Name = Name.NumericOid();
}
}
private static void ConfigureFunctionLogging(IMessageSink sink, Process funcHostProcess)
{
void LogToOutput(object sender, DataReceivedEventArgs args)
{
var message = new DiagnosticMessage(args.Data);
sink.OnMessage(message);
}
funcHostProcess.ErrorDataReceived += LogToOutput;
funcHostProcess.OutputDataReceived += LogToOutput;
funcHostProcess.BeginOutputReadLine();
funcHostProcess.BeginErrorReadLine();
}
void IActionFilter.OnActionExecuting(ActionExecutingContext filterContext)
{
// Log Action Filter Call
var message = new DiagnosticMessage
{
IP = filterContext.HttpContext.Request.UserHostAddress.ToString(),
OrgId = 75,
PersonId = 3,
Session = "Session descipton"
};
LoggerFactory.CreateLog().Debug(message.MessageFormat, message.Parameters);
this.OnActionExecuting(filterContext);
}
protected override void AssertProducesInternal(Type systemType, DiagnosticType expectedDiagnosticType, string[] errorIdentifiers, bool useFailResolver = false)
{
DiagnosticMessage error = null;
try
{
AuthoringComponentPostProcessor.CreateBufferElementDataAuthoringType(TypeDefinitionFor(systemType));
}
catch (FoundErrorInUserCodeException exception)
{
error = exception.DiagnosticMessages.Single();
}
Assert.AreEqual(expected: expectedDiagnosticType, actual: error?.DiagnosticType);
Assert.IsTrue(error?.MessageData.Contains(errorIdentifiers.Single()));
}
private async Task Dequeue()
{
var tasks = new List <Task <DiagnosticResult> >();
for (var i = 0; i < 50; i++)
{
if (_openDocuments.IsEmpty)
{
break;
}
string filePath = null;
if (_openDocuments.TryDequeue(out filePath))
{
tasks.Add(this.ProcessNextItem(filePath));
}
}
if (!tasks.Any())
{
return;
}
var diagnosticResults = await Task.WhenAll(tasks.ToArray());
if (diagnosticResults.Any())
{
var message = new DiagnosticMessage()
{
Results = diagnosticResults
};
this._forwarder.Forward(message);
}
if (_openDocuments.IsEmpty)
{
lock (_lock)
{
_queueRunning = false;
}
}
else
{
this.ProcessQueue();
}
}
public DiagnosticMessage ToDiagnosticMessage(MethodDefinition context)
{
var result = new DiagnosticMessage()
{
DiagnosticType = DiagnosticType.Error,
MessageData = MessageWithoutLocation,
};
var seq = SequencePointFor(context);
if (seq != null)
{
result.Column = seq.StartColumn;
result.Line = seq.StartLine;
}
return(result);
}
private static void PrintDiagnostic(DiagnosticMessage diag)
{
switch (diag.Severity)
{
case DiagnosticMessageSeverity.Info:
Reporter.Error.WriteLine(diag.FormattedMessage);
break;
case DiagnosticMessageSeverity.Warning:
Reporter.Error.WriteLine(diag.FormattedMessage.Yellow().Bold());
break;
case DiagnosticMessageSeverity.Error:
Reporter.Error.WriteLine(diag.FormattedMessage.Red().Bold());
break;
}
}
public async void TestRunBackgroundWorker()
{
var platformServicesFake = A.Fake <IPlatformServices>();
Device.PlatformServices = platformServicesFake;
DatabaseMigrator.Migrate(_connection, _migrationSkriptFolderPath);
MessagingCenter.Subscribe <StartBackgroundWorkingServiceMessage>(this, MessageHelper.START_BACKGROUND_WORKING_SERVICE_MESSAGE, message =>
{
var msg = new DiagnosticMessage("Start Background Working Service");
output.WriteLine("{0}", msg.Message);
});
MessagingCenter.Subscribe <StopBackgroundWorkingServiceMessage>(this, MessageHelper.STOP_BACKGROUND_WORKING_SERVICE_MESSAGE, message =>
{
var msg = new DiagnosticMessage("Stop Background Working Service");
output.WriteLine("{0}", msg.Message);
});
MessagingCenter.Subscribe <ElementFinishedMessage>(this, MessageHelper.ELEMENT_FINISHED_MESSAGE, message =>
{
var msg = new DiagnosticMessage("Element processed");
output.WriteLine("{0}", msg.Message);
});
var deleteAll = BackgroundQueueService.EmptyQueue(_connection).Result;
Assert.True(deleteAll);
var testSpotGuid = Guid.NewGuid();
var testLat = 48.45;
var testLng = 13.9167;
var result = BackgroundQueueService.PushWheaterRequestToBackgroundQueue(_connection, testSpotGuid, testLat, testLng).Result;
Assert.True(result != Guid.Empty);
await BackgroundWorkerService.RunBackgroundWorkerService(_connection, new CancellationToken(false));
int cnt = BackgroundQueueService.GetQueueElementCount(_connection).Result;
Assert.Equal(0, cnt);
}
public Process StartFunction(IConfigurationRoot config, IMessageSink sink)
{
var dotnetExePath = Environment.ExpandEnvironmentVariables(config["DotnetExecutablePath"]);
var functionHostPath = Environment.ExpandEnvironmentVariables(config["FunctionHostPath"]);
var functionAppFolder = config["FunctionApplicationPath"];
var configMessage = new DiagnosticMessage("DotnetExePath: {0}, FunctionHostPath: {1}, FunctionApplicationPath: {2}",
dotnetExePath, functionHostPath, functionAppFolder);
sink.OnMessage(configMessage);
var funcHostProcess = new Process
{
StartInfo =
{
FileName = dotnetExePath,
Arguments = $"\"{functionHostPath}\" start -p {Port} --csharp",
WorkingDirectory = functionAppFolder,
RedirectStandardError = true,
RedirectStandardOutput = true,
}
};
var success = funcHostProcess.Start();
if (!success)
{
throw new InvalidOperationException("Could not start Azure Functions host.");
}
ConfigureFunctionLogging(sink, funcHostProcess);
if (funcHostProcess.HasExited)
{
var error = _funcHostProcess.StandardError.ReadToEnd();
throw new InvalidOperationException(error);
}
// ugly hack to let azure function start before test begun
Thread.Sleep(200);
return(funcHostProcess);
}
public virtual Task <IEnumerable <DiagnosticMessage> > GetDiagnosticMessages(CancellationToken cancellationToken)
{
List <DiagnosticMessage> diagnosticMessages = new List <DiagnosticMessage>();
foreach (SettingInfo info in _settings.Values)
{
string errorMessage = (string)info.CheckErrorMethod.Invoke(info.Setting, Array.Empty <object>());
if (string.IsNullOrEmpty(errorMessage))
{
continue;
}
DiagnosticMessage diagnosticMessage = new DiagnosticMessage(Severity.Error, errorMessage);
diagnosticMessages.Add(diagnosticMessage);
}
return(Task.FromResult((IEnumerable <DiagnosticMessage>)diagnosticMessages));
}
protected override void AssertProducesInternal(
Type systemType,
DiagnosticType expectedDiagnosticType,
string[] errorIdentifiers,
bool useFailResolver = false)
{
DiagnosticMessage error = null;
try
{
AssemblyDefinition assemblyDefinition = AssemblyDefinition.ReadAssembly(systemType.Assembly.Location);
TypeDefinition typeDefinitionToTest = assemblyDefinition.MainModule.Types.Single(t => t.Name == systemType.Name);
bool _ = AuthoringComponentPostProcessor.RunTest(typeDefinitionToTest);
}
catch (FoundErrorInUserCodeException exception)
{
error = exception.DiagnosticMessages.Single();
}
Assert.AreEqual(expected: expectedDiagnosticType, actual: error?.DiagnosticType);
Assert.IsTrue(error?.MessageData.Contains(errorIdentifiers.Single()));
}
public DiagnosticMessageView(DiagnosticMessage data)
{
ErrorCode = data.ErrorCode;
SourceFilePath = data.SourceFilePath;
Message = data.Message;
Severity = data.Severity;
StartLine = data.StartLine;
StartColumn = data.StartColumn;
EndLine = data.EndLine;
EndColumn = data.EndColumn;
FormattedMessage = data.FormattedMessage;
var description = data.Source as LibraryDescription;
if (description != null)
{
Source = new
{
Name = description.Identity.Name,
Version = description.Identity.Version?.ToString()
};
}
}
private void AddRecord(DiagnosticMessage message)
{
if (numDisplayedRecords < maxDisplayedRecords)
{
if ((RecordEntries.Find(x => (x.message.ID == message.ID) && (x.message.Fmi == message.Fmi)) == null))
{
if (!inWarningMode)
{
inWarningMode = true;
SetBackground();
}
var entry = new RecordEntry(message, canvas.Width, ((canvas.Height - (canvas.Height / (maxDisplayedRecords * 2))) / (double)maxDisplayedRecords), RemoveRecord)
{
//Background = new SolidColorBrush(Colors.Blue),
};
RecordEntries.Add(entry);
recordStack.Children.Add(entry);
numDisplayedRecords++;
//AdjustRecordHeight();
}
}
}
public DiagnosticMessageView(DiagnosticMessage data)
{
ErrorCode = data.ErrorCode;
SourceFilePath = data.SourceFilePath;
Message = data.Message;
Severity = data.Severity;
StartLine = data.StartLine;
StartColumn = data.StartColumn;
EndLine = data.EndLine;
EndColumn = data.EndColumn;
FormattedMessage = data.FormattedMessage;
var description = data.Source as LibraryDescription;
if (description != null)
{
Source = new
{
Name = description.Identity.Name,
Version = description.Identity.Version?.ToString()
};
}
}
private static List<DiagnosticMessage> ValueAsCompilationMessages(JsonObject obj, string key)
{
var messages = new List<DiagnosticMessage>();
var arrayValue = obj.Value(key) as JsonArray;
for (int i = 0; i < arrayValue.Length; i++)
{
var item = arrayValue[i] as JsonObject;
var message = new DiagnosticMessage(
item.ValueAsString(nameof(DiagnosticMessage.ErrorCode)),
item.ValueAsString(nameof(DiagnosticMessage.Message)),
item.ValueAsString(nameof(DiagnosticMessage.FormattedMessage)),
item.ValueAsString(nameof(DiagnosticMessage.SourceFilePath)),
(DiagnosticMessageSeverity)item.ValueAsInt(nameof(DiagnosticMessage.Severity)),
item.ValueAsInt(nameof(DiagnosticMessage.StartColumn)),
item.ValueAsInt(nameof(DiagnosticMessage.StartLine)),
item.ValueAsInt(nameof(DiagnosticMessage.EndColumn)),
item.ValueAsInt(nameof(DiagnosticMessage.EndLine)));
messages.Add(message);
}
return messages;
}
protected void addMessage(DiagnosticMessage m)
{
if (App.diagnosticWindow != null)
{
App.diagnosticWindow.Dispatcher.adopt(delegate
{
lock (messageHistoryLock)
{
App.diagnosticWindow.messageSource.Add(m);
};
});
}
}
private static void PrintDiagnostic(DiagnosticMessage diag)
{
switch (diag.Severity)
{
case DiagnosticMessageSeverity.Info:
Reporter.Error.WriteLine(diag.FormattedMessage);
break;
case DiagnosticMessageSeverity.Warning:
Reporter.Error.WriteLine(diag.FormattedMessage.Yellow().Bold());
break;
case DiagnosticMessageSeverity.Error:
Reporter.Error.WriteLine(diag.FormattedMessage.Red().Bold());
break;
}
}