internal static EventWaiter VerifyWorkspaceFailedEvent(this Workspace workspace, Action <WorkspaceDiagnosticEventArgs> action)
{
var wew = new EventWaiter();
workspace.WorkspaceFailed += wew.Wrap <WorkspaceDiagnosticEventArgs>((sender, args) => action(args));
return(wew);
}
internal static EventWaiter VerifyWorkspaceChangedEvent(this MSBuildWorkspace workspace, Action <WorkspaceChangeEventArgs> action)
{
var wew = new EventWaiter();
workspace.WorkspaceChanged += wew.Wrap <WorkspaceChangeEventArgs>((sender, args) => action(args));
return(wew);
}
public ReaderViewBase()
{
this.DefaultStyleKey = typeof(ReaderViewBase);
_gestureRecognizer = new GestureRecognizer();
_gestureRecognizer.GestureSettings = GestureSettings.ManipulationTranslateX;
_gestureRecognizer.ManipulationStarted += _gestureRecognizer_ManipulationStarted;
_gestureRecognizer.ManipulationUpdated += _gestureRecognizer_ManipulationUpdated;
_gestureRecognizer.ManipulationCompleted += _gestureRecognizer_ManipulationCompleted;
PointerWheelChangedEventHandler = new PointerEventHandler(_PointerWheelChanged);
PointerPressedEventHandler = new PointerEventHandler(_PointerPressed);
PointerMovedEventHandler = new PointerEventHandler(_PointerMoved);
PointerReleasedEventHandler = new PointerEventHandler(_PointerReleased);
PointerCanceledEventHandler = new PointerEventHandler(_PointerCanceled);
TouchTappedEventHandler = new TappedEventHandler(_TouchTapped);
TouchHoldingEventHandler = new HoldingEventHandler(_TouchHolding);
this.AddHandler(UIElement.PointerWheelChangedEvent, PointerWheelChangedEventHandler, true);
this.AddHandler(UIElement.PointerPressedEvent, PointerPressedEventHandler, true);
this.AddHandler(UIElement.PointerMovedEvent, PointerMovedEventHandler, true);
this.AddHandler(UIElement.PointerReleasedEvent, PointerReleasedEventHandler, true);
this.AddHandler(UIElement.PointerCanceledEvent, PointerCanceledEventHandler, true);
this.AddHandler(UIElement.TappedEvent, TouchTappedEventHandler, true);
this.AddHandler(UIElement.HoldingEvent, TouchHoldingEventHandler, true);
this.SizeChanged += ReaderViewBase_SizeChanged;
IndexWaiter = new EventWaiter();
CreateContentDelayer = new EventDelayer();
CreateContentDelayer.ResetWhenDelayed = true;
CreateContentDelayer.Arrived += CreateContentWaiter_Arrived;
}
/// <summary> Process the queue. </summary>
protected override void ProcessQueue()
{
// Endless loop unless aborted
while (ThreadRunState != ThreadRunStates.Abort)
{
// Calculate sleep time based on incoming command speed
//_queueSpeed.SetCount(Queue.Count);
//_queueSpeed.CalcSleepTime();
EventWaiter.Wait(1000);
// Process queue unless stopped
if (ThreadRunState == ThreadRunStates.Start)
{
// Only actually sleep if there are no commands in the queue
//if (Queue.Count == 0) _queueSpeed.Sleep();
var dequeueCommand = DequeueCommand();
if (dequeueCommand != null)
{
CmdMessenger.HandleMessage(dequeueCommand);
}
}
//else
//{
// _queueSpeed.Sleep();
//}
}
}
public async Task <ReadOnlyCollection <T> > CollectEventArgsAsync <T>(Func <T, bool> predicate, TimeSpan?timeoutoverride = null) where T : AsyncEventArgs
{
var timeout = timeoutoverride ?? this.Config.Timeout;
using var waiter = new EventWaiter <T>(this.Client);
var res = await waiter.CollectMatches(new CollectRequest <T>(predicate, timeout)).ConfigureAwait(false);
return(res);
}
/// <summary>
/// Waits for specific event args to be received. Make sure the appropriate <see cref="DiscordIntents"/> are registered, if needed.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="predicate"></param>
/// <param name="timeoutoverride"></param>
/// <returns></returns>
public async Task <InteractivityResult <T> > WaitForEventArgsAsync <T>(Func <T, bool> predicate, TimeSpan?timeoutoverride = null) where T : AsyncEventArgs
{
var timeout = timeoutoverride ?? this.Config.Timeout;
using var waiter = new EventWaiter <T>(this.Client);
var res = await waiter.WaitForMatch(new MatchRequest <T>(predicate, timeout)).ConfigureAwait(false);
return(new InteractivityResult <T>(res == null, res));
}
public override async Task ConnectAsync() {
var handshakeWaiter = new EventWaiter();
Handshaked += handshakeWaiter.Callback;
await Connect(Address);
await handshakeWaiter.Wait();
Handshaked -= handshakeWaiter.Callback;
}
protected internal override void Setup(DiscordClient client)
{
this.Client = client;
this.MessageCreatedWaiter = new EventWaiter <MessageCreateEventArgs>(this.Client);
this.MessageReactionAddWaiter = new EventWaiter <MessageReactionAddEventArgs>(this.Client);
this.TypingStartWaiter = new EventWaiter <TypingStartEventArgs>(this.Client);
this.Poller = new Poller(this.Client);
this.ReactionCollector = new ReactionCollector(this.Client);
this.Paginator = new Paginator(this.Client);
}
IEnumerable <bool> TestFunc(EventWaiter waiter)
{
Console.WriteLine("...Process A..."); // ...Process A...
Elevator elv = theMultishuttle.elevators["L01"];
yield return(waiter.Wait(elv, "OnElevatorArrived")); // [C]
Console.WriteLine("...Process B..."); // ...Process B...
}
/// <summary> Queue the command wrapped in a command strategy. </summary>
/// <param name="commandStrategy"> The command strategy. </param>
public override void QueueCommand(CommandStrategy commandStrategy)
{
lock (Queue)
{
// Process all generic enqueue strategies
Queue.Enqueue(commandStrategy);
foreach (var generalStrategy in GeneralStrategies)
{
generalStrategy.OnEnqueue();
}
}
// Give a signal to indicate that a new item has been queued
EventWaiter.Set();
if (NewLineReceived != null)
{
NewLineReceived(this, new NewLineEvent.NewLineArgs(commandStrategy.Command));
}
}
public void EventWaiterTest()
{
// Delay event invocation
const int eventDelay = 1000;
var raiseEventTask = Task.Run(async() => {
// Wait delay
await Task.Delay(eventDelay);
// Raise event
OnTestEvent(new EventArgs());
});
// Get awaiter for event
var waitEventTask = EventWaiter.WaitAsync <EventArgs>((h) => TestEvent += h, (h) => TestEvent -= h);
// Wait (await waitEventTask)
var waitResult = waitEventTask.Wait(eventDelay + 100);
Assert.True(waitResult);
}
public ReaderView()
{
this.DefaultStyleKey = typeof(ReaderView);
_GestureRecognizer = new GestureRecognizer();
_GestureRecognizer.GestureSettings = GestureSettings.ManipulationTranslateX;
_GestureRecognizer.ManipulationStarted += _GestureRecognizer_ManipulationStarted;
_GestureRecognizer.ManipulationUpdated += _GestureRecognizer_ManipulationUpdated;
_GestureRecognizer.ManipulationCompleted += _GestureRecognizer_ManipulationCompleted;
PointerWheelChangedEventHandler = new PointerEventHandler(_PointerWheelChanged);
PointerPressedEventHandler = new PointerEventHandler(_PointerPressed);
PointerMovedEventHandler = new PointerEventHandler(_PointerMoved);
PointerReleasedEventHandler = new PointerEventHandler(_PointerReleased);
PointerCanceledEventHandler = new PointerEventHandler(_PointerCanceled);
this.AddHandler(UIElement.PointerWheelChangedEvent, PointerWheelChangedEventHandler, true);
this.AddHandler(UIElement.PointerPressedEvent, PointerPressedEventHandler, true);
this.AddHandler(UIElement.PointerMovedEvent, PointerMovedEventHandler, true);
this.AddHandler(UIElement.PointerReleasedEvent, PointerReleasedEventHandler, true);
this.AddHandler(UIElement.PointerCanceledEvent, PointerCanceledEventHandler, true);
this.SizeChanged += ReaderView_SizeChanged;
IndexWaiter = new EventWaiter();
CreateContentDelayer = new EventDelayer();
CreateContentDelayer.ResetWhenDelayed = true;
CreateContentDelayer.Arrived += CreateContentWaiter_Arrived;
this.Unloaded += (s, a) =>
{
this.RemoveHandler(UIElement.PointerWheelChangedEvent, PointerWheelChangedEventHandler);
this.RemoveHandler(UIElement.PointerPressedEvent, PointerPressedEventHandler);
this.RemoveHandler(UIElement.PointerMovedEvent, PointerMovedEventHandler);
this.RemoveHandler(UIElement.PointerReleasedEvent, PointerReleasedEventHandler);
this.RemoveHandler(UIElement.PointerCanceledEvent, PointerCanceledEventHandler);
};
}
public async Task TestDocumentEvents()
{
using (var workspace = CreateWorkspace())
{
var doc1Text = "public class C { }";
var document = new TestHostDocument(doc1Text);
var project1 = new TestHostProject(workspace, document, name: "project1");
var longEventTimeout = TimeSpan.FromMinutes(5);
var shortEventTimeout = TimeSpan.FromSeconds(5);
workspace.AddTestProject(project1);
// Creating two waiters that will allow us to know for certain if the events have fired.
using (var closeWaiter = new EventWaiter())
using (var openWaiter = new EventWaiter())
{
// Wrapping event handlers so they can notify us on being called.
var documentOpenedEventHandler = openWaiter.Wrap <DocumentEventArgs>(
(sender, args) => Assert.True(args.Document.Id == document.Id,
"The document given to the 'DocumentOpened' event handler did not have the same id as the one created for the test."));
var documentClosedEventHandler = closeWaiter.Wrap <DocumentEventArgs>(
(sender, args) => Assert.True(args.Document.Id == document.Id,
"The document given to the 'DocumentClosed' event handler did not have the same id as the one created for the test."));
workspace.DocumentOpened += documentOpenedEventHandler;
workspace.DocumentClosed += documentClosedEventHandler;
workspace.OpenDocument(document.Id);
workspace.CloseDocument(document.Id);
// Wait for all workspace tasks to finish. After this is finished executing, all handlers should have been notified.
await WaitForWorkspaceOperationsToComplete(workspace);
// Wait to receive signal that events have fired.
Assert.True(openWaiter.WaitForEventToFire(longEventTimeout),
string.Format("event 'DocumentOpened' was not fired within {0} minutes.",
longEventTimeout.Minutes));
Assert.True(closeWaiter.WaitForEventToFire(longEventTimeout),
string.Format("event 'DocumentClosed' was not fired within {0} minutes.",
longEventTimeout.Minutes));
workspace.DocumentOpened -= documentOpenedEventHandler;
workspace.DocumentClosed -= documentClosedEventHandler;
workspace.OpenDocument(document.Id);
workspace.CloseDocument(document.Id);
// Wait for all workspace tasks to finish. After this is finished executing, all handlers should have been notified.
await WaitForWorkspaceOperationsToComplete(workspace);
// Verifying that an event has not been called is difficult to prove.
// All events should have already been called so we wait 5 seconds and then assume the event handler was removed correctly.
Assert.False(openWaiter.WaitForEventToFire(shortEventTimeout),
string.Format("event handler 'DocumentOpened' was called within {0} seconds though it was removed from the list.",
shortEventTimeout.Seconds));
Assert.False(closeWaiter.WaitForEventToFire(shortEventTimeout),
string.Format("event handler 'DocumentClosed' was called within {0} seconds though it was removed from the list.",
shortEventTimeout.Seconds));
}
}
}
public void TestDocumentEvents()
{
using (var workspace = CreateWorkspace())
{
var doc1Text = "public class C { }";
var document = new TestHostDocument(doc1Text);
var project1 = new TestHostProject(workspace, document, name: "project1");
var longEventTimeout = TimeSpan.FromMinutes(5);
var shortEventTimeout = TimeSpan.FromSeconds(5);
workspace.AddTestProject(project1);
// Creating two waiters that will allow us to know for certain if the events have fired.
using (var closeWaiter = new EventWaiter())
using (var openWaiter = new EventWaiter())
{
// Wrapping event handlers so they can notify us on being called.
var documentOpenedEventHandler = openWaiter.Wrap<DocumentEventArgs>(
(sender, args) => Assert.True(args.Document.Id == document.Id,
"The document given to the 'DocumentOpened' event handler did not have the same id as the one created for the test."));
var documentClosedEventHandler = closeWaiter.Wrap<DocumentEventArgs>(
(sender, args) => Assert.True(args.Document.Id == document.Id,
"The document given to the 'DocumentClosed' event handler did not have the same id as the one created for the test."));
workspace.DocumentOpened += documentOpenedEventHandler;
workspace.DocumentClosed += documentClosedEventHandler;
workspace.OpenDocument(document.Id);
workspace.CloseDocument(document.Id);
// Wait for all workspace tasks to finish. After this is finished executing, all handlers should have been notified.
WaitForWorkspaceOperationsToComplete(workspace);
// Wait to recieve signal that events have fired.
Assert.True(openWaiter.WaitForEventToFire(longEventTimeout),
string.Format("event 'DocumentOpened' was not fired within {0} minutes.",
longEventTimeout.Minutes));
Assert.True(closeWaiter.WaitForEventToFire(longEventTimeout),
string.Format("event 'DocumentClosed' was not fired within {0} minutes.",
longEventTimeout.Minutes));
workspace.DocumentOpened -= documentOpenedEventHandler;
workspace.DocumentClosed -= documentClosedEventHandler;
workspace.OpenDocument(document.Id);
workspace.CloseDocument(document.Id);
// Wait for all workspace tasks to finish. After this is finished executing, all handlers should have been notified.
WaitForWorkspaceOperationsToComplete(workspace);
// Verifiying that an event has not been called is difficult to prove.
// All events should have already been called so we wait 5 seconds and then assume the event handler was removed correctly.
Assert.False(openWaiter.WaitForEventToFire(shortEventTimeout),
string.Format("event handler 'DocumentOpened' was called within {0} seconds though it was removed from the list.",
shortEventTimeout.Seconds));
Assert.False(closeWaiter.WaitForEventToFire(shortEventTimeout),
string.Format("event handler 'DocumentClosed' was called within {0} seconds though it was removed from the list.",
shortEventTimeout.Seconds));
}
}
}
internal static EventWaiter VerifyWorkspaceFailedEvent(this MSBuildWorkspace workspace, Action<WorkspaceDiagnosticEventArgs> action)
{
var wew = new EventWaiter();
workspace.WorkspaceFailed += wew.Wrap<WorkspaceDiagnosticEventArgs>((sender, args) => action(args));
return wew;
}
internal static EventWaiter VerifyWorkspaceChangedEvent(this Workspace workspace, Action<WorkspaceChangeEventArgs> action)
{
var wew = new EventWaiter();
workspace.WorkspaceChanged += wew.Wrap<WorkspaceChangeEventArgs>((sender, args) => action(args));
return wew;
}