public void TestDestoryed()
        {
            Utils.WeakReference<MyObject> r;
            if (true)
            {
                MyObject obj = new MyObject();

                r = new Utils.WeakReference<MyObject>(obj);
                Assert.IsTrue(r.IsAlive);
                Assert.IsNotNull(r.Target);
                MyObject test;
                Assert.IsTrue(r.TryGetTarget(out test));
                Assert.IsTrue(ReferenceEquals(obj, test));
                test = null;
                _destroyed = false;

                GC.KeepAlive(obj);
                obj = null;
            }

            GC.GetTotalMemory(true);
            GC.WaitForPendingFinalizers();

            Assert.IsTrue(_destroyed);

            MyObject tmp;
            Assert.IsFalse(r.IsAlive);
            Assert.IsNull(r.Target);
            Assert.IsFalse(r.TryGetTarget(out tmp));
        }
Пример #2
0
        public void TestDestoryed()
        {
            Utils.WeakReference <MyObject> r;
            if (true)
            {
                MyObject obj = new MyObject();

                r = new Utils.WeakReference <MyObject>(obj);
                Assert.IsTrue(r.IsAlive);
                Assert.IsNotNull(r.Target);
                MyObject test;
                Assert.IsTrue(r.TryGetTarget(out test));
                Assert.IsTrue(ReferenceEquals(obj, test));
                test       = null;
                _destroyed = false;

                GC.KeepAlive(obj);
                obj = null;
            }

            GC.GetTotalMemory(true);
            GC.WaitForPendingFinalizers();

            Assert.IsTrue(_destroyed);

            MyObject tmp;

            Assert.IsFalse(r.IsAlive);
            Assert.IsNull(r.Target);
            Assert.IsFalse(r.TryGetTarget(out tmp));
        }
Пример #3
0
            CacheEntry GetCache(NodeHandle handle, bool isNew)
            {
                Utils.WeakReference <CacheEntry> weakRef;
                CacheEntry entry = null;

                if (!isNew)
                {
                    if (handle.TryGetCache(out weakRef) && weakRef != null && weakRef.TryGetTarget(out entry))
                    {
                        return(entry);
                    }

                    using (_cacheLock.Read(base.Options.LockTimeout))
                    {
                        if (_cache.TryGetValue(handle, out weakRef))
                        {
                            if (!weakRef.TryGetTarget(out entry))
                            {
                                using (new SafeLock <DeadlockException>(weakRef))
                                {
                                    if (!weakRef.TryGetTarget(out entry))
                                    {
                                        weakRef.Target = entry = new CacheEntry(this, handle);
                                    }
                                    handle.SetCacheEntry(weakRef);
                                }
                            }
                        }
                    }
                }
                if (entry == null)
                {
                    using (_cacheLock.Write(base.Options.LockTimeout))
                    {
                        if (!_cache.TryGetValue(handle, out weakRef))
                        {
                            _cache.Add(handle, weakRef = new Utils.WeakReference <CacheEntry>(entry = new CacheEntry(this, handle)));
                            handle.SetCacheEntry(weakRef);
                        }
                        else
                        {
                            if (!weakRef.TryGetTarget(out entry))
                            {
                                using (new SafeLock <DeadlockException>(weakRef))
                                {
                                    if (!weakRef.TryGetTarget(out entry))
                                    {
                                        weakRef.Target = entry = new CacheEntry(this, handle);
                                    }
                                    handle.SetCacheEntry(weakRef);
                                }
                            }
                        }
                    }
                }
                Assert(entry != null, "Cache entry is null");
                _keepAlive.Add(entry);
                return(entry);
            }
        public void TestReplaceTarget()
        {
            string value1 = "Testing Value - 1";
            string value2 = "Testing Value - 2";
            Utils.WeakReference<string> r = new Utils.WeakReference<string>(value1);

            string tmp;
            Assert.IsTrue(r.TryGetTarget(out tmp) && tmp == value1);

            r.Target = value2;
            Assert.IsTrue(r.TryGetTarget(out tmp) && tmp == value2);
        }
        public void TestSerialization()
        {
            string value = "Testing Value";
            Utils.WeakReference<string> r;
            r = new Utils.WeakReference<string>(value);
            Utils.WeakReference<string> r2 = new Cloning.SerializerClone().Clone(r);

            Assert.AreEqual(r.Target, r2.Target);
            Assert.AreEqual(value, r2.Target);
            string tmp;
            Assert.IsTrue(r2.TryGetTarget(out tmp) && tmp == value);
        }
Пример #6
0
        public void TestReplaceTarget()
        {
            string value1 = "Testing Value - 1";
            string value2 = "Testing Value - 2";

            Utils.WeakReference <string> r = new Utils.WeakReference <string>(value1);

            string tmp;

            Assert.IsTrue(r.TryGetTarget(out tmp) && tmp == value1);

            r.Target = value2;
            Assert.IsTrue(r.TryGetTarget(out tmp) && tmp == value2);
        }
Пример #7
0
        public void TestSerialization()
        {
            string value = "Testing Value";

            Utils.WeakReference <string> r;
            r = new Utils.WeakReference <string>(value);
            Utils.WeakReference <string> r2 = new Cloning.SerializerClone().Clone(r);

            Assert.AreEqual(r.Target, r2.Target);
            Assert.AreEqual(value, r2.Target);
            string tmp;

            Assert.IsTrue(r2.TryGetTarget(out tmp) && tmp == value);
        }
        public void TestReplaceBadTypeTarget()
        {
            string value1 = "Testing Value - 1";
            object value2 = new MyObject();
            Utils.WeakReference<string> r = new Utils.WeakReference<string>(value1);

            string tmp;
            Assert.IsTrue(r.TryGetTarget(out tmp) && tmp == value1);

            ((WeakReference)r).Target = value2; //incorrect type...
            Assert.IsFalse(r.IsAlive);
            Assert.IsNull(r.Target);
            Assert.IsFalse(r.TryGetTarget(out tmp));

            Assert.IsTrue(ReferenceEquals(value2, ((WeakReference)r).Target));
        }
Пример #9
0
        public void TestReplaceBadTypeTarget()
        {
            string value1 = "Testing Value - 1";
            object value2 = new MyObject();

            Utils.WeakReference <string> r = new Utils.WeakReference <string>(value1);

            string tmp;

            Assert.IsTrue(r.TryGetTarget(out tmp) && tmp == value1);

            ((WeakReference)r).Target = value2; //incorrect type...
            Assert.IsFalse(r.IsAlive);
            Assert.IsNull(r.Target);
            Assert.IsFalse(r.TryGetTarget(out tmp));

            Assert.IsTrue(ReferenceEquals(value2, ((WeakReference)r).Target));
        }