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;
}
}
