public void BarelyUpgrade()
        {
            // setup
            var rwLock  = new ReaderWriterLockSlim();
            var rValue  = new Read();
            var wValue  = new Write();
            var subject = new ReaderWriterSynchronized <Write, Read>(rwLock, wValue, rValue);

            subject.UpgradeableReader.BarelyLock();

            // act and assert
            var result = subject.BarelyLock();

            result.ShouldBe(wValue);
        }
        public void LockTryUpgrade()
        {
            // setup
            var rwLock  = new ReaderWriterLockSlim();
            var rValue  = new Read();
            var wValue  = new Write();
            var subject = new ReaderWriterSynchronized <Write, Read>(rwLock, wValue, rValue);

            // act and assert
            using (var rGuard = subject.UpgradeableReader.Lock())
                using (var wGuard = subject.TryLock())
                {
                    rwLock.IsWriteLockHeld.ShouldBeTrue();
                    wGuard.Value.ShouldBe(wValue);
                }

            rwLock.IsUpgradeableReadLockHeld.ShouldBeFalse();
        }
Пример #3
0
        public void WithLockAction_Reentrant()
        {
            // setup
            var rwLock  = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
            var value   = new object();
            var subject = new ReaderWriterSynchronized <object, object>(rwLock, value, value);

            // act and assert
            subject.WithLock((v) =>
            {
                subject.WithLock((v2) =>
                {
                    rwLock.IsWriteLockHeld.ShouldBeTrue();
                    v2.ShouldBe(value);
                });
            });

            rwLock.IsWriteLockHeld.ShouldBeFalse();
        }
        public void WithLockAction_Reentrant()
        {
            // setup
            var rwLock  = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
            var rValue  = new Read();
            var wValue  = new Write();
            var subject = new ReaderWriterSynchronized <Write, Read>(rwLock, wValue, rValue).UpgradeableReader;

            // act and assert
            subject.WithLock((v) =>
            {
                subject.WithLock((v2) =>
                {
                    rwLock.IsUpgradeableReadLockHeld.ShouldBeTrue();
                    v2.ShouldBe(rValue);
                });
            });

            rwLock.IsUpgradeableReadLockHeld.ShouldBeFalse();
        }
        public void WithLockActionUpgrade()
        {
            // setup
            var rwLock  = new ReaderWriterLockSlim();
            var rValue  = new Read();
            var wValue  = new Write();
            var subject = new ReaderWriterSynchronized <Write, Read>(rwLock, wValue, rValue);

            // act and assert
            subject.UpgradeableReader.WithLock((r) =>
            {
                subject.WithLock((w) =>
                {
                    rwLock.IsWriteLockHeld.ShouldBeTrue();
                    w.ShouldBe(wValue);
                });
            });

            rwLock.IsUpgradeableReadLockHeld.ShouldBeFalse();
        }
        public void BarelyTryLock_ConcurrentAcquire()
        {
            // setup
            var rwLock     = new ReaderWriterLockSlim();
            var value      = new object();
            var subject    = new ReaderWriterSynchronized <object, object>(rwLock, value, value).Reader;
            var setupEvent = new AutoResetEvent(false);

            new Thread(() =>
            {
                rwLock.EnterReadLock();
                setupEvent.Set();
            }).Start();
            setupEvent.WaitOne();

            // act and assert
            subject.BarelyTryLock(out var result).ShouldBeTrue();

            result.ShouldBe(value);
            rwLock.IsReadLockHeld.ShouldBeTrue();
        }