public async Task AwaitRegKeyChange() { using (var test = new RegKeyTest()) { Task changeWatcherTask = test.Key.WaitForChangeAsync(); Assert.False(changeWatcherTask.IsCompleted); test.Key.SetValue("a", "b"); await changeWatcherTask; } }
public async Task AwaitRegKeyChange() { Skip.IfNot(RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); using (var test = new RegKeyTest()) { Task changeWatcherTask = test.Key.WaitForChangeAsync(); Assert.False(changeWatcherTask.IsCompleted); test.Key.SetValue("a", "b"); await changeWatcherTask; } }
public async Task AwaitRegKeyChange_KeyDisposedWhileWatching() { Task watchingTask; using (var test = new RegKeyTest()) { watchingTask = test.Key.WaitForChangeAsync(); } // We expect the task to quietly complete (without throwing any exception). await watchingTask; }
public async Task AwaitRegKeyChange_KeyDeleted() { using (var test = new RegKeyTest()) { using (var subKey = test.CreateSubKey()) { Task changeWatcherTask = subKey.WaitForChangeAsync(watchSubtree: true, cancellationToken: test.FinishedToken); test.Key.DeleteSubKey(Path.GetFileName(subKey.Name)); await changeWatcherTask; } } }
public async Task AwaitRegKeyChange_WatchSubtree() { using (var test = new RegKeyTest()) { using (var subKey = test.CreateSubKey()) { Task changeWatcherTask = test.Key.WaitForChangeAsync(watchSubtree: true, cancellationToken: test.FinishedToken); subKey.SetValue("subkeyValueName", "b"); await changeWatcherTask; } } }
public async Task AwaitRegKeyChange_TwoAtOnce_SameKeyHandle() { using (var test = new RegKeyTest()) { Task changeWatcherTask1 = test.Key.WaitForChangeAsync(); Task changeWatcherTask2 = test.Key.WaitForChangeAsync(); Assert.False(changeWatcherTask1.IsCompleted); Assert.False(changeWatcherTask2.IsCompleted); test.Key.SetValue("a", "b"); await Task.WhenAll(changeWatcherTask1, changeWatcherTask2); } }
public async Task AwaitRegKeyChange_NoChange() { using (var test = new RegKeyTest()) { Task changeWatcherTask = test.Key.WaitForChangeAsync(cancellationToken: test.FinishedToken); Assert.False(changeWatcherTask.IsCompleted); // Give a bit of time to confirm the task will not complete. Task completedTask = await Task.WhenAny(changeWatcherTask, Task.Delay(AsyncDelay)); Assert.NotSame(changeWatcherTask, completedTask); } }
public async Task AwaitRegKeyChange_KeyDisposedWhileWatching() { Skip.IfNot(RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); Task watchingTask; using (var test = new RegKeyTest()) { watchingTask = test.Key.WaitForChangeAsync(); } // We expect the task to quietly complete (without throwing any exception). await watchingTask; }
public async Task AwaitRegKeyChange_WatchSubtree() { Skip.IfNot(RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); using (var test = new RegKeyTest()) { using (var subKey = test.CreateSubKey()) { Task changeWatcherTask = test.Key.WaitForChangeAsync(watchSubtree: true, cancellationToken: test.FinishedToken); subKey.SetValue("subkeyValueName", "b"); await changeWatcherTask; } } }
public async Task AwaitRegKeyChange_TwoAtOnce_SameKeyHandle() { Skip.IfNot(RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); using (var test = new RegKeyTest()) { Task changeWatcherTask1 = test.Key.WaitForChangeAsync(); Task changeWatcherTask2 = test.Key.WaitForChangeAsync(); Assert.False(changeWatcherTask1.IsCompleted); Assert.False(changeWatcherTask2.IsCompleted); test.Key.SetValue("a", "b"); await Task.WhenAll(changeWatcherTask1, changeWatcherTask2); } }
public async Task AwaitRegKeyChange_NoWatchSubtree() { using (var test = new RegKeyTest()) { using (var subKey = test.CreateSubKey()) { Task changeWatcherTask = test.Key.WaitForChangeAsync(watchSubtree: false, cancellationToken: test.FinishedToken); subKey.SetValue("subkeyValueName", "b"); // We do not expect changes to sub-keys to complete the task, so give a bit of time to confirm // the task doesn't complete. Task completedTask = await Task.WhenAny(changeWatcherTask, Task.Delay(AsyncDelay)); Assert.NotSame(changeWatcherTask, completedTask); } } }
public async Task AwaitRegKeyChange_Canceled() { using (var test = new RegKeyTest()) { var cts = new CancellationTokenSource(); Task changeWatcherTask = test.Key.WaitForChangeAsync(cancellationToken: cts.Token); Assert.False(changeWatcherTask.IsCompleted); cts.Cancel(); try { await changeWatcherTask; Assert.True(false, "Expected exception not thrown."); } catch (OperationCanceledException ex) { Assert.Equal(cts.Token, ex.CancellationToken); } } }
public async Task AwaitRegKeyChange_CanceledAndImmediatelyDisposed() { Task watchingTask; CancellationToken expectedCancellationToken; using (var test = new RegKeyTest()) { expectedCancellationToken = test.FinishedToken; watchingTask = test.Key.WaitForChangeAsync(cancellationToken: test.FinishedToken); } try { await watchingTask; Assert.True(false, "Expected exception not thrown."); } catch (OperationCanceledException ex) { Assert.Equal(expectedCancellationToken, ex.CancellationToken); } }
public async Task AwaitRegKeyChange_CallingThreadDestroyed() { using (var test = new RegKeyTest()) { // Start watching and be certain the thread that started watching is destroyed. // This simulates a more common case of someone on a threadpool thread watching // a key asynchronously and then the .NET Threadpool deciding to reduce the number of threads in the pool. Task watchingTask = null; var thread = new Thread(() => { watchingTask = test.Key.WaitForChangeAsync(cancellationToken: test.FinishedToken); }); thread.Start(); thread.Join(); // Verify that the watching task is still watching. Task completedTask = await Task.WhenAny(watchingTask, Task.Delay(AsyncDelay)); Assert.NotSame(watchingTask, completedTask); test.CreateSubKey().Dispose(); await watchingTask; } }