public void FindWeakT_NullDelegate_ReturnsHandler()
        {
            var s1 = new Stub1();
            EventHandler <EventArgs> handler = s1.Handler;

            Assert.IsNull(s1.StubEvent);
            Assert.AreSame(handler, WeakEventHandlerExtensions.FindWeak <EventArgs>(s1.StubEvent, handler));
        }
        public void FindWeakT_NotWeak_ReturnsStrongHandler()
        {
            var s1 = new Stub1();
            EventHandler <EventArgs> handler = s1.Handler;

            s1.StubEvent += handler;
            Assert.AreSame(handler, WeakEventHandlerExtensions.FindWeak <EventArgs>(s1.StubEvent, handler));
        }
        public void MakeWeakT_FireEvent_SourceHandlerCalled()
        {
            var s1 = new Stub1();
            var weakEventHandler = WeakEventHandlerExtensions.MakeWeak <EventArgs>(s1.Handler, args => { });

            weakEventHandler(this, new EventArgs());
            Assert.AreEqual(1, s1.FireCount);
        }
        public void MakeWeakT_AlreadyWeak_ReturnsExisting()
        {
            var s1 = new Stub1();
            var weakEventHandler1 = WeakEventHandlerExtensions.MakeWeak <EventArgs>(s1.Handler, args => { });
            var weakEventHandler2 = WeakEventHandlerExtensions.MakeWeak <EventArgs>(weakEventHandler1, args => { });

            Assert.AreSame(weakEventHandler1, weakEventHandler2);
        }
        public void FindWeakT_StaticHandler_ReturnsStaticHandler()
        {
            var s1 = new Stub1();

            s1.StubEvent += (o, args) => { }; // Make s1.StubEvent!=null
            EventHandler <EventArgs> handler = StaticHandler;

            Assert.AreSame(handler, WeakEventHandlerExtensions.FindWeak <EventArgs>(s1.StubEvent, handler));
        }
        public void MakeWeakT_DoesntPreventGC()
        {
            var           s1  = new Stub1();
            WeakReference ws1 = new WeakReference(s1);
            var           weakEventHandler1 = WeakEventHandlerExtensions.MakeWeak <EventArgs>(s1.Handler, args => { });

            s1 = null;
            GC.Collect();
            Assert.IsFalse(ws1.IsAlive);
        }
        public void FindWeakT_IsWeak_CallsIsHandlerFor()
        {
            var weakMock = new WeakEventHandlerMock <EventArgs>();
            var s1       = new Stub1();

            s1.StubEvent += weakMock.HandlerT;
            EventHandler <EventArgs> strongHandler = s1.Handler;
            EventHandler <EventArgs> weakHandler   = WeakEventHandlerExtensions.FindWeak <EventArgs>(s1.StubEvent, strongHandler);

            Assert.AreEqual(weakMock.HandlerT, weakHandler);
            Assert.AreSame(weakMock.LastIsHandlerFor, strongHandler);
        }
        public void MakeWeakT_AnonymousMethod_Throws()
        {
            int counter = 0; // We have to capture something in order to create a closure that the called code can detec.

            WeakEventHandlerExtensions.MakeWeak <EventArgs>((o, args) => ++ counter, args => { });
        }
 public void MakeWeakT_StaticHandler_Throws()
 {
     WeakEventHandlerExtensions.MakeWeak <EventArgs>(StaticHandler, args => { });
 }
        public void MakeWeakT_NullUnregister_Throws()
        {
            var s1 = new Stub1();

            WeakEventHandlerExtensions.MakeWeak <EventArgs>(s1.Handler, null);
        }
 public void MakeWeakT_NullEvent_Throws()
 {
     WeakEventHandlerExtensions.MakeWeak <EventArgs>(null, args => { });
 }
        public void FindWeakT_NullHandler_Throws()
        {
            var s1 = new Stub1();

            WeakEventHandlerExtensions.FindWeak <EventArgs>(s1.StubEvent, null);
        }