public TItem Dequeue(CancellationToken cancellationToken = default) { while (!cancellationToken.IsCancellationRequested) { lock (_syncRoot) { if (_items.Count > 0) { var item = _items.First.Value; _items.RemoveFirst(); return(item); } if (_items.Count == 0) { _gate?.Reset(); } } _gate?.Wait(cancellationToken); } throw new OperationCanceledException(); }
public void WaitOne() { if (!_disposing.Value) { _mreCompleted?.Wait(); } }
private static void AttachCtrlcSigtermShutdown( CancellationTokenSource cts, ManualResetEventSlim resetEvent, string shutdownMessage) { void Shutdown() { if (!cts.IsCancellationRequested) { if (!string.IsNullOrEmpty(shutdownMessage)) { Console.WriteLine(shutdownMessage); } try { cts.Cancel(); } catch (ObjectDisposedException) { } } // Wait on the given reset event resetEvent?.Wait(); }; AppDomain.CurrentDomain.ProcessExit += (sender, eventArgs) => Shutdown(); Console.CancelKeyPress += (sender, eventArgs) => { Shutdown(); // Don't terminate the process immediately, wait for the Main thread to exit gracefully. eventArgs.Cancel = true; }; }
public WorkParcel GetParcel() { EnsureNotOnThread(); // Only the background thread can get a parcel lock (_disposeLock) { if (_disposed) { return(WorkParcel.Empty); } } _hasParcel?.Wait(_cancelSource.Token); lock (_disposeLock) { if (_disposed) { return(WorkParcel.Empty); } _hasParcel.Reset(); lock (_stateLock) { // Create a cancellation source for this parcel _currentParcelCancelSource = new CancellationTokenSource(); var changes = _changes; _changes = new List <ChangeReference>(); return(new WorkParcel(changes, _currentParcelCancelSource.Token)); } } }
// Run in a dedicated thread private async void PerformRead() { var original = _readWriteCancellationTokenSource; if (original == null) { Log.To.Sync.V(Tag, "_readWriteCancellationTokenSource is null, cancelling read..."); return; } var zeroByteCount = 0; // This will protect us against future nullification of the original source var cancelSource = CancellationTokenSource.CreateLinkedTokenSource(original.Token); while (!cancelSource.IsCancellationRequested) { try { _receivePause?.Wait(cancelSource.Token); } catch (ObjectDisposedException) { return; } catch (OperationCanceledException) { return; } try { var stream = NetworkStream; if (stream == null) { return; } // Phew, at this point we are clear to actually read from the stream var received = await stream.ReadAsync(_buffer, 0, _buffer.Length, cancelSource.Token).ConfigureAwait(false); if (received == 0) { if (zeroByteCount++ >= 10) { Log.To.Sync.I(Tag, "Failed to read from stream too many times, signaling closed..."); DidClose(new CouchbasePosixException(PosixBase.GetCode(nameof(PosixWindows.ECONNRESET)))); return; } // Should only happen on a closed stream, but just in case let's continue // after a small delay (wait for cancellation to confirm) Thread.Sleep(200); continue; } zeroByteCount = 0; var data = _buffer.Take(received).ToArray(); Receive(data); } catch (Exception e) { DidClose(e); return; } } }
public static void CancelBeforeWait() { ManualResetEventSlim mres = new ManualResetEventSlim(); CancellationTokenSource cs = new CancellationTokenSource(); cs.Cancel(); CancellationToken ct = cs.Token; const int millisec = 100; TimeSpan timeSpan = new TimeSpan(100); EnsureOperationCanceledExceptionThrown( () => mres.Wait(ct), ct, "CancelBeforeWait: An OCE should have been thrown."); EnsureOperationCanceledExceptionThrown( () => mres.Wait(millisec, ct), ct, "CancelBeforeWait: An OCE should have been thrown."); EnsureOperationCanceledExceptionThrown( () => mres.Wait(timeSpan, ct), ct, "CancelBeforeWait: An OCE should have been thrown."); mres.Dispose(); }
public void Successful_AppObserver_Run_Cancellation_Via_ObserverManager() { ObserverManager.FabricServiceContext = this.context; ObserverManager.TelemetryEnabled = false; ObserverManager.EtwEnabled = false; ObserverManager.FabricClientInstance = new FabricClient(FabricClientRole.User); var stopWatch = new Stopwatch(); var obs = new AppObserver { IsEnabled = true, NodeName = "_Test_0", IsTestRun = true, }; var obsMgr = new ObserverManager(obs) { ApplicationName = "fabric:/TestApp0", }; var objReady = new ManualResetEventSlim(false); stopWatch.Start(); var t = Task.Factory.StartNew(() => { objReady.Set(); obsMgr.StartObservers(); }); objReady?.Wait(); while (!obsMgr.IsObserverRunning && stopWatch.Elapsed.TotalSeconds < 10) { // wait... } stopWatch.Stop(); // Observer is running. Stop it... obsMgr.StopObservers(); Thread.Sleep(5); Assert.IsFalse(obsMgr.IsObserverRunning); obs.Dispose(); objReady?.Dispose(); }
public static void OnCompleted_CompletesInAnotherSynchronizationContext(bool generic, bool? continueOnCapturedContext) { SynchronizationContext origCtx = SynchronizationContext.Current; try { // Create a context that tracks operations, and set it as current var validateCtx = new ValidateCorrectContextSynchronizationContext(); Assert.Equal(0, validateCtx.PostCount); SynchronizationContext.SetSynchronizationContext(validateCtx); // Create a not-completed task and get an awaiter for it var mres = new ManualResetEventSlim(); var tcs = new TaskCompletionSource<object>(); // Hook up a callback bool postedInContext = false; Action callback = () => { postedInContext = ValidateCorrectContextSynchronizationContext.IsPostedInContext; mres.Set(); }; if (generic) { if (continueOnCapturedContext.HasValue) tcs.Task.ConfigureAwait(continueOnCapturedContext.Value).GetAwaiter().OnCompleted(callback); else tcs.Task.GetAwaiter().OnCompleted(callback); } else { if (continueOnCapturedContext.HasValue) ((Task)tcs.Task).ConfigureAwait(continueOnCapturedContext.Value).GetAwaiter().OnCompleted(callback); else ((Task)tcs.Task).GetAwaiter().OnCompleted(callback); } Assert.False(mres.IsSet, "Callback should not yet have run."); // Complete the task in another context and wait for the callback to run Task.Run(() => tcs.SetResult(null)); mres.Wait(); // Validate the callback ran and in the correct context bool shouldHavePosted = !continueOnCapturedContext.HasValue || continueOnCapturedContext.Value; Assert.Equal(shouldHavePosted ? 1 : 0, validateCtx.PostCount); Assert.Equal(shouldHavePosted, postedInContext); } finally { // Reset back to the original context SynchronizationContext.SetSynchronizationContext(origCtx); } }
public WorkParcel GetParcel() { EnsureNotOnThread(); // Only the background thread can get a parcel lock (_disposeLock) { if (_disposed) { return(WorkParcel.Empty); } } try { _hasParcel?.Wait(_cancelSource.Token); } catch (Exception) { // Swallow any exceptions caused by waiting on the parcel to avoid crashing VS. } lock (_disposeLock) { if (_disposed) { return(WorkParcel.Empty); } try { _hasParcel.Reset(); } catch (Exception) { // Swallow any exceptions caused by resetting the parcel switch to avoid crashing VS. } lock (_stateLock) { // Create a cancellation source for this parcel _currentParcelCancelSource = new CancellationTokenSource(); var changes = _changes; _changes = new List <ChangeReference>(); return(new WorkParcel(changes, _currentParcelCancelSource.Token)); } } }
public static void RunManualResetEventSlimTest1_SimpleWait() { ManualResetEventSlim ev1 = new ManualResetEventSlim(false); ManualResetEventSlim ev2 = new ManualResetEventSlim(false); ManualResetEventSlim ev3 = new ManualResetEventSlim(false); Task.Run(delegate { ev2.Set(); ev1.Wait(); ev3.Set(); }); ev2.Wait(); //Thread.Sleep(100); ev1.Set(); ev3.Wait(); }
/// <summary> /// Blocks the calling thread until the server starts or fails to start within the allotted timeout period. /// </summary> /// <param name="msTimeout">The number of milliseconds to wait before a timeout occurs.</param> /// <returns>True if the server starts within the specified timeout period, otherwise False.</returns> public bool WaitForIsListening(int msTimeout = 10000) { //return TimeoutFunc<bool>.Create(msTimeout, ct => //{ // var result = false; // while (!ct.IsCancellationRequested) // { // if (_mreIsListening != null) // { // result = _mreIsListening.WaitOne(1); // if (result) // break; // } // System.Threading.Thread.Sleep(1); // } // return result; //}).Start(); return(_mreIsListening?.Wait(msTimeout) ?? false); }
private void Dispose(bool disposing) { ReleaseUnmanagedResources(); if (!disposing) { return; } _processingThreadCancel?.Cancel(); _threadEndEvent?.Wait(); _threadEndEvent?.Dispose(); _processingThreadCancel?.Dispose(); _queueCount?.Dispose(); _poolCount?.Dispose(); if (_handle.IsAllocated) { _handle.Free(); } }
/// <summary> /// Waits for a response from the server. /// </summary> /// <returns>A Task which returns a CallResult<TResponseType></returns> public async Task <RPCResult <TResponseType> > WaitForResponse <TResponseType>() { var result = await Task.Run(() => { Exception ex = null; try { _mreResponseReceived?.Wait(); return(GetResult <TResponseType>(Message.Response, Message.Exception)); } catch (NullReferenceException) { ex = new ObjectDisposedException("CallHandler", "The CallHandler has been disposed. The response cannot be trusted."); } //ignore this because someone called Dispose() catch (ObjectDisposedException) { ex = new ObjectDisposedException("CallHandler", "The CallHandler has been disposed. The response cannot be trusted."); } //ignore this because someone called Dispose() catch (TaskCanceledException) { System.Diagnostics.Debugger.Break(); } return(GetResult <TResponseType>(null, ex)); }); return(result); }
} // func SendKillCommand public void StopProcess() { const string csSendKillCommand = "SendKillCommand"; try { var isCommandSended = SendKillCommand(); // Has the script a kill implementation if (!isCommandSended) { var sendKillCommand = this[csSendKillCommand]; if (sendKillCommand != null) { isCommandSended = (bool)Lua.RtConvertValue(CallMemberDirect(csSendKillCommand, LuaResult.Empty.Values, throwExceptions: false), typeof(bool)); } } //// Ctrl+C - muss via CreateRemoteThread ausgeführt werden! //if (!lCommandSended) //{ // NativeMethods.GenerateConsoleCtrlEvent(0, process.Id); // lCommandSended = true; //} // Wait for exist, and kill. var waitForExitTimeout = isCommandSended ? ConfigNode.GetAttribute <int>("exitTimeout") : 100; if (!process.WaitForExit(waitForExitTimeout)) { Log.LogMsg(LogMsgType.Warning, "Prozess wird abgeschossen."); process.Kill(); } waitForExitEvent?.Wait(waitForExitTimeout * 2); } catch (Exception e) { Log.Except(e); } } // proc StopProcess
private WebResponse CreateResponse() { if (_writePending || _writing) { lock (this) { if (_writePending || _writing) { _blockReaderUntilRequestStreamDisposed = new ManualResetEventSlim(); } } } _blockReaderUntilRequestStreamDisposed?.Wait(); try { return(_response ?? (_response = new FileWebResponse(this, _uri, _fileAccess, !_syncHint))); } catch (Exception e) { throw new WebException(e.Message, e); } }
public static void CancelAfterWait() { CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); CancellationToken cancellationToken = cancellationTokenSource.Token; ManualResetEventSlim mres = new ManualResetEventSlim(); Task.Run( () => { for (int i = 0; i < 400; i++) ; cancellationTokenSource.Cancel(); } ); //Now wait.. the wait should abort and an exception should be thrown EnsureOperationCanceledExceptionThrown( () => mres.Wait(cancellationToken), cancellationToken, "CancelBeforeWait: An OCE(null) should have been thrown that references the cancellationToken."); // the token should not have any listeners. // currently we don't expose this.. but it was verified manually }
public void WaitForInitialization() => r_InitializationLock?.Wait();
/// <inheritdoc /> public void Wait() { _event?.Wait(); }
public void Snooze(int milliseconds) { s_Shutdown.Wait(milliseconds); }
private static bool TestSync() { const int RUN_TIME = 15000; const int SETUP_TIME = 20; const int CONSUM = 100; const int PRODUC = 100; const int QUEUE = 5; Thread[] consumthrs = new Thread[CONSUM]; Thread[] producthrs = new Thread[PRODUC]; int[] results = new int[PRODUC+1]; int[] consumCounters = new int[CONSUM]; int[] producCounters = new int[PRODUC]; int[] interruptCounters = new int[CONSUM + PRODUC]; int sentInterrupts = 0; ManualResetEventSlim startEvent = new ManualResetEventSlim(false); SynchronousQueue<int> sync = new SynchronousQueue<int>(); for (int i = 0; i < PRODUC; i++) { int tid = i; producthrs[i] = new Thread(() => { // Wait the start for all threads startEvent.Wait(); int endTime = Environment.TickCount + RUN_TIME; //do //{ //do //{ try { sync.Put(tid+1 , tid+1); //break; } catch (ThreadInterruptedException) { interruptCounters[tid]++; } //} while (true); //Thread.Yield(); ++producCounters[tid]; //if ((++producCounters[tid] % 1000) == 0) //{ Console.Write("[#p{0}]", tid); //} //} while (Environment.TickCount < endTime); try { Thread.Sleep(0); } catch (ThreadInterruptedException) { interruptCounters[tid]++; } }); producthrs[i].Start(); } for (int i = 0; i < CONSUM; i++) { int tid = i; consumthrs[i] = new Thread(() => { // Wait the start for all threads startEvent.Wait(); int endTime = Environment.TickCount + RUN_TIME; //do //{ //do //{ try { int result = sync.Take(tid + 1); //if (result != 0) //{ results[result] += 1; //} //break; } catch (ThreadInterruptedException) { interruptCounters[tid + CONSUM]++; } //} while (true); //Thread.Yield(); ++consumCounters[tid]; //if ((++consumCounters[tid] % 1000) == 0) //{ Console.Write("[#c{0}]", tid); //} //} while (Environment.TickCount < endTime); try { Thread.Sleep(0); } catch (ThreadInterruptedException) { interruptCounters[tid + CONSUM]++; } }); consumthrs[i].Start(); } Thread.Sleep(SETUP_TIME); startEvent.Set(); // Wait until all threads have been terminated. for (int i = 0; i < CONSUM + PRODUC; i++) { if (i < CONSUM) consumthrs[i].Join(); else producthrs[i - CONSUM].Join(); } // Show results Console.WriteLine("\nConsumers counters:"); for (int i = 0; i < CONSUM; i++) { if ((i % 5) == 0) Console.WriteLine(); Console.Write("[#c{0}: {1,4}]", i, consumCounters[i]); } Console.WriteLine("\nProducers counters:"); for (int i = 0; i < PRODUC; i++) { if ((i % 5) == 0) Console.WriteLine(); Console.Write("[#p{0}: {1,4}", i, producCounters[i]); } Console.WriteLine("\ninterrupt counters:"); int sum = 0; for (int i = 0; i < CONSUM + PRODUC; i++) { sum += interruptCounters[i]; if ((i % 5) == 0) Console.WriteLine(); Console.Write("[#{0}: {1,4}]", i, interruptCounters[i]); } Console.WriteLine("\nsent interrupts: {0}, received: {1}", sentInterrupts, sum); for (int i = 1; i < results.Count(); i++) { if (results[i] == 0) return false; Console.WriteLine(i); } return true; }
protected override Task <decimal> InvokeTestMethodAsync(ExceptionAggregator aggregator) { SharedData.ExecutingTest(TestMethod); DispatcherSynchronizationContext synchronizationContext = null; Dispatcher dispatcher = null; Thread staThread; using (var staThreadStartedEvent = new ManualResetEventSlim(initialState: false)) { staThread = new Thread((ThreadStart)(() => { // All WPF Tests need a DispatcherSynchronizationContext and we dont want to block pending keyboard // or mouse input from the user. So use background priority which is a single level below user input. synchronizationContext = new DispatcherSynchronizationContext(); dispatcher = Dispatcher.CurrentDispatcher; // xUnit creates its own synchronization context and wraps any existing context so that messages are // still pumped as necessary. So we are safe setting it here, where we are not safe setting it in test. SynchronizationContext.SetSynchronizationContext(synchronizationContext); staThreadStartedEvent.Set(); Dispatcher.Run(); })); staThread.Name = $"{nameof(WpfTestRunner)} {TestMethod.Name}"; staThread.SetApartmentState(ApartmentState.STA); staThread.Start(); staThreadStartedEvent.Wait(); Debug.Assert(synchronizationContext != null); } var taskScheduler = new SynchronizationContextTaskScheduler(synchronizationContext); var task = Task.Factory.StartNew(async() => { Debug.Assert(SynchronizationContext.Current is DispatcherSynchronizationContext); using (await SharedData.TestSerializationGate.DisposableWaitAsync(CancellationToken.None)) { // Sync up FTAO to the context that we are creating here. ForegroundThreadAffinitizedObject.CurrentForegroundThreadData = new ForegroundThreadData( Thread.CurrentThread, new SynchronizationContextTaskScheduler(new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher, DispatcherPriority.Background)), ForegroundThreadDataKind.StaUnitTest); // Reset our flag ensuring that part of this test actually needs WpfFact s_wpfFactRequirementReason = null; // Just call back into the normal xUnit dispatch process now that we are on an STA Thread with no synchronization context. var invoker = new XunitTestInvoker(Test, MessageBus, TestClass, ConstructorArguments, TestMethod, TestMethodArguments, BeforeAfterAttributes, aggregator, CancellationTokenSource); return(await invoker.RunAsync()); } }, CancellationTokenSource.Token, TaskCreationOptions.None, taskScheduler).Unwrap(); return(Task.Run( async() => { try { return await task.ConfigureAwait(false); } finally { // Make sure to shut down the dispatcher. Certain framework types listed for the dispatcher // shutdown to perform cleanup actions. In the absence of an explicit shutdown, these actions // are delayed and run during AppDomain or process shutdown, where they can lead to crashes of // the test process. dispatcher.InvokeShutdown(); // Join the STA thread, which ensures shutdown is complete. staThread.Join(HangMitigatingTimeout); } })); }
public PythonEditor( string content = null, PythonLanguageVersion version = PythonLanguageVersion.V27, MockVs vs = null, IPythonInterpreterFactory factory = null, VsProjectAnalyzer analyzer = null, string filename = null, bool?inProcAnalyzer = null ) { if (vs == null) { _disposeVS = true; vs = new MockVs(); } MockVsTextView view = null; try { AdvancedEditorOptions advancedOptions = null; vs.InvokeSync(() => { advancedOptions = vs.GetPyService().AdvancedOptions; advancedOptions.AutoListMembers = true; advancedOptions.AutoListIdentifiers = false; }); AdvancedOptions = advancedOptions; if (factory == null) { vs.InvokeSync(() => { factory = vs.ComponentModel.GetService <IInterpreterRegistryService>() .Interpreters .FirstOrDefault(c => c.GetLanguageVersion() == version && c.Configuration.Id.StartsWith("Global|PythonCore")); if (factory != null) { Console.WriteLine($"Using interpreter {factory.Configuration.InterpreterPath}"); } }); if (factory == null) { _disposeFactory = true; factory = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion()); Console.WriteLine("Using analysis-only interpreter"); } } if (analyzer == null) { _disposeAnalyzer = true; analyzer = vs.InvokeTask(() => VsProjectAnalyzer.CreateForTestsAsync(vs.ComponentModel.GetService <PythonEditorServices>(), factory, inProcAnalyzer ?? Debugger.IsAttached), 10000); } if (string.IsNullOrEmpty(filename)) { do { filename = PathUtils.GetAbsoluteFilePath(TestData.GetTempPath(), Path.GetRandomFileName()) + ".py"; } while (File.Exists(filename)); } var cancel = CancellationTokens.After60s; using (var mre = new ManualResetEventSlim()) { view = vs.CreateTextView(PythonCoreConstants.ContentType, content ?? "", v => { v.TextView.TextBuffer.Properties[BufferParser.ParseImmediately] = true; v.TextView.TextBuffer.Properties[IntellisenseController.SuppressErrorLists] = IntellisenseController.SuppressErrorLists; v.TextView.TextBuffer.Properties[VsProjectAnalyzer._testAnalyzer] = analyzer; v.TextView.TextBuffer.Properties[VsProjectAnalyzer._testFilename] = filename; }, filename); var entry = analyzer.GetAnalysisEntryFromPath(filename); while (entry == null && !cancel.IsCancellationRequested) { Thread.Sleep(50); entry = analyzer.GetAnalysisEntryFromPath(filename); } if (!string.IsNullOrEmpty(content) && !cancel.IsCancellationRequested && !entry.IsAnalyzed) { EventHandler evt = (s, e) => mre.SetIfNotDisposed(); try { entry.AnalysisComplete += evt; while (!mre.Wait(50, cancel) && !vs.HasPendingException && !entry.IsAnalyzed) { if (!analyzer.IsAnalyzing && !entry.IsAnalyzed) { var bp = entry.TryGetBufferParser(); Assert.IsNotNull(bp, "No buffer parser was ever created"); var bi = PythonTextBufferInfo.TryGetForBuffer(view.TextView.TextBuffer); Assert.IsNotNull(bi, "No BufferInfo was ever created"); bi.LastSentSnapshot = null; bp.EnsureCodeSyncedAsync(view.TextView.TextBuffer).WaitAndUnwrapExceptions(); } } } catch (OperationCanceledException) { } finally { entry.AnalysisComplete -= evt; } } if (cancel.IsCancellationRequested) { Assert.Fail("Timed out waiting for code analysis"); } vs.ThrowPendingException(); } View = view; view = null; Analyzer = analyzer; analyzer = null; Factory = factory; factory = null; VS = vs; vs = null; } finally { if (view != null) { view.Dispose(); } if (analyzer != null && _disposeAnalyzer) { analyzer.Dispose(); } if (factory != null && _disposeFactory) { var disp = factory as IDisposable; if (disp != null) { disp.Dispose(); } } if (vs != null && _disposeVS) { vs.Dispose(); } } }
public IEnumerator InterleavedMediaAndData() { // Create the peer connections var pc1_go = new GameObject("pc1"); pc1_go.SetActive(false); // prevent auto-activation of components var pc1 = pc1_go.AddComponent <PeerConnection>(); pc1.AutoInitializeOnStart = false; var pc2_go = new GameObject("pc2"); pc2_go.SetActive(false); // prevent auto-activation of components var pc2 = pc2_go.AddComponent <PeerConnection>(); pc2.AutoInitializeOnStart = false; // Batch changes manually pc1.AutoCreateOfferOnRenegotiationNeeded = false; pc2.AutoCreateOfferOnRenegotiationNeeded = false; // Create the signaler var sig_go = new GameObject("signaler"); var sig = sig_go.AddComponent <LocalOnlySignaler>(); sig.Peer1 = pc1; sig.Peer2 = pc2; // Create the sender video source var source1 = pc1_go.AddComponent <UniformColorVideoSource>(); //sender1.SenderTrackName = "track_name"; MediaLine ml1 = pc1.AddMediaLine(MediaKind.Video); Assert.IsNotNull(ml1); ml1.Source = source1; // Create the receiver video source var receiver2 = pc2_go.AddComponent <VideoReceiver>(); MediaLine ml2 = pc2.AddMediaLine(MediaKind.Video); Assert.IsNotNull(ml2); ml2.Receiver = receiver2; // Activate pc1_go.SetActive(true); pc2_go.SetActive(true); // Initialize var initializedEvent1 = new ManualResetEventSlim(initialState: false); pc1.OnInitialized.AddListener(() => initializedEvent1.Set()); Assert.IsNull(pc1.Peer); bool finishedInitializeBeforeTimeout1 = pc1.InitializeAsync().Wait(millisecondsTimeout: 50000); Assert.IsTrue(finishedInitializeBeforeTimeout1); var initializedEvent2 = new ManualResetEventSlim(initialState: false); pc2.OnInitialized.AddListener(() => initializedEvent2.Set()); Assert.IsNull(pc2.Peer); bool finishedInitializeBeforeTimeout2 = pc2.InitializeAsync().Wait(millisecondsTimeout: 50000); Assert.IsTrue(finishedInitializeBeforeTimeout2); // Wait a frame so that the Unity event OnInitialized can propagate yield return(null); // Check the event was raised and the C# peer objects created Assert.IsTrue(initializedEvent1.Wait(millisecondsTimeout: 50000)); Assert.IsNotNull(pc1.Peer); Assert.IsTrue(initializedEvent2.Wait(millisecondsTimeout: 50000)); Assert.IsNotNull(pc2.Peer); // Confirm the source is ready, and there is a sender track. Assert.IsTrue(source1.IsLive); Assert.IsNotNull(ml1.SenderTrack); // Create some dummy out-of-band data channel to force SCTP negotiation // during the first offer, and be able to add some in-band data channels // later via subsequent SDP session negotiations. { Task <DataChannel> t1 = pc1.Peer.AddDataChannelAsync(42, "dummy", ordered: true, reliable: true); Task <DataChannel> t2 = pc2.Peer.AddDataChannelAsync(42, "dummy", ordered: true, reliable: true); Assert.IsTrue(t1.Wait(millisecondsTimeout: 10000)); Assert.IsTrue(t2.Wait(millisecondsTimeout: 10000)); } // Connect Assert.IsTrue(sig.StartConnection()); yield return(sig.WaitForConnection(millisecondsTimeout: 60000)); Assert.IsTrue(sig.IsConnected); // Wait a frame so that the Unity events for streams started can propagate yield return(null); // Check transceiver update var video_tr1 = ml1.Transceiver; Assert.IsNotNull(video_tr1); var video_tr2 = ml2.Transceiver; Assert.IsNotNull(video_tr2); Assert.AreEqual(0, video_tr1.MlineIndex); Assert.AreEqual(0, video_tr2.MlineIndex); // ====== Add in-band data channel ==================================== // Add an in-band data channel on peer #1 DataChannel dc1; { Task <DataChannel> t1 = pc1.Peer.AddDataChannelAsync("test_data_channel", ordered: true, reliable: true); Assert.IsTrue(t1.Wait(millisecondsTimeout: 10000)); dc1 = t1.Result; } // Prepare to receive a new data channel on peer #2 DataChannel dc2 = null; var dc2_added_ev = new ManualResetEventSlim(initialState: false); pc2.Peer.DataChannelAdded += (DataChannel channel) => { dc2 = channel; dc2_added_ev.Set(); }; // Renegotiate; data channel will consume media line #1 Assert.IsTrue(sig.StartConnection()); yield return(sig.WaitForConnection(millisecondsTimeout: 60000)); Assert.IsTrue(sig.IsConnected); // Do not assume that connecting is enough to get the data channel, as callbacks are // asynchronously invoked. Instead explicitly wait for the created event to be raised. Assert.IsTrue(dc2_added_ev.Wait(millisecondsTimeout: 10000)); // Check the data channel is ready Assert.IsNotNull(dc2); Assert.AreEqual(dc1.ID, dc2.ID); Assert.AreEqual(DataChannel.ChannelState.Open, dc1.State); Assert.AreEqual(DataChannel.ChannelState.Open, dc2.State); // ====== Add an extra media transceiver ============================== // Create the receiver video source var receiver1b = pc1_go.AddComponent <VideoReceiver>(); MediaLine ml1b = pc1.AddMediaLine(MediaKind.Video); Assert.IsNotNull(ml1b); ml1b.Receiver = receiver1b; // Create the sender video source var source2b = pc2_go.AddComponent <UniformColorVideoSource>(); //sender2b.SenderTrackName = "track_name_2"; MediaLine ml2b = pc2.AddMediaLine(MediaKind.Video); Assert.IsNotNull(ml2b); ml2b.Source = source2b; // Renegotiate Assert.IsTrue(sig.StartConnection()); yield return(sig.WaitForConnection(millisecondsTimeout: 60000)); Assert.IsTrue(sig.IsConnected); // Wait a frame so that the Unity events for streams started can propagate yield return(null); // Check transceiver update var video_tr1b = ml1b.Transceiver; Assert.IsNotNull(video_tr1b); var video_tr2b = ml2b.Transceiver; Assert.IsNotNull(video_tr2b); Assert.AreEqual(2, video_tr1b.MlineIndex); Assert.AreEqual(2, video_tr2b.MlineIndex); }
void RACWorker_DoWork(object sender, DoWorkEventArgs e) { ulong deltaTimeInQueue; string threadName = "RossiAlphaAnalyzer_" + rossiAlphaGateWidth; Thread.CurrentThread.Name = threadName; #if USE_SPINTIME spinTimeReady = false; #endif while (keepRunning == true) { isReadyToAnalyze = true; #if USE_SPINTIME if (spinTimeReady) { StartSpinCount(); } #endif waitingForMessage.Wait(); //wait for some other thread to place neutron data in this object and signal this worker to analyze #if USE_SPINTIME if (spinTimeReady) { EndSpinCount(); } else { spinTimeReady = true; } #endif if (keepRunning == true) { int i, j; ulong eventTime; uint eventNeutrons; uint eventNumNeutrons; RossiAlphaCircularNeutronEvent anEvent; RossiAlphaCircularNeutronEvent nextEvent; for (j = 0; j < numEventsThisBlock; j++) { eventTime = inputEventTime[j]; eventNeutrons = inputEventNeutrons[j]; eventNumNeutrons = inputEventNumNeutrons[j]; //fill in these new data at the tail of the circular linked list, //remembering that endOfNeutronEventList points to the next EMPTY struct in the list //INCLUDING at the beginning when the head and tail point to the same struct endOfList.FillEventWithData(eventTime, eventNeutrons, eventNumNeutrons); //check to see if the circular list will overflow if (endOfList.next.serialNumber == startOfList.serialNumber) { //if stack would overflow, add RawAnalysisProperties.circularListBlockIncrement neutron events at this spot in the stack... anEvent = endOfList; nextEvent = endOfList.next; for (i = 0; i < RawAnalysisProperties.circularListBlockIncrement; i++) { anEvent.next = new RossiAlphaCircularNeutronEvent(i + numObjectsInCircularLinkedList); anEvent = anEvent.next; } anEvent.next = nextEvent; //patch the circular linked list back together numObjectsInCircularLinkedList += RawAnalysisProperties.circularListBlockIncrement; //increase the record of the number of structs in the circular list } //move endOfNeutronEventList to the next empty struct endOfList = endOfList.next; //for fun, count how many times we have lapped the circular list in this experiment if (endOfList.serialNumber == 0) { numCircuits++; } //see if oldest event in the queue is expiring, //and while there are expiring events calculate the RossiAlpha statistics for those events deltaTimeInQueue = eventTime - startOfList.eventTime; while (deltaTimeInQueue > rossiAlphaWindowWidth) { //record the time of the expiring gate from the startOfList event, the total measured time for this experiment totalRossiAlphaAnalysisTime = startOfList.eventTime + rossiAlphaWindowWidth; //do RossiAlpha analysis here, accumulating statistics //add up how many neutrons there were in each RossiAlpha gate from the time of the expiring event int whichBin; ulong deltaTime; //skip the event at the head of the list. //To match data from the legacy code, start with the neutron event following this expiring head event. anEvent = startOfList.next; while (anEvent.serialNumber != endOfList.serialNumber) //...that is, until we reach the end of the list... { //Find the lowest bin with end time greater than the time of anEvent. deltaTime = anEvent.eventTime - startOfList.eventTime; whichBin = (int)(Math.Ceiling((double)deltaTime / (double)rossiAlphaGateWidth) + 0.1); if (whichBin < RawAnalysisProperties.numRAGatesPerWindow) //then this event falls into a bin; add this event's neutrons to that bin { neutronsPerRossiAlphaGate[whichBin] += anEvent.numNeutrons; //go to the next event anEvent = anEvent.next; } else { anEvent = endOfList; //abort the loop by going to the end of the list } } //remove expiring oldest event from the stack startOfList = startOfList.next; //re-calculate the delta time in the stack deltaTimeInQueue = eventTime - startOfList.eventTime; } //END of handling an individual NeutronEvent } //END of handling this block of events //prepare this thread's wait condition so will wait for a message //before telling master thread this thread's analysis is complete waitingForMessage.Reset(); } //END of if(keepRunning) else { //The master thread has cleared the keepRunning flag, so this worker is exiting //Do any cleanup etc. here. } } //END of while(keepRunning) }
public static void OnCompleted_CompletesInAnotherTaskScheduler(bool generic, bool? continueOnCapturedContext) { SynchronizationContext origCtx = SynchronizationContext.Current; try { SynchronizationContext.SetSynchronizationContext(null); // get off xunit's SynchronizationContext to avoid interactions with await var quwi = new QUWITaskScheduler(); RunWithSchedulerAsCurrent(quwi, delegate { Assert.True(TaskScheduler.Current == quwi, "Expected to be on target scheduler"); // Create the not completed task and get its awaiter var mres = new ManualResetEventSlim(); var tcs = new TaskCompletionSource<object>(); // Hook up the callback bool ranOnScheduler = false; Action callback = () => { ranOnScheduler = (TaskScheduler.Current == quwi); mres.Set(); }; if (generic) { if (continueOnCapturedContext.HasValue) tcs.Task.ConfigureAwait(continueOnCapturedContext.Value).GetAwaiter().OnCompleted(callback); else tcs.Task.GetAwaiter().OnCompleted(callback); } else { if (continueOnCapturedContext.HasValue) ((Task)tcs.Task).ConfigureAwait(continueOnCapturedContext.Value).GetAwaiter().OnCompleted(callback); else ((Task)tcs.Task).GetAwaiter().OnCompleted(callback); } Assert.False(mres.IsSet, "Callback should not yet have run."); // Complete the task in another scheduler and wait for the callback to run Task.Run(delegate { tcs.SetResult(null); }); mres.Wait(); // Validate the callback ran on the right scheduler bool shouldHaveRunOnScheduler = !continueOnCapturedContext.HasValue || continueOnCapturedContext.Value; Assert.Equal(shouldHaveRunOnScheduler, ranOnScheduler); }); } finally { SynchronizationContext.SetSynchronizationContext(origCtx); } }
void ParticipateUntil (ManualResetEventSlim evt, int millisecondsTimeout) { evt.Wait (millisecondsTimeout); }
public void ExecuteAllMethodCallUpdateAllPackageOnAllProjects(bool includePrerelease) { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("C", "3.0"); var packageB2 = PackageUtility.CreatePackage("B", "4.0"); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageB); sourceRepository.AddPackage(packageB2); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageB); var projectManager1 = new Mock <IProjectManager>(); projectManager1.Setup(p => p.LocalRepository).Returns(localRepository); var projectManager2 = new Mock <IProjectManager>(); projectManager2.Setup(p => p.LocalRepository).Returns(localRepository); var project1 = MockProjectUtility.CreateMockProject("Project1"); var project2 = MockProjectUtility.CreateMockProject("Project2"); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object); packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2); solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 }); var mockWindowService = new Mock <IUserNotifierServices>(); mockWindowService.Setup(p => p.ShowProjectSelectorWindow( It.IsAny <string>(), It.IsAny <IPackage>(), It.IsAny <Predicate <Project> >(), It.IsAny <Predicate <Project> >())).Returns(new Project[] { project1, project2 }); var provider = CreateSolutionUpdatesProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object); provider.IncludePrerelease = includePrerelease; var extensionTree = provider.ExtensionsTree; var extensionB2 = new PackageItem(provider, packageB2); var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; firstTreeNode.Repository.AddPackage(packageA); firstTreeNode.Repository.AddPackage(packageB); firstTreeNode.Repository.AddPackage(packageC); firstTreeNode.Extensions.Add(extensionB2); provider.SelectedNode = firstTreeNode; IVsPackageManager activePackageManager = provider.GetActivePackageManager(); Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager); var manualEvent = new ManualResetEventSlim(false); Exception exception = null; provider.ExecuteCompletedCallback = delegate { try { // Assert Assert.Equal(RepositoryOperationNames.Update, sourceRepository.LastOperation); mockPackageManager.Verify( p => p.UpdatePackages(true, includePrerelease, provider, provider), Times.Once()); } catch (Exception ex) { exception = ex; } finally { manualEvent.Set(); } }; // Act provider.Execute(item: null); // do not allow the method to return manualEvent.Wait(); Assert.Null(exception); }
public void ExecuteMethodDoNotCallUpdatePackageIfNoProjectIsChecked() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("C", "3.0"); var packageB2 = PackageUtility.CreatePackage("B", "4.0"); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageB); sourceRepository.AddPackage(packageB2); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageB); var projectManager1 = new Mock <IProjectManager>(); projectManager1.Setup(p => p.LocalRepository).Returns(localRepository); var projectManager2 = new Mock <IProjectManager>(); projectManager2.Setup(p => p.LocalRepository).Returns(localRepository); var project1 = MockProjectUtility.CreateMockProject("Project1"); var project2 = MockProjectUtility.CreateMockProject("Project2"); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object); packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2); solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 }); var mockWindowService = new Mock <IUserNotifierServices>(); mockWindowService.Setup(p => p.ShowProjectSelectorWindow( It.IsAny <string>(), It.IsAny <IPackage>(), It.IsAny <Predicate <Project> >(), It.IsAny <Predicate <Project> >())).Returns(new Project[0]); var provider = CreateSolutionUpdatesProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object); var extensionTree = provider.ExtensionsTree; var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; firstTreeNode.Repository.AddPackage(packageA); firstTreeNode.Repository.AddPackage(packageB); firstTreeNode.Repository.AddPackage(packageC); provider.SelectedNode = firstTreeNode; IVsPackageManager activePackageManager = provider.GetActivePackageManager(); Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager); var manualEvent = new ManualResetEventSlim(false); provider.ExecuteCompletedCallback = delegate { // Assert mockPackageManager.Verify(p => p.UpdatePackage( new Project[] { project1, project2 }, packageB2, It.IsAny <IEnumerable <PackageOperation> >(), true, false, provider, provider), Times.Never()); manualEvent.Set(); }; var extensionB2 = new PackageItem(provider, packageB2); // Act provider.Execute(extensionB2); // do not allow the method to return manualEvent.Wait(); }
/// <inheritdoc /> public void Wait() => _event?.Wait();
public async Task ConfiguredAwaiter_ContinuesOnCapturedContext(bool continueOnCapturedContext) { await Task.Run(() => { var tsc = new TrackingSynchronizationContext(); SynchronizationContext.SetSynchronizationContext(tsc); try { ValueTask<int> t = 42; var mres = new ManualResetEventSlim(); t.ConfigureAwait(continueOnCapturedContext).GetAwaiter().OnCompleted(() => mres.Set()); Assert.True(mres.Wait(10000)); Assert.Equal(continueOnCapturedContext ? 1 : 0, tsc.Posts); } finally { SynchronizationContext.SetSynchronizationContext(null); } }); }
public Task TakeScreenshotAsync() => Task.Run(async() => { Interlocked.Increment(ref screenShotTasks); if (!captureMenuCursor.Value) { cursorVisibility.Value = false; // We need to wait for at most 3 draw nodes to be drawn, following which we can be assured at least one DrawNode has been generated/drawn with the set value const int frames_to_wait = 3; int framesWaited = 0; using (var framesWaitedEvent = new ManualResetEventSlim(false)) { ScheduledDelegate waitDelegate = host.DrawThread.Scheduler.AddDelayed(() => { if (framesWaited++ < frames_to_wait) { // ReSharper disable once AccessToDisposedClosure framesWaitedEvent.Set(); } }, 10, true); framesWaitedEvent.Wait(); waitDelegate.Cancel(); } } using (var image = await host.TakeScreenshotAsync()) { if (Interlocked.Decrement(ref screenShotTasks) == 0 && cursorVisibility.Value == false) { cursorVisibility.Value = true; } var fileName = getFileName(); if (fileName == null) { return; } var stream = storage.GetStream(fileName, FileAccess.Write); switch (screenshotFormat.Value) { case ScreenshotFormat.Png: image.SaveAsPng(stream); break; case ScreenshotFormat.Jpg: image.SaveAsJpeg(stream); break; default: throw new ArgumentOutOfRangeException(nameof(screenshotFormat)); } notificationOverlay.Post(new SimpleNotification { Text = $"{fileName} 已保存!", Activated = () => { storage.OpenInNativeExplorer(); return(true); } }); } });
public void ConcurrentReadersTest() { const int threadCount = 8; var threads = new Thread[threadCount]; var exceptions = new Exception[threadCount]; var locker = new object(); var acquired = 0; var m2 = new ManualResetEventSlim(false); var m1 = new ManualResetEventSlim(false); for (var i = 0; i < threadCount; i++) { var ic = i; // capture threads[i] = new Thread(() => { using (var scope = ScopeProvider.CreateScope()) { try { scope.EagerReadLock(Constants.Locks.Servers); lock (locker) { acquired++; if (acquired == threadCount) { m2.Set(); } } m1.Wait(); lock (locker) { acquired--; } } catch (Exception e) { exceptions[ic] = e; } scope.Complete(); } }); } // ensure that current scope does not leak into starting threads using (ExecutionContext.SuppressFlow()) { foreach (var thread in threads) { thread.Start(); } } m2.Wait(); // all threads have locked in parallel var maxAcquired = acquired; m1.Set(); foreach (var thread in threads) { thread.Join(); } Assert.AreEqual(threadCount, maxAcquired); Assert.AreEqual(0, acquired); for (var i = 0; i < threadCount; i++) { Assert.IsNull(exceptions[i]); } }
/// <summary> /// Update the pages in the texture loader that should be loaded. Note that if you are retiring indirection textures /// you can pass an enumerator to their ids so their removal will not be pooled. /// </summary> /// <param name="loopResumingCallback">An action that is fired just before the loop restarts to load images.</param> /// <param name="retiringIndirectionTextureIds">An enumerator over indirection texture ids that should not have removal pooled since they are being retired. Null means ignore this (default).</param> public void updatePagesFromRequests(Action loopResumingCallback = null, IEnumerable <byte> retiringIndirectionTextureIds = null) { //If there are no added pages or changes to indirection textures, there is nothing to do with this call, just return if (addedPages.Count == 0 && removedPages.Count == 0 && loopResumingCallback == null && retiringIndirectionTextureIds == null) { return; } //Finish any current image loading and wait until that is complete if (loadingTask != null) { stopLoading = true; loadingTask.Wait(); } //Careful with order, we want to make sure the loadingtask is done before getting a lock again since that function locks for its duration. lock (syncObject) { //We have a lock now, are we still ok to load? if (cancelBackgroundLoad) { throw new CancelThreadException(); } } //If we have pages to retire, for extra safety wait until all outstanding staging buffers are finished uploading if (retiringIndirectionTextureIds != null) { foreach (var stagingBuffer in stagingBufferSets) { stagingBuffer.waitForGpuUpload(); } } //Reset stopLoading = false; //Remove pages foreach (var page in removedPages) { PTexPage pTexPage; if (usedPhysicalPages.TryGetValue(page, out pTexPage)) { //See if this page is part of a retired texture, if not pool the page if (retiringIndirectionTextureIds == null || !retiringIndirectionTextureIds.Contains(pTexPage.VirtualTexturePage.indirectionTexId)) { physicalPagePool.Add(page, pTexPage); } else { pTexPage.VirtualTexturePage = null; } physicalPageQueue.Add(pTexPage); usedPhysicalPages.Remove(page); } else { pagesToLoad.Remove(page); } } //Clear out any other physical page pool entries if (retiringIndirectionTextureIds != null) { List <PTexPage> currentPagePool = physicalPagePool.Values.ToList(); foreach (var pooledPage in currentPagePool) { if (retiringIndirectionTextureIds.Contains(pooledPage.VirtualTexturePage.indirectionTexId)) { physicalPagePool.Remove(pooledPage.VirtualTexturePage); pooledPage.VirtualTexturePage = null; } } } //Process pages into loaded and not loaded foreach (var addedPage in addedPages) { PTexPage pTexPage; //Does the virtual texture already contain the page? if (physicalPagePool.TryGetValue(addedPage, out pTexPage)) { //Already contained, just update the queue and pool, this requires no texture updates physicalPageQueue.Remove(pTexPage); physicalPagePool.Remove(addedPage); usedPhysicalPages.Add(addedPage, pTexPage); } else if (!usedPhysicalPages.ContainsKey(addedPage) && !pagesToLoad.Contains(addedPage)) //Add all new pages that are not already used, could potentailly be slow, can second check be replaced by a hash map { pagesToLoad.Add(addedPage); } } if (loopResumingCallback != null) { loopResumingCallback.Invoke(); } Overprevisioned = pagesToLoad.Count > physicalPageQueue.Count; //Start loading task again pagesToLoad.Sort((v1, v2) => ((v1.mip << 24) + indirectionTextureRequestCount[v1.indirectionTexId]) - ((v2.mip << 24) + indirectionTextureRequestCount[v2.indirectionTexId])); loadingTask = Task.Run(() => { lock (syncObject) { PerformanceMonitor.start("updatePagesFromRequests processing pages"); for (int i = pagesToLoad.Count - 1; i > -1; --i) //Process backwards, try to avoid as many collection element shifts as possible, this is sorted so the desired read order is reversed in actual memory { if (cancelBackgroundLoad) //Reaquired lock, are we still active { throw new CancelThreadException(); } if (stopLoading) { break; } System.Threading.Monitor.Exit(syncObject); stagingBufferWaitEvent.Wait(); //Make sure we actually can dequeue a staging buffer StagingBufferSet stagingBuffers; lock (stagingBufferSets) { stagingBuffers = this.stagingBufferSets[0]; stagingBuffers.reset(); stagingBufferSets.RemoveAt(0); if (stagingBufferSets.Count == 0) { //We have no more staging buffers, force next iteration to wait until the last one has been returned. stagingBufferWaitEvent.Reset(); } } System.Threading.Monitor.Enter(syncObject); if (loadPage(pagesToLoad[i], stagingBuffers)) { virtualTextureManager.syncToGpu(stagingBuffers); } else { returnStagingBuffer(stagingBuffers); } pagesToLoad.RemoveAt(i); } PerformanceMonitor.stop("updatePagesFromRequests processing pages"); } }); //Reset added and removed pages addedPages.Clear(); removedPages.Clear(); }
public static void RunManualResetEventSlimTest5_Dispose_Negative() { ManualResetEventSlim mres = new ManualResetEventSlim(false); mres.Dispose(); Assert.Throws<ObjectDisposedException>(() => mres.Reset()); // Failure Case: The object has been disposed, should throw ObjectDisposedException. Assert.Throws<ObjectDisposedException>(() => mres.Wait(0)); // Failure Case: The object has been disposed, should throw ObjectDisposedException. Assert.Throws<ObjectDisposedException>( () => { WaitHandle handle = mres.WaitHandle; }); // Failure Case: The object has been disposed, should throw ObjectDisposedException. mres = new ManualResetEventSlim(false); ManualResetEvent mre = (ManualResetEvent)mres.WaitHandle; mres.Dispose(); Assert.Throws<ObjectDisposedException>(() => mre.WaitOne(0)); // Failure Case: The underlying event object has been disposed, should throw ObjectDisposedException. }
public async Task TestOrdering_Sync_OrderedDisabled() { // If ordering were enabled, this test would hang. var options = new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = 2, EnsureOrdered = false }; var mres = new ManualResetEventSlim(); var tb = new TransformBlock<int, int>(i => { if (i == 0) mres.Wait(); return i; }, options); tb.Post(0); tb.Post(1); Assert.Equal(1, await tb.ReceiveAsync()); mres.Set(); Assert.Equal(0, await tb.ReceiveAsync()); tb.Complete(); await tb.Completion; }
public static void RunManualResetEventSlimTest6_Exceptions() { ManualResetEventSlim mres = null; Assert.Throws<ArgumentOutOfRangeException>(() => mres = new ManualResetEventSlim(false, -1)); // Failure Case: Constructor didn't throw AORE when -1 passed mres = new ManualResetEventSlim(false); Assert.Throws<ArgumentOutOfRangeException>(() => mres.Wait(-2)); // Failure Case: Wait(int) didn't throw AORE when the totalmilliseconds < -1 Assert.Throws<ArgumentOutOfRangeException>(() => mres.Wait(TimeSpan.FromDays(-1))); // Failure Case: Wait(TimeSpan) didn't throw AORE when the totalmilliseconds < -1 Assert.Throws<ArgumentOutOfRangeException>(() => mres.Wait(TimeSpan.MaxValue)); // Failure Case: Wait(TimeSpan, CancellationToken) didn't throw AORE when the totalmilliseconds > int.max Assert.Throws<ArgumentOutOfRangeException>(() => mres.Wait(TimeSpan.FromDays(-1), new CancellationToken())); // Failure Case: Wait(TimeSpan) didn't throw AORE when the totalmilliseconds < -1 Assert.Throws<ArgumentOutOfRangeException>(() => mres.Wait(TimeSpan.MaxValue, new CancellationToken())); // Failure Case: Wait(TimeSpan, CancellationToken) didn't throw AORE when the totalmilliseconds > int.max }
/// <summary> /// Waits for the event to be completed /// </summary> public void Wait() => Event?.Wait();
public void Throws_When_Lock_Timeout_Is_Exceeded_Write() { var counter = 0; var gate = new ManualResetEventSlim(false); var logger = GetRequiredService<ILogger<LocksTests>>(); using (ExecutionContext.SuppressFlow()) { var t1 = Task.Run(() => { using var scope = ScopeProvider.CreateScope(); _ = scope.Database; // Begin transaction Interlocked.Increment(ref counter); gate.Wait(); logger.LogInformation("t1 - Attempting to acquire write lock"); Assert.DoesNotThrow(() => { // ReSharper disable once AccessToDisposedClosure // This will acquire right away scope.EagerWriteLock(TimeSpan.FromMilliseconds(1000), Constants.Locks.ContentTree); }); logger.LogInformation("t1 - Acquired write lock, sleeping"); Thread.Sleep(1500); // Wait longer than the Read Lock B timeout scope.Complete(); logger.LogInformation("t1 - Complete transaction"); }); var t2 = Task.Run(() => { using var scope = ScopeProvider.CreateScope(); _ = scope.Database; // Begin transaction Interlocked.Increment(ref counter); gate.Wait(); Thread.Sleep(100); // Let other transaction obtain write lock first. logger.LogInformation("t2 - Attempting to acquire write lock"); var ex = Assert.Throws<DistributedWriteLockTimeoutException>(() => { // ReSharper disable once AccessToDisposedClosure scope.EagerWriteLock(TimeSpan.FromMilliseconds(1000), Constants.Locks.ContentTree); logger.LogInformation("t2 - Acquired write lock, something has gone wrong."); }); if (ex != null) { logger.LogInformation("t2 - Failed to acquire write lock in time, all is well."); } scope.Complete(); }); while (counter < 2) { Thread.Sleep(10); } gate.Set(); Task.WaitAll(t1, t2); } }
private void DrainQueue(CancellationToken token, ICancelable cancel) { while (true) { try { _evt.Wait(token); } catch (OperationCanceledException) { return; } var hasFailed = false; var error = default(Exception); var hasValue = false; var value = default(TSource); var hasCompleted = false; var shouldWait = false; var waitTime = default(TimeSpan); lock (_gate) { if (_hasFailed) { error = _exception; hasFailed = true; } else { var now = Elapsed; if (_queue.Count > 0) { var next = _queue.Dequeue(); hasValue = true; value = next.Value; var nextDue = next.Interval; if (nextDue.CompareTo(now) > 0) { shouldWait = true; waitTime = Scheduler.Normalize(nextDue.Subtract(now)); } } else if (_hasCompleted) { hasCompleted = true; if (_completeAt.CompareTo(now) > 0) { shouldWait = true; waitTime = Scheduler.Normalize(_completeAt.Subtract(now)); } } } } /* lock (_gate) */ if (shouldWait) { var timer = new ManualResetEventSlim(); _scheduler.ScheduleAction(timer, waitTime, static slimTimer => { slimTimer.Set(); }); try { timer.Wait(token); } catch (OperationCanceledException) { return; } } if (hasValue) { ForwardOnNext(value !); } else { if (hasCompleted) { ForwardOnCompleted(); } else if (hasFailed) { ForwardOnError(error !); } return; } } }
public void ConcurrentWritersTest() { const int threadCount = 8; var threads = new Thread[threadCount]; var exceptions = new Exception[threadCount]; var locker = new object(); var acquired = 0; var entered = 0; var ms = new AutoResetEvent[threadCount]; for (var i = 0; i < threadCount; i++) { ms[i] = new AutoResetEvent(false); } var m1 = new ManualResetEventSlim(false); for (var i = 0; i < threadCount; i++) { var ic = i; // capture threads[i] = new Thread(() => { using (var scope = ScopeProvider.CreateScope()) { try { lock (locker) { entered++; if (entered == threadCount) { m1.Set(); } } ms[ic].WaitOne(); scope.EagerWriteLock(Constants.Locks.Servers); lock (locker) { acquired++; } ms[ic].WaitOne(); lock (locker) { acquired--; } } catch (Exception e) { exceptions[ic] = e; } scope.Complete(); } }); } // ensure that current scope does not leak into starting threads using (ExecutionContext.SuppressFlow()) { foreach (var thread in threads) { thread.Start(); } } m1.Wait(); // all threads have entered ms[0].Set(); // let 0 go // TODO: This timing is flaky Thread.Sleep(100); for (var i = 1; i < threadCount; i++) { ms[i].Set(); // let others go } // TODO: This timing is flaky Thread.Sleep(500); // only 1 thread has locked Assert.AreEqual(1, acquired); for (var i = 0; i < threadCount; i++) { ms[i].Set(); // let all go } foreach (var thread in threads) { thread.Join(); } Assert.AreEqual(0, acquired); for (var i = 0; i < threadCount; i++) { Assert.IsNull(exceptions[i]); } }
public static void BaseSynchronizationContext_SameAsNoSynchronizationContext() { var quwi = new QUWITaskScheduler(); SynchronizationContext origCtx = SynchronizationContext.Current; try { SynchronizationContext.SetSynchronizationContext(new SynchronizationContext()); RunWithSchedulerAsCurrent(quwi, delegate { ManualResetEventSlim mres = new ManualResetEventSlim(); var tcs = new TaskCompletionSource<object>(); var awaiter = ((Task)tcs.Task).GetAwaiter(); bool ranOnScheduler = false; bool ranWithoutSyncCtx = false; awaiter.OnCompleted(() => { ranOnScheduler = (TaskScheduler.Current == quwi); ranWithoutSyncCtx = SynchronizationContext.Current == null; mres.Set(); }); Assert.False(mres.IsSet, "Callback should not yet have run."); Task.Run(delegate { tcs.SetResult(null); }); mres.Wait(); Assert.True(ranOnScheduler, "Should have run on scheduler"); Assert.True(ranWithoutSyncCtx, "Should have run with a null sync ctx"); }); } finally { SynchronizationContext.SetSynchronizationContext(origCtx); } }
public void ExecuteUninstallsSolutionLevelPackageWhenUpdating() { // Arrange var packageA_10 = PackageUtility.CreatePackage("A", "1.0", content: null, assemblyReferences: null, tools: new[] { "init.ps1" }, dependencies: null); var packageA_12 = PackageUtility.CreatePackage("A", "1.2", content: null, assemblyReferences: null, tools: new[] { "init.ps1" }, dependencies: null); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA_12); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA_10); var projectManager1 = new Mock <IProjectManager>(); projectManager1.Setup(p => p.LocalRepository).Returns(localRepository); var project1 = MockProjectUtility.CreateMockProject("Project1"); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.LocalRepository).Returns(localRepository); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object); packageManager.Setup(p => p.IsProjectLevel(packageA_12)).Returns(false); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1); solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1 }); var mockWindowService = new Mock <IUserNotifierServices>(); mockWindowService.Setup(p => p.ShowProjectSelectorWindow( It.IsAny <string>(), It.IsAny <IPackage>(), It.IsAny <Predicate <Project> >(), It.IsAny <Predicate <Project> >())).Returns(new Project[0]); var provider = CreateSolutionUpdatesProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object); var extensionTree = provider.ExtensionsTree; var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; firstTreeNode.Repository.AddPackage(packageA_10); provider.SelectedNode = firstTreeNode; IVsPackageManager activePackageManager = provider.GetActivePackageManager(); Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager); var manualEvent = new ManualResetEventSlim(false); Exception exception = null; provider.ExecuteCompletedCallback = delegate { try { // Assert mockPackageManager.Verify(p => p.UpdatePackage( new Project[0], packageA_12, new[] { new PackageOperation(packageA_10, PackageAction.Uninstall), new PackageOperation(packageA_12, PackageAction.Install) }, true, false, provider, provider), Times.Once()); } catch (Exception e) { exception = e; } finally { manualEvent.Set(); } }; var extensionA_12 = new PackageItem(provider, packageA_12); // Act provider.Execute(extensionA_12); // do not allow the method to return manualEvent.Wait(); Assert.Null(exception); }
public void ConfiguredAwaiter_OnCompleted(bool continueOnCapturedContext) { // Since ValueTask implements both OnCompleted and UnsafeOnCompleted, // OnCompleted typically won't be used by await, so we add an explicit test // for it here. ValueTask<int> t = 42; var mres = new ManualResetEventSlim(); t.ConfigureAwait(continueOnCapturedContext).GetAwaiter().OnCompleted(() => mres.Set()); Assert.True(mres.Wait(10000)); }
public void Awaiter_OnCompleted() { // Since ValueTask implements both OnCompleted and UnsafeOnCompleted, // OnCompleted typically won't be used by await, so we add an explicit test // for it here. ValueTask<int> t = new ValueTask<int>(42); var mres = new ManualResetEventSlim(); t.GetAwaiter().OnCompleted(() => mres.Set()); Assert.True(mres.Wait(10000)); }