public void TestLock()
        {
            LockCounterFactory <SimpleReadWriteLocking> factory = new LockCounterFactory <SimpleReadWriteLocking>();
            ILockStrategy lck = factory.Create();
            SynchronizedDictionary <int, string> test = new SynchronizedDictionary <int, string>(lck);

            Assert.IsTrue(ReferenceEquals(lck, test.Lock));
            test.Add(42, "42");
            Assert.AreEqual(1, factory.TotalWriterCount);
            Assert.AreEqual(0, factory.TotalReaderCount);

            test[42] = "51";
            Assert.AreEqual(2, factory.TotalWriterCount);

            test.Add(1, "52");
            Assert.AreEqual(3, factory.TotalWriterCount);

            test.Remove(-1);
            Assert.AreEqual(4, factory.TotalWriterCount);

            test.Remove(1);
            Assert.AreEqual(5, factory.TotalWriterCount);

            Assert.AreEqual("51", test[42]);
            Assert.AreEqual(1, factory.TotalReaderCount);

            foreach (KeyValuePair <int, string> i in test)
            {
                GC.KeepAlive(i);
            }
            Assert.AreEqual(2, factory.TotalReaderCount);

            Assert.AreEqual(false, test.ContainsKey(-1));
            Assert.AreEqual(3, factory.TotalReaderCount);

            Assert.AreEqual(1, test.Count);
            Assert.AreEqual(4, factory.TotalReaderCount);

            string cmp;

            Assert.IsTrue(test.TryGetValue(42, out cmp) && cmp == "51");
            Assert.AreEqual(5, factory.TotalReaderCount);
        }
Beispiel #2
0
        public void PreTestAsserts()
        {
            LockCounterFactory counters = LockFactory as LockCounterFactory;

            if (counters != null)
            {
                counters.GlobalAssertNoLocks();
                Assert.AreEqual(0, counters.CurrentReaderCount);
                Assert.AreEqual(0, counters.CurrentWriterCount);
            }
            DebugLockFactory debug = LockFactory as DebugLockFactory;

            if (debug != null)
            {
                debug.LocalAssertNoLocks();
                Assert.AreEqual(0, debug.LocalReaderCount);
                Assert.AreEqual(0, debug.LocalWriterCount);
                debug.LimitNestedReaders = 10;
                debug.LimitNestedWriters = 10;
            }
        }
        public void TestLock()
        {
            LockCounterFactory <SimpleReadWriteLocking> factory = new LockCounterFactory <SimpleReadWriteLocking>();
            ILockStrategy          lck  = factory.Create();
            SynchronizedList <int> list = new SynchronizedList <int>(lck);

            Assert.IsTrue(ReferenceEquals(lck, list.Lock));
            list.Add(42);
            Assert.AreEqual(1, factory.TotalWriterCount);
            Assert.AreEqual(0, factory.TotalReaderCount);

            list[0] = 51;
            Assert.AreEqual(2, factory.TotalWriterCount);

            list.Insert(1, 52);
            Assert.AreEqual(3, factory.TotalWriterCount);

            list.RemoveAt(1);
            Assert.AreEqual(4, factory.TotalWriterCount);

            list.Remove(-1);
            Assert.AreEqual(5, factory.TotalWriterCount);

            Assert.AreEqual(51, list[0]);
            Assert.AreEqual(1, factory.TotalReaderCount);

            foreach (int i in list)
            {
                GC.KeepAlive(i);
            }
            Assert.AreEqual(2, factory.TotalReaderCount);

            Assert.AreEqual(0, list.IndexOf(51));
            Assert.AreEqual(3, factory.TotalReaderCount);

            Assert.AreEqual(1, list.Count);
            Assert.AreEqual(4, factory.TotalReaderCount);
        }