public async Task AsyncReaderWriterLock_ReaderThenReader()
{
// Verify that obtaining a reader lock does not block
// another reader.
var rwLock = new AsyncReaderWriterLock();
var haveLock = false;
var inTask = false;
var readLock = await rwLock.GetReadLockAsync();
Task.Run(
async() =>
{
inTask = true;
using (await rwLock.GetReadLockAsync())
{
haveLock = true;
}
});
Helper.WaitFor(() => inTask, defaultTimeout);
await Task.Delay(taskWait);
Assert.IsTrue(haveLock);
readLock.Dispose();
Helper.WaitFor(() => haveLock, defaultTimeout);
rwLock.Dispose();
}
public async Task AsyncReaderWriterLock_Basic()
{
var rwLock = (AsyncReaderWriterLock)null;
var haveLock = false;
// Verify that we can obtain a reader lock.
rwLock = new AsyncReaderWriterLock();
haveLock = false;
using (await rwLock.GetReadLockAsync())
{
haveLock = true;
}
Assert.IsTrue(haveLock);
rwLock.Dispose();
// Verify that we can obtain a writer lock.
rwLock = new AsyncReaderWriterLock();
haveLock = false;
using (await rwLock.GetWriteLockAsync())
{
haveLock = true;
}
Assert.IsTrue(haveLock);
rwLock.Dispose();
}
public async Task AsyncReaderWriterLock_ReaderThenWriter()
{
// Verify that obtaining a reader lock blocks a writer lock and then
// that releasing the read lock, unblocks the writer.
var rwLock = new AsyncReaderWriterLock();
var haveLock = false;
var inTask = false;
var readLock = await rwLock.GetReadLockAsync();
Task.Run(
async() =>
{
inTask = true;
using (await rwLock.GetWriteLockAsync())
{
haveLock = true;
}
});
Helper.WaitFor(() => inTask, defaultTimeout);
await Task.Delay(taskWait);
Assert.IsFalse(haveLock);
readLock.Dispose();
Helper.WaitFor(() => haveLock, defaultTimeout);
rwLock.Dispose();
}
public async Task WriterThenReader_Delay()
{
// Verify that obtaining a writer lock blocks a reader lock and then
// that releasing the write lock, unblocks the reader. We'll add delay
// to mix things up.
var rwLock = new AsyncReaderWriterLock();
var haveLock = false;
var inTask = false;
var writeLock = await rwLock.GetWriteLockAsync();
var task = Task.Run(
async() =>
{
inTask = true;
using (await rwLock.GetReadLockAsync())
{
await Task.Delay(250);
haveLock = true;
}
});
NeonHelper.WaitFor(() => inTask, defaultTimeout);
await Task.Delay(taskWait);
Assert.False(haveLock);
writeLock.Dispose();
NeonHelper.WaitFor(() => haveLock, defaultTimeout);
rwLock.Dispose();
}
public async Task ReaderThenReader_Delay()
{
// Verify that obtaining a reader lock does not block
// another reader. We'll add delay to mix things up.
var rwLock = new AsyncReaderWriterLock();
var haveLock = false;
var inTask = false;
var readLock = await rwLock.GetReadLockAsync();
var task = Task.Run(
async() =>
{
inTask = true;
using (await rwLock.GetReadLockAsync())
{
await Task.Delay(250);
haveLock = true;
}
});
NeonHelper.WaitFor(() => inTask, defaultTimeout);
await Task.Delay(taskWait);
Assert.True(haveLock);
readLock.Dispose();
NeonHelper.WaitFor(() => haveLock, defaultTimeout);
rwLock.Dispose();
}
public void TestOperationAfterDisposeAsync()
{
var l = new AsyncReaderWriterLock();
l.Dispose();
Assert.ThrowsAsync <ObjectDisposedException>(() => l.ReadLockAsync());
Assert.ThrowsAsync <ObjectDisposedException>(() => l.WriteLockAsync());
}
/// <summary>
/// Releases all resources associated with this audit trail.
/// </summary>
/// <param name="disposing">Indicates whether the <see cref="Dispose(bool)"/> has been called directly or from finalizer.</param>
protected override void Dispose(bool disposing)
{
if (disposing)
{
syncRoot.Dispose();
commitEvent.Dispose();
}
base.Dispose(disposing);
}
public async Task AsyncReaderWriterLock_WriterThenMultipleWriters()
{
// Verify that obtaining a writer lock blocks multiple writers and then
// that releasing the write lock, unblocks all of the other writers.
const int writerCount = 10;
var waitCount = 0;
var acquireCount = 0;
var rwLock = new AsyncReaderWriterLock();
var writeLock = await rwLock.GetWriteLockAsync();
for (int i = 0; i < writerCount; i++)
{
Task.Run(
async() =>
{
Interlocked.Increment(ref waitCount);
//using (await rwLock.GetWriteLockAsync())
//{
// Interlocked.Increment(ref acquireCount);
//}
var testLock = await rwLock.GetWriteLockAsync();
Interlocked.Increment(ref acquireCount);
testLock.Dispose();
});
}
Helper.WaitFor(() => waitCount == writerCount, defaultTimeout);
await Task.Delay(taskWait);
Assert.AreEqual(0, acquireCount);
writeLock.Dispose();
Helper.WaitFor(() => acquireCount == writerCount, defaultTimeout);
rwLock.Dispose();
}
public async Task AsyncReaderWriterLock_WriterThenMultipleReaders_Delay()
{
// Verify that obtaining a writer lock blocks multiple readers and then
// that releasing the write lock, unblocks all of the readers. We'll
// add delay to mix things up.
const int readerCount = 10;
var waitCount = 0;
var acquireCount = 0;
var rwLock = new AsyncReaderWriterLock();
var writeLock = await rwLock.GetWriteLockAsync();
for (int i = 0; i < readerCount; i++)
{
Task.Run(
async() =>
{
Interlocked.Increment(ref waitCount);
using (await rwLock.GetReadLockAsync())
{
await Task.Delay(100);
Interlocked.Increment(ref acquireCount);
}
});
}
Helper.WaitFor(() => waitCount == readerCount, defaultTimeout);
await Task.Delay(taskWait);
Assert.AreEqual(0, acquireCount);
writeLock.Dispose();
Helper.WaitFor(() => acquireCount == readerCount, defaultTimeout);
rwLock.Dispose();
}
public async Task AsyncReaderWriterLock_Basic_Delay()
{
var rwLock = (AsyncReaderWriterLock)null;
var haveLock = false;
// Verify that we can obtain a reader lock. We'll add delay
// to mix things up.
rwLock = new AsyncReaderWriterLock();
haveLock = false;
using (await rwLock.GetReadLockAsync())
{
await Task.Delay(250);
haveLock = true;
}
Assert.IsTrue(haveLock);
rwLock.Dispose();
// Verify that we can obtain a writer lock.
rwLock = new AsyncReaderWriterLock();
haveLock = false;
using (await rwLock.GetWriteLockAsync())
{
await Task.Delay(250);
haveLock = true;
}
Assert.IsTrue(haveLock);
rwLock.Dispose();
}
public virtual void Destroy()
{
// The cache is externally provided and may be shared. Destroying the cache is
// not the responsibility of this class.
_asyncReaderWriterLock.Dispose();
}
