Esempio n. 1
0
        public void Test_Messenger_Cleanup(Type type)
        {
            var messenger = (IMessenger)Activator.CreateInstance(type);
            var recipient = new RecipientWithSomeMessages();

            messenger.Register <MessageA>(recipient);

            Assert.IsTrue(messenger.IsRegistered <MessageA>(recipient));

            void Test()
            {
                var recipient2 = new RecipientWithSomeMessages();

                messenger.Register <MessageB>(recipient2);

                Assert.IsTrue(messenger.IsRegistered <MessageB>(recipient2));

                GC.KeepAlive(recipient2);
            }

            Test();

            GC.Collect();

            // Here we just check that calling Cleanup doesn't alter the state
            // of the messenger. This method shouldn't really do anything visible
            // to consumers, it's just a way for messengers to compact their data.
            messenger.Cleanup();

            Assert.IsTrue(messenger.IsRegistered <MessageA>(recipient));
        }
Esempio n. 2
0
        public void Test_Messenger_IRecipient_SomeMessages_WithToken(Type type)
        {
            var messenger = (IMessenger)Activator.CreateInstance(type);
            var recipient = new RecipientWithSomeMessages();
            var token     = nameof(Test_Messenger_IRecipient_SomeMessages_WithToken);

            messenger.RegisterAll(recipient, token);

            Assert.IsTrue(messenger.IsRegistered <MessageA, string>(recipient, token));
            Assert.IsTrue(messenger.IsRegistered <MessageB, string>(recipient, token));

            Assert.IsFalse(messenger.IsRegistered <MessageA>(recipient));
            Assert.IsFalse(messenger.IsRegistered <MessageB>(recipient));

            Assert.AreEqual(recipient.As, 0);
            Assert.AreEqual(recipient.Bs, 0);

            messenger.Send <MessageB, string>(token);

            Assert.AreEqual(recipient.As, 0);
            Assert.AreEqual(recipient.Bs, 1);

            messenger.Send <MessageA, string>(token);

            Assert.AreEqual(recipient.As, 1);
            Assert.AreEqual(recipient.Bs, 1);

            messenger.UnregisterAll(recipient, token);

            Assert.IsFalse(messenger.IsRegistered <MessageA>(recipient));
            Assert.IsFalse(messenger.IsRegistered <MessageB>(recipient));
        }
Esempio n. 3
0
        public void Test_IRecipientGenerator_GeneratedRegistration()
        {
            var messenger = new StrongReferenceMessenger();
            var recipient = new RecipientWithSomeMessages();

            var messageA = new MessageA();
            var messageB = new MessageB();

            Action <IMessenger, object, int> registrator = Microsoft.Toolkit.Mvvm.Messaging.__Internals.__IMessengerExtensions.CreateAllMessagesRegistratorWithToken <int>(recipient);

            registrator(messenger, recipient, 42);

            Assert.IsTrue(messenger.IsRegistered <MessageA, int>(recipient, 42));
            Assert.IsTrue(messenger.IsRegistered <MessageB, int>(recipient, 42));

            Assert.IsNull(recipient.A);
            Assert.IsNull(recipient.B);

            messenger.Send(messageA, 42);

            Assert.AreSame(recipient.A, messageA);
            Assert.IsNull(recipient.B);

            messenger.Send(messageB, 42);

            Assert.AreSame(recipient.A, messageA);
            Assert.AreSame(recipient.B, messageB);
        }
Esempio n. 4
0
        public void Test_Messenger_IRecipient_SomeMessages_NoToken()
        {
            var messenger = new Messenger();
            var recipient = new RecipientWithSomeMessages();

            messenger.RegisterAll(recipient);

            Assert.IsTrue(messenger.IsRegistered <MessageA>(recipient));
            Assert.IsTrue(messenger.IsRegistered <MessageB>(recipient));

            Assert.AreEqual(recipient.As, 0);
            Assert.AreEqual(recipient.Bs, 0);

            messenger.Send <MessageA>();

            Assert.AreEqual(recipient.As, 1);
            Assert.AreEqual(recipient.Bs, 0);

            messenger.Send <MessageB>();

            Assert.AreEqual(recipient.As, 1);
            Assert.AreEqual(recipient.Bs, 1);

            messenger.UnregisterAll(recipient);

            Assert.IsFalse(messenger.IsRegistered <MessageA>(recipient));
            Assert.IsFalse(messenger.IsRegistered <MessageB>(recipient));
        }
Esempio n. 5
0
            void Test()
            {
                var recipient = new RecipientWithSomeMessages();

                weakRecipient = new WeakReference(recipient);

                messenger.Register <MessageA>(recipient);

                Assert.IsTrue(messenger.IsRegistered <MessageA>(recipient));

                Assert.AreEqual(GetRecipientsMapCount(messenger), 1);

                GC.KeepAlive(recipient);
            }
Esempio n. 6
0
        public void Test_Messenger_Reset(Type type)
        {
            var messenger = (IMessenger)Activator.CreateInstance(type);
            var recipient = new RecipientWithSomeMessages();

            messenger.RegisterAll(recipient);

            Assert.IsTrue(messenger.IsRegistered <MessageA>(recipient));
            Assert.IsTrue(messenger.IsRegistered <MessageB>(recipient));

            messenger.Reset();

            Assert.IsFalse(messenger.IsRegistered <MessageA>(recipient));
            Assert.IsFalse(messenger.IsRegistered <MessageB>(recipient));
        }