private void SearchForLinks(string URI, int SearchDepth)
{
Console.WriteLine(SearchDepth);
if (SearchDepth >= 0)
{
WebClient webclient = new WebClient();
Uri uri = new Uri(URI);
string page;
foreach (IDomObject link in CQ.Create(page = webclient.DownloadString(uri)).Find("a"))
{
string str = link.GetAttribute("href");
if (str != null)
{
if (str.StartsWith("/"))
{
str = uri.GetLeftPart(UriPartial.Authority) + str;
}
if (str != URI)
{
if (str.Contains(uri.GetLeftPart(UriPartial.Authority)) && SearchDepth > 0)
{
SearchForLinks(str, --SearchDepth);
}
else
{
OutputEvent?.Invoke(str, SearchDepth, link.GetAttribute("href"), link.GetAttribute("title"));
}
}
}
}
}
}
public OutputEvent ConvertToOutputEvent(JObject json)
{
var cblipEvent = json.ToObject <Event>();
OutputEvent outputEvent = new OutputEvent
{
botIdentifier = cblipEvent.ownerIdentity?.Split('@')[0],
ownerIdentity = cblipEvent.ownerIdentity,
identity = cblipEvent.contact?.Identity,
externalId = cblipEvent.contact?.ExternalId,
group = cblipEvent.contact?.Group,
source = cblipEvent.contact?.Source,
messageId = cblipEvent.messageId,
storageDate = cblipEvent.storageDate.ToUniversalTime().ToString(),
category = cblipEvent.category,
action = cblipEvent.action,
extras = cblipEvent.extras.ToString(),
value = cblipEvent.value,
label = cblipEvent.label,
id = cblipEvent.id,
};
_logger.LogDebug("Message Identified AS event for botIdentifier: {botIdentifier}", outputEvent.botIdentifier);
return(outputEvent);
}
public void Copy(string whereFrom, string to, string fileName)
{
try
{
if (fileName.Contains("install"))
{
CheckInstallWim(to);
}
#region old conditions
//if (fileName == "Winre.wim" && File.Exists($@"{to}\{fileName}"))
//{
// File.Delete($@"{to}\{fileName}");
//}
//else if (fileName == "install.wim" && File.Exists($@"{to}\{fileName}"))
//{
// File.Delete($@"{to}\{fileName}");
//}
//else if (fileName == "install.esd" && File.Exists($@"{to}\{fileName}"))
//{
// File.Delete($@"{to}\{fileName}");
//}
#endregion
OutputEvent?.Invoke($"Импорт нового {fileName}", true, false);
File.Copy(whereFrom, $@"{to}\{fileName}", true);
OutputEvent?.Invoke($"Импорт {fileName} завершен", false, true);
}
catch (Exception ex)
{
OutputEvent?.Invoke(ex.Message, false, true);
}
}
protected void RegisterOutput(OutputEvent func)
{
if (OutputHandler == null)
{
OutputHandler += func;
}
}
void IWCFObserverCallback.OnNext(OutputEvent value)
{
int expectedMax = 100;
int input = Math.Abs(value.O % expectedMax);
byte colorIndex = value.Color;
Debug.WriteLine("colorIndex: " + colorIndex);
Kpi1.Content = value.O;
Kpi1.Foreground = colors[colorIndex];
var last = myPolyline.Points.Count != 0 ? myPolyline.Points.Last():new Point(0, 0);
myPolyline.Points.Add(new Point(last.X + 1, PlainChart.ActualHeight - 10 - input * PlainChart.ActualHeight / expectedMax));
var trans = 25;
if (last.X % trans == 0)
{
TranslateTransform tt = new TranslateTransform(0, 0);
DoubleAnimation dax = new DoubleAnimation(myPolyline.RenderTransform.Value.OffsetX, PlainChart.ActualWidth - 2 * trans - last.X,
new Duration(TimeSpan.FromMilliseconds(450)));
var easing = new ExponentialEase();
easing.EasingMode = EasingMode.EaseIn;
dax.EasingFunction = easing;
tt.BeginAnimation(TranslateTransform.XProperty, dax);
myPolyline.RenderTransform = tt;
}
}
public void SettingNotificationWithEventCanDeleteEvent()
{
var configService = A.Fake <IConfigService>();
A.CallTo(() => configService.Config).Returns(new Config());
var outputEvent = new OutputEvent
{
ChannelName = "Channel",
StartTime = TimeSpan.FromSeconds(1),
EndTime = TimeSpan.FromSeconds(2)
};
var viewModel = new EventEditorViewModel(configService)
{
Notification = new Confirmation
{
Content = outputEvent
}
};
Assert.True(viewModel.CanDeleteEvent);
Assert.True(viewModel.DeleteCommand.CanExecute());
}
public async Task StartSubscribeEventHandler()
{
_logger.LogInformation("Event Listener starting for {eventSubscriptionName}", _eventSubscriptionName.SubscriptionId);
// Pull messages from the subscription using SimpleSubscriber.
_eventSubscriber = await SubscriberClient.CreateAsync(_eventSubscriptionName);
await _eventSubscriber.StartAsync(async (msg, cancellationToken) =>
{
try
{
_logger.LogDebug("Event receipt from {eventSubscriptionName}", _eventSubscriptionName.SubscriptionId);
string messageString = msg.Data.ToStringUtf8();
JObject json = JsonConvert.DeserializeObject <JObject>(messageString);
OutputEvent outEvent = _limeConverter.ConvertToOutputEvent(json);
_logger.LogInformation("Event receipt {id}", outEvent.id);
await _eventRepository.SaveEvent(outEvent);
// Return Reply.Ack to indicate this message has been handled.
return(SubscriberClient.Reply.Ack);
}
catch (Exception ex)
{
_logger.LogError(ex.ToString() + " " + msg.Data.ToStringUtf8());
return(SubscriberClient.Reply.Nack);
}
});
}
public void Work()
{
try
{
_filenames = new ConcurrentQueue <string>(Directory.GetFiles(path, "*.jpg"));
}
catch (DirectoryNotFoundException)
{
OutputEvent?.Invoke("No Files");
return;
}
//Console.CancelKeyPress += (sender, eArgs) =>
//{
// StopSignal.Set();
// eArgs.Cancel = true;
//};
var procNumb = Environment.ProcessorCount;
var threads = new Thread[procNumb];
for (var i = 0; i < procNumb; ++i)
{
OutputEvent?.Invoke("Begining thread");
threads[i] = new Thread(Worker);
threads[i].Start();
}
for (var i = 0; i < procNumb; ++i)
{
threads[i].Join();
}
OutputEvent?.Invoke("Work Finished");
}
public void DeleteCommandConfirmsAndSetsNotificationContentToNull()
{
var configService = A.Fake <IConfigService>();
A.CallTo(() => configService.Config).Returns(new Config());
var outputEvent = new OutputEvent
{
ChannelName = "Channel",
StartTime = TimeSpan.FromSeconds(1),
EndTime = TimeSpan.FromSeconds(2)
};
var notification = new Confirmation
{
Content = outputEvent
};
var viewModel = new EventEditorViewModel(configService)
{
Notification = notification
};
viewModel.DeleteCommand.Execute();
Assert.True(notification.Confirmed);
Assert.Null(notification.Content);
}
public ColorMessage DispatchOutputMessage(ColorMessage colorMessage)
{
if (OutputEvent == null)
{
return(colorMessage);
}
foreach (OutputEventDelegate del in OutputEvent.GetInvocationList())
{
try
{
colorMessage = del(colorMessage);
}
catch (Exception e)
{
ChiConsole.WriteError("Error calling output handler", e);
}
if (colorMessage == null)
{
break;
}
}
return(colorMessage);
}
protected void Initialize()
{
MockEventAggregator = new Mock<IEventAggregator>();
MockRegionManager = new Mock<IRegionManager>();
MockServiceLocator = new Mock<IServiceLocator>();
MockBackgroundWorker = new Mock<BackgroundWorker>();
OutputEvent = new OutputEvent();
ClickableOutputEvent = new ClickableOutputEvent();
ProjectOpeningEvent projectOpeningEvent = new ProjectOpeningEvent();
LoadProjectEvent loadProjectEvent = new LoadProjectEvent();
ClearOutputEvent clearOutputEvent = new ClearOutputEvent();
ResultAddedEvent resultAddedEvent = new ResultAddedEvent();
ViewResultsEvent viewResultsEvent = new ViewResultsEvent();
StatusUpdateEvent statusUpdateEvent = new StatusUpdateEvent();
MockEventAggregator.Setup(mock => mock.GetEvent<ClearOutputEvent>()).Returns(clearOutputEvent);
MockEventAggregator.Setup(mock => mock.GetEvent<OutputEvent>()).Returns(OutputEvent);
MockEventAggregator.Setup(mock => mock.GetEvent<ClickableOutputEvent>()).Returns(ClickableOutputEvent);
MockEventAggregator.Setup(mock => mock.GetEvent<ProjectOpeningEvent>()).Returns(projectOpeningEvent);
MockEventAggregator.Setup(mock => mock.GetEvent<LoadProjectEvent>()).Returns(loadProjectEvent);
MockEventAggregator.Setup(mock => mock.GetEvent<ResultAddedEvent>()).Returns(resultAddedEvent);
MockEventAggregator.Setup(mock => mock.GetEvent<ViewResultsEvent>()).Returns(viewResultsEvent);
MockEventAggregator.Setup(mock => mock.GetEvent<StatusUpdateEvent>()).Returns(statusUpdateEvent);
List<IExperimentType> experimentTypes = new List<IExperimentType>();
experimentTypes.Add(new HydraExperimentType(MockServiceLocator.Object));
List<IDataProvider> dataProviders = new List<IDataProvider>();
dataProviders.Add(new ProteoWizardDataProvider(MockEventAggregator.Object));
MockServiceLocator.Setup(mock => mock.GetAllInstances<IExperimentType>()).Returns(experimentTypes);
MockServiceLocator.Setup(mock => mock.GetAllInstances<IDataProvider>()).Returns(dataProviders);
}
private Event CreateEvent()
{
Event evt;
switch (Type)
{
case EventType.Output:
evt = new OutputEvent();
break;
case EventType.Abort:
evt = new AbortCondition
{
ThresholdMin = ThresholdMin,
ThresholdMax = ThresholdMax
};
break;
default:
throw new InvalidOperationException("Invalid event type");
}
evt.StartTime = StartTime;
evt.EndTime = EndTime;
evt.ChannelName = Channel;
return(evt);
}
public void SettingNotificationWithEventLoadsEditorWithEventState_Output()
{
var configService = A.Fake <IConfigService>();
A.CallTo(() => configService.Config).Returns(new Config());
var outputEvent = new OutputEvent
{
ChannelName = "Channel",
StartTime = TimeSpan.FromSeconds(1),
EndTime = TimeSpan.FromSeconds(2)
};
var viewModel = new EventEditorViewModel(configService)
{
Notification = new Confirmation
{
Content = outputEvent
}
};
Assert.Equal(outputEvent.ChannelName, viewModel.Channel);
Assert.Equal(outputEvent.StartTime, viewModel.StartTime);
Assert.Equal(outputEvent.EndTime, viewModel.EndTime);
Assert.Equal(EventType.Output, viewModel.Type);
}
public void CanAddEventToSubsequence(Subsequence subsequence)
{
var evt = new OutputEvent
{
ChannelName = "Channel",
StartTime = TimeSpan.Zero,
EndTime = TimeSpan.FromSeconds(1)
};
var viewModel = new SequenceViewModel(new Sequence());
viewModel.CreateEventRequest.Raised += (o, e) =>
{
var confirmation = (IConfirmation)e.Context;
confirmation.Confirmed = true;
confirmation.Content = evt;
e.Callback();
};
viewModel.AddEventCommand.Execute(subsequence.ToString());
var seq = (subsequence == Subsequence.Primary ? viewModel.Sequence.PrimarySequence : viewModel.Sequence.AbortSequence);
Assert.Single(seq);
Assert.Same(evt, seq.First());
}
public void GuardedCondition()
{
string input = @"A[],
B[],
D[],
C[];
A[(count(@/C)==0)] -->* B,
D -->* C
";
var p = new ResedaParser();
p.dispTree(input);
var term = p.Generate(input);
System.Diagnostics.Debug.WriteLine(term.subProcess.ToSource());
var term2 = p.Generate(term.subProcess.ToSource());
Assert.AreEqual(term.ToSource(), term2.ToSource());
OutputEvent a = (OutputEvent)term.subProcess.structuredData[0];
OutputEvent b = (OutputEvent)term.subProcess.structuredData[1];
OutputEvent d = (OutputEvent)term.subProcess.structuredData[2];
OutputEvent c = (OutputEvent)term.subProcess.structuredData[3];
Assert.IsTrue(b.IsEnabled());
b.Execute();
Assert.IsFalse(c.IsEnabled());
Assert.ThrowsException <Exception>(() =>
{
c.Execute();
});
}
private void OutputMsg(Process process)
{
StreamReader sr = process.StandardOutput;
while (!sr.EndOfStream)
{
output = sr.ReadLine();
if (string.IsNullOrEmpty(output))
{
output = "Подготовка. Это может занять продолжительное время. Подождите.";
OutputEvent?.Invoke(output, true, false);
}
else
{
OutputEvent?.Invoke(output, false, false);
}
if (output.Contains("Ошибка"))
{
OutputEvent?.Invoke(output, false, true);
break;
}
}
OutputEvent?.Invoke(output, false, true);
}
public void BooleanFilterTest()
{
string input = "A[?]," +
"A[?]," +
"A[?]," +
"B[]" +
"; A[@.:v == 5] *--> B";
var p = new ResedaParser();
p.dispTree(input);
var term = p.Generate(input);
var term2 = p.Generate(term.subProcess.ToSource());
Assert.AreEqual(term.ToSource(), term2.ToSource());
InputEvent a0 = (InputEvent)term.subProcess.structuredData[0];
InputEvent a1 = (InputEvent)term.subProcess.structuredData[1];
InputEvent a2 = (InputEvent)term.subProcess.structuredData[2];
OutputEvent b = (OutputEvent)term.subProcess.structuredData[3];
a0.Execute(1);
System.Diagnostics.Debug.WriteLine(term.PrintTree(true));
a1.Execute(5);
System.Diagnostics.Debug.WriteLine(term.PrintTree(true));
a2.Execute(3);
System.Diagnostics.Debug.WriteLine(term.PrintTree(true));
}
void LogException(Exception ex, MeadowDebugAdapterThreadState threadState)
{
// Microsoft.VisualStudio.Shared.VSCodeDebugProtocol.Messages.ThreadEvent
var msg = new StringBuilder();
msg.AppendLine(ex.ToString());
msg.AppendLine();
msg.AppendLine("Solidity call stack: ");
try
{
msg.AppendLine(threadState.ExecutionTraceAnalysis.GetCallStackString(threadState.CurrentStepIndex.Value));
}
catch (Exception callstackResolveEx)
{
msg.AppendLine("Exception resolving callstack: " + callstackResolveEx.ToString());
}
var exceptionEvent = new OutputEvent
{
Category = OutputEvent.CategoryValue.Stderr,
Output = msg.ToString()
};
Protocol.SendEvent(exceptionEvent);
}
public void SendInput(double a, double b)
{
double[] results = Model.Calculate(a, b);
OutputEvent?.Invoke(this, $"a+b= {results[0]:G16}");
OutputEvent?.Invoke(this, $"a-b= {results[1]:G16}");
OutputEvent?.Invoke(this, $"a*b= {results[2]:G16}");
OutputEvent?.Invoke(this, $"a/b= {(b is 0.0 or (-0.0) ? "(Помилка ділення на нуль)" : results[3]):G16}");
}
public void MyTestInitialize()
{
mockEventAggregator = new Mock<IEventAggregator>();
outputEvent = new OutputEvent();
mockEventAggregator.Setup(mock => mock.GetEvent<OutputEvent>()).Returns(outputEvent);
msmsFragmentAnalyzer = new MsMsFragmentAnalyzer(mockEventAggregator.Object);
}
public void MyTestInitialize()
{
mockDataProvider = new Mock<IDataProvider>();
mockEventAggregator = new Mock<IEventAggregator>();
outputEvent = new OutputEvent();
mockEventAggregator.Setup(mock => mock.GetEvent<OutputEvent>()).Returns(outputEvent);
chromatographicPeakDetection = new ChromatographicPeakDetection(mockEventAggregator.Object);
}
public void onOutput(OutputEvent e)
{
string message = e.getMsg();
if (!(message.StartsWith("'board") || message.StartsWith("Board"))) //filtra i messaggi derivanti da text_term
{
System.Console.Write(e.getMsg());
}
}
protected override void Producer()
{
Event asynchronousEvent = new OutputEvent(new TestOutput(string.Empty, TestOutputType.Trace));
Assert.IsFalse(asynchronousEvent.IsSynchronous);
this.q.Enqueue(asynchronousEvent);
this.afterEnqueue = true;
Thread.MemoryBarrier();
}
protected override void HandleProtocolError(Exception ex)
{
var exceptionEvent = new OutputEvent
{
Category = OutputEvent.CategoryValue.Stderr,
Output = ex.ToString()
};
Protocol.SendEvent(exceptionEvent);
}
private Event GenerateOutputEvent(ParseTreeNode child, int i)
{
i++;
var result = new OutputEvent(child.ChildNodes[i - 1].Token.Text, GenerateExpression(child.ChildNodes[i + 1]));
if (child.ChildNodes.Count > i + 2 && child.ChildNodes[i + 2].Term.Name == "Process")
{
AddProcess(result, child.ChildNodes[i + 2]);
}
return(result);
}
public SavitzkyGolaySmoothing(IEventAggregator eventAggregator, IRegionManager regionManager)
{
_eventAggregator = eventAggregator;
_output = eventAggregator.GetEvent<OutputEvent>();
_clickableOutput = eventAggregator.GetEvent<ClickableOutputEvent>();
_regionManager = regionManager;
Enabled = true;
LeftParam = 3;
RightParam = 3;
Order = 2;
}
void outputWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
if (this.Active == false)
{
return;
}
if (e.UserState is OutputEvent)
{
OutputEvent outputEvent = e.UserState as OutputEvent;
this.Write(outputEvent.Output);
}
}
public void BPMTestThomas()
{
string input = @"orders[]{
create_order[?:@/customers/customer/customer_id:value]
;
create_order -->>{
order[]{
!order_id[freshid()],
!customer_id[@trigger:value]
}
}
},
customers[]{
create_customer[?],
customer[] {
customer_id(0)[],
customer_name('John')[]
},
customer[]{
customer_id(1)[],
customer_name('Mary')[]
}
;
create_customer -->> {
customer[]{
!customer_id[freshid()],
!customer_name[?]
}
}
}";
var p = new ResedaParser();
p.dispTree(input);
var term = p.Generate(input);
System.Diagnostics.Debug.WriteLine(term.subProcess.ToSource());
var term2 = p.Generate(term.subProcess.ToSource());
//Assert.AreEqual(term.ToSource(), term2.ToSource());
InputEvent create_order = (InputEvent)term.subProcess.structuredData[0].subProcess.structuredData[0];
create_order.Execute(1);
System.Diagnostics.Debug.WriteLine(term.ToSource());
OutputEvent o1 = (OutputEvent)term.subProcess.structuredData[0].subProcess.structuredData[1].subProcess.structuredData[0];
OutputEvent o2 = (OutputEvent)term.subProcess.structuredData[0].subProcess.structuredData[1].subProcess.structuredData[1];
o1.Execute();
o2.Execute();
System.Diagnostics.Debug.WriteLine(term.ToSource());
}
public void Write(TProtocol oprot)
{
oprot.IncrementRecursionDepth();
try
{
TStruct struc = new TStruct("TDDIFTAArtifactUnion");
oprot.WriteStructBegin(struc);
TField field = new TField();
if (InputEvent != null && __isset.InputEvent)
{
field.Name = "InputEvent";
field.Type = TType.Struct;
field.ID = 1;
oprot.WriteFieldBegin(field);
InputEvent.Write(oprot);
oprot.WriteFieldEnd();
}
if (OutputEvent != null && __isset.OutputEvent)
{
field.Name = "OutputEvent";
field.Type = TType.Struct;
field.ID = 2;
oprot.WriteFieldBegin(field);
OutputEvent.Write(oprot);
oprot.WriteFieldEnd();
}
if (Gate != null && __isset.Gate)
{
field.Name = "Gate";
field.Type = TType.Struct;
field.ID = 3;
oprot.WriteFieldBegin(field);
Gate.Write(oprot);
oprot.WriteFieldEnd();
}
if (FTAPropagation != null && __isset.FTAPropagation)
{
field.Name = "FTAPropagation";
field.Type = TType.Struct;
field.ID = 4;
oprot.WriteFieldBegin(field);
FTAPropagation.Write(oprot);
oprot.WriteFieldEnd();
}
oprot.WriteFieldStop();
oprot.WriteStructEnd();
}
finally
{
oprot.DecrementRecursionDepth();
}
}
private void process_data_received(object sender, DataReceivedEventArgs dataReceivedEventArgs)
{
if (!String.IsNullOrEmpty(dataReceivedEventArgs.Data))
{
if (dataReceivedEventArgs.Data.StartsWith("ERROR"))
{
ProcessErrorEvnet?.Invoke(this, dataReceivedEventArgs.Data);
}
var outputData = dataReceivedEventArgs.Data + Environment.NewLine;
ThreadPool.QueueUserWorkItem(writeLogToFile, outputData);
OutputEvent?.Invoke(outputData);
}
}
public void InitialValueTest()
{
string input = @"
!A(3)[?],
!B[?],
!C(1)[freshid()];";
var p = new ResedaParser();
p.dispTree(input);
var term = p.Generate(input);
InputEvent a = (InputEvent)term.subProcess.structuredData[0];
InputEvent b = (InputEvent)term.subProcess.structuredData[1];
OutputEvent c = (OutputEvent)term.subProcess.structuredData[2];
System.Diagnostics.Debug.WriteLine(term.subProcess.ToSource());
var term2 = p.Generate(term.subProcess.ToSource());
Assert.AreEqual(term.ToSource(), term2.ToSource());
Assert.AreEqual(c.marking.value.ToString(), "1");
Assert.AreEqual(a.marking.value.ToString(), "3");
Assert.IsNull(b.marking.value);
c.Execute();
Assert.AreEqual(c.marking.value.ToString(), "4");
b.Execute(1);
Assert.AreEqual(c.marking.value.ToString(), "4");
a.Execute(5);
Assert.AreEqual(a.marking.value.ToString(), "5");
c.Execute();
Assert.AreEqual(c.marking.value.ToString(), "6");
/*
* c.Execute();
* System.Diagnostics.Debug.WriteLine(c.ToSource());
* System.Diagnostics.Debug.WriteLine(c.marking.value);
* Assert.AreEqual(c.marking.value.ToString(), "0");
* c.Execute();
* Assert.AreEqual(c.marking.value.ToString(), "1");
* a.Execute(3);
* c.Execute();
* Assert.AreEqual(c.marking.value.ToString(), "4");
*
* b.Execute(1);
* c.Execute();
* Assert.AreEqual(c.marking.value.ToString(), "5");
*
* b.Execute(10);
* c.Execute();
* Assert.AreEqual(c.marking.value.ToString(), "11");
*/
}
public void RunStep(DateTime cleardate, ClearStepInfo step, OutputEvent func)
{
RegisterOutput(func);
try
{
ClearConfigManagerMock.RunStep(step);
Run(cleardate);
ClearConfigManagerMock.FinishStep(step);
}
catch (Exception ex)
{
ClearConfigManagerMock.ErrorStep(step);
throw ex;
}
}
public override string ToString()
{
StringBuilder __sb = new StringBuilder("TDDIFTAArtifactUnion(");
bool __first = true;
if (InputEvent != null && __isset.InputEvent)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("InputEvent: ");
__sb.Append(InputEvent == null ? "<null>" : InputEvent.ToString());
}
if (OutputEvent != null && __isset.OutputEvent)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("OutputEvent: ");
__sb.Append(OutputEvent == null ? "<null>" : OutputEvent.ToString());
}
if (Gate != null && __isset.Gate)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("Gate: ");
__sb.Append(Gate == null ? "<null>" : Gate.ToString());
}
if (FTAPropagation != null && __isset.FTAPropagation)
{
if (!__first)
{
__sb.Append(", ");
}
__first = false;
__sb.Append("FTAPropagation: ");
__sb.Append(FTAPropagation == null ? "<null>" : FTAPropagation.ToString());
}
__sb.Append(")");
return(__sb.ToString());
}
private void Worker()
{
while (_filenames.TryDequeue(out var name))
{
if (StopSignal.WaitOne(0))
{
OutputEvent?.Invoke("Breaking by signal");
return;
}
//var prediction = FileRead(name);
//Console.WriteLine(name + prediction);
EventResult?.Invoke(FileRead(name));
}
OutputEvent?.Invoke("Normal finish");
}
public XicPeakPicker(IEventAggregator eventAggregator)
{
_output = eventAggregator.GetEvent<OutputEvent>();
}
public void MyTestInitialize()
{
mockEventAggregator = new Mock<IEventAggregator>();
outputEvent = new OutputEvent();
mockEventAggregator.Setup(mock => mock.GetEvent<OutputEvent>()).Returns(outputEvent);
isotopicProfileFinder = new IsotopicProfileFinder(mockEventAggregator.Object);
isotopicProfileFinder.PeakWidthMaximum = 0.5;
isotopicProfileFinder.MSPeakSelectionOption = Hydra.Core.MSPeakSelectionOption.MostIntenseWithinMzVariation;
}
private void Produce()
{
try
{
Event e = new OutputEvent(new TestOutput(this.ProducerThread.Name, TestOutputType.Log));
DateTime start = DateTime.Now;
while (DateTime.Now - start <= TimeSpan.FromSeconds(3))
{
this.queue.Enqueue(e);
this.SentEventsCount++;
this.MaxQueueLength = Math.Max(this.queue.Count, this.MaxQueueLength);
// without Sleep or with just a Sleep(0), the EventPump thread does not keep up and the queue gets very long
if (this.delay)
{
Thread.Sleep(1);
}
}
}
catch (Exception ex)
{
this.Exception = ex;
}
}
public DeuterationResultGenerator(IEventAggregator eventAggregator)
{
_output = eventAggregator.GetEvent<OutputEvent>();
}
public ProteoWizardDataProvider(IEventAggregator eventAggregator)
{
_eventAggregator = eventAggregator;
_output = _eventAggregator.GetEvent<OutputEvent>();
}
public void MyTestInitialize()
{
mockEventAggregator = new Mock<IEventAggregator>();
outputEvent = new OutputEvent();
mockEventAggregator.Setup(mock => mock.GetEvent<OutputEvent>()).Returns(outputEvent);
labelAmountCalculator = new LabelAmountCalculator(mockEventAggregator.Object);
}
public MsMsFragmentAnalyzer(IEventAggregator eventAggregator)
{
this.eventAggregator = eventAggregator;
output = eventAggregator.GetEvent<OutputEvent>();
}
public SpectralPeakDetection(IEventAggregator eventAggregator)
: base(eventAggregator)
{
_output = eventAggregator.GetEvent<OutputEvent>();
}
public void onOutput(OutputEvent ev)
{
String s = Utilities.stripQuotes(ev.getMsg());
System.Console.Out.Write(s);
}
public IsotopicProfileFinder(IEventAggregator eventAggregator)
{
_output = eventAggregator.GetEvent<OutputEvent>();
}
public void MyTestInitialize()
{
mockEventAggregator = new Mock<IEventAggregator>();
outputEvent = new OutputEvent();
mockEventAggregator.Setup(mock => mock.GetEvent<OutputEvent>()).Returns(outputEvent);
xicPeakPicker = new XicPeakPicker(mockEventAggregator.Object);
}
public LabelAmountCalculator(IEventAggregator eventAggregator)
{
_output = eventAggregator.GetEvent<OutputEvent>();
mode = Mode.ExperimentalMassAndIntensity;
}
public ChromatographicPeakDetection(IEventAggregator eventAggregator)
: base(eventAggregator)
{
_output = eventAggregator.GetEvent<OutputEvent>();
}
public void MyTestInitialize()
{
Mock<IRegionManager> mockRegionManager = new Mock<IRegionManager>();
mockDataProvider = new Mock<IDataProvider>();
mockEventAggregator = new Mock<IEventAggregator>();
outputEvent = new OutputEvent();
clickableOutputEvent = new ClickableOutputEvent();
mockEventAggregator.Setup(mock => mock.GetEvent<ClickableOutputEvent>()).Returns(clickableOutputEvent);
mockEventAggregator.Setup(mock => mock.GetEvent<OutputEvent>()).Returns(outputEvent);
smoothing = new SavitzkyGolaySmoothing(mockEventAggregator.Object, mockRegionManager.Object);
}
public void onOutput(OutputEvent ev)
{
String s = Utilities.stripQuotes(ev.getMsg());
s = s.Replace("\n", "\r\n");
outputArea.Text += s;
outputArea.SelectionStart = outputArea.TextLength;
outputArea.SelectionLength = 0;
outputArea.ScrollToCaret();
Application.DoEvents();
if (library.enableTrace)
{
System.Console.Out.Write(s);
}
}
protected override void Producer()
{
Event asynchronousEvent = new OutputEvent(new TestOutput(string.Empty, TestOutputType.Trace));
Assert.IsFalse(asynchronousEvent.IsSynchronous);
this.q.Enqueue(asynchronousEvent);
this.afterEnqueue = true;
Thread.MemoryBarrier();
}
