Test_Messenger.cs

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Reflection;
usingSystem.Threading;
usingSystem.Threading.Tasks;
usingCommunityToolkit.Mvvm.Messaging;
usingCommunityToolkit.Mvvm.Messaging.Messages;
usingMicrosoft.VisualStudio.TestTools.UnitTesting;

namespaceCommunityToolkit.Mvvm.UnitTests;

[TestClass]
publicpartialclassTest_Messenger
{
[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_UnregisterRecipientWithMessageType(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
object?recipient=new();

messenger.Unregister<MessageA>(recipient);
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_UnregisterRecipientWithMessageTypeAndToken(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
object?recipient=new();

messenger.Unregister<MessageA,string>(recipient,nameof(MessageA));
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_UnregisterRecipientWithToken(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
object?recipient=new();

messenger.UnregisterAll(recipient,nameof(MessageA));
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_UnregisterRecipientWithRecipient(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
object?recipient=new();

messenger.UnregisterAll(recipient);
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_RegisterAndUnregisterRecipientWithMessageType(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
object?recipient=new();

messenger.Register<MessageA>(recipient,(r,m)=>{});

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

messenger.Unregister<MessageA>(recipient);

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

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_RegisterAndUnregisterRecipientWithMessageTypeAndToken(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
object?recipient=new();

messenger.Register<MessageA,string>(recipient,nameof(MessageA),(r,m)=>{});

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

messenger.Unregister<MessageA,string>(recipient,nameof(MessageA));

Assert.IsFalse(messenger.IsRegistered<MessageA,string>(recipient,nameof(MessageA)));
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_RegisterAndUnregisterRecipientWithMessageTypeAndMultipleTokens(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
object?recipient=new();

Assert.IsFalse(messenger.IsRegistered<MessageA,int>(recipient,1));
Assert.IsFalse(messenger.IsRegistered<MessageA,int>(recipient,2));
Assert.IsFalse(messenger.IsRegistered<MessageA,string>(recipient,"a"));
Assert.IsFalse(messenger.IsRegistered<MessageA,string>(recipient,"b"));

messenger.Register<MessageA,int>(recipient,1,(r,m)=>{});

Assert.IsTrue(messenger.IsRegistered<MessageA,int>(recipient,1));
Assert.IsFalse(messenger.IsRegistered<MessageA,int>(recipient,2));
Assert.IsFalse(messenger.IsRegistered<MessageA,string>(recipient,"a"));
Assert.IsFalse(messenger.IsRegistered<MessageA,string>(recipient,"b"));

messenger.Register<MessageA,int>(recipient,2,(r,m)=>{});

Assert.IsTrue(messenger.IsRegistered<MessageA,int>(recipient,1));
Assert.IsTrue(messenger.IsRegistered<MessageA,int>(recipient,2));
Assert.IsFalse(messenger.IsRegistered<MessageA,string>(recipient,"a"));
Assert.IsFalse(messenger.IsRegistered<MessageA,string>(recipient,"b"));

messenger.Register<MessageA,string>(recipient,"a",(r,m)=>{});

Assert.IsTrue(messenger.IsRegistered<MessageA,int>(recipient,1));
Assert.IsTrue(messenger.IsRegistered<MessageA,int>(recipient,2));
Assert.IsTrue(messenger.IsRegistered<MessageA,string>(recipient,"a"));
Assert.IsFalse(messenger.IsRegistered<MessageA,string>(recipient,"b"));

messenger.Register<MessageA,string>(recipient,"b",(r,m)=>{});

Assert.IsTrue(messenger.IsRegistered<MessageA,int>(recipient,1));
Assert.IsTrue(messenger.IsRegistered<MessageA,int>(recipient,2));
Assert.IsTrue(messenger.IsRegistered<MessageA,string>(recipient,"a"));
Assert.IsTrue(messenger.IsRegistered<MessageA,string>(recipient,"b"));

messenger.Unregister<MessageA,int>(recipient,1);

Assert.IsFalse(messenger.IsRegistered<MessageA,int>(recipient,1));
Assert.IsTrue(messenger.IsRegistered<MessageA,int>(recipient,2));
Assert.IsTrue(messenger.IsRegistered<MessageA,string>(recipient,"a"));
Assert.IsTrue(messenger.IsRegistered<MessageA,string>(recipient,"b"));

messenger.Unregister<MessageA,int>(recipient,2);

Assert.IsFalse(messenger.IsRegistered<MessageA,int>(recipient,1));
Assert.IsFalse(messenger.IsRegistered<MessageA,int>(recipient,2));
Assert.IsTrue(messenger.IsRegistered<MessageA,string>(recipient,"a"));
Assert.IsTrue(messenger.IsRegistered<MessageA,string>(recipient,"b"));

messenger.Unregister<MessageA,string>(recipient,"a");

Assert.IsFalse(messenger.IsRegistered<MessageA,int>(recipient,1));
Assert.IsFalse(messenger.IsRegistered<MessageA,int>(recipient,2));
Assert.IsFalse(messenger.IsRegistered<MessageA,string>(recipient,"a"));
Assert.IsTrue(messenger.IsRegistered<MessageA,string>(recipient,"b"));

messenger.Unregister<MessageA,string>(recipient,"b");

Assert.IsFalse(messenger.IsRegistered<MessageA,int>(recipient,1));
Assert.IsFalse(messenger.IsRegistered<MessageA,int>(recipient,2));
Assert.IsFalse(messenger.IsRegistered<MessageA,string>(recipient,"a"));
Assert.IsFalse(messenger.IsRegistered<MessageA,string>(recipient,"b"));
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_RegisterAndUnregisterRecipientWithToken(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
object?recipient=new();

messenger.Register<MessageA,string>(recipient,nameof(MessageA),(r,m)=>{});

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

messenger.UnregisterAll(recipient,nameof(MessageA));

Assert.IsFalse(messenger.IsRegistered<MessageA,string>(recipient,nameof(MessageA)));
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_RegisterAndUnregisterRecipientWithRecipient(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
object?recipient=new();

messenger.Register<MessageA,string>(recipient,nameof(MessageA),(r,m)=>{});

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

messenger.UnregisterAll(recipient);

Assert.IsFalse(messenger.IsRegistered<MessageA,string>(recipient,nameof(MessageA)));
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_IsRegistered_Register_Send_UnregisterOfTMessage_WithNoToken(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
objecta=new();

Assert.IsFalse(messenger.IsRegistered<MessageA>(a));

object?recipient=null;
string?result=null;

messenger.Register<MessageA>(a,(r,m)=>
{
recipient=r;
result=m.Text;
});

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

_=messenger.Send(newMessageA{Text=nameof(MessageA)});

Assert.AreSame(recipient,a);
Assert.AreEqual(result,nameof(MessageA));

messenger.Unregister<MessageA>(a);

Assert.IsFalse(messenger.IsRegistered<MessageA>(a));

recipient=null;
result=null;

_=messenger.Send(newMessageA{Text=nameof(MessageA)});

Assert.IsNull(recipient);
Assert.IsNull(result);
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_IsRegistered_Register_Send_UnregisterRecipient_WithNoToken(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
objecta=new();

Assert.IsFalse(messenger.IsRegistered<MessageA>(a));

string?result=null;
messenger.Register<MessageA>(a,(r,m)=>result=m.Text);

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

_=messenger.Send(newMessageA{Text=nameof(MessageA)});

Assert.AreEqual(result,nameof(MessageA));

messenger.UnregisterAll(a);

Assert.IsFalse(messenger.IsRegistered<MessageA>(a));

result=null;
_=messenger.Send(newMessageA{Text=nameof(MessageA)});

Assert.IsNull(result);
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_IsRegistered_Register_Send_UnregisterOfTMessage_WithToken(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
objecta=new();

Assert.IsFalse(messenger.IsRegistered<MessageA>(a));

string?result=null;
messenger.Register<MessageA,string>(a,nameof(MessageA),(r,m)=>result=m.Text);

Assert.IsTrue(messenger.IsRegistered<MessageA,string>(a,nameof(MessageA)));

_=messenger.Send(newMessageA{Text=nameof(MessageA)},nameof(MessageA));

Assert.AreEqual(result,nameof(MessageA));

messenger.Unregister<MessageA,string>(a,nameof(MessageA));

Assert.IsFalse(messenger.IsRegistered<MessageA,string>(a,nameof(MessageA)));

result=null;
_=messenger.Send(newMessageA{Text=nameof(MessageA)},nameof(MessageA));

Assert.IsNull(result);
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_DuplicateRegistrationWithMessageType(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
object?recipient=new();

messenger.Register<MessageA>(recipient,(r,m)=>{});

_=Assert.ThrowsException<InvalidOperationException>(()=>
{
messenger.Register<MessageA>(recipient,(r,m)=>{});
});
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_DuplicateRegistrationWithMessageTypeAndToken(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
object?recipient=new();

messenger.Register<MessageA,string>(recipient,nameof(MessageA),(r,m)=>{});

_=Assert.ThrowsException<InvalidOperationException>(()=>
{
messenger.Register<MessageA,string>(recipient,nameof(MessageA),(r,m)=>{});
});
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_IRecipient_NoMessages(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
RecipientWithNoMessages?recipient=new();

messenger.RegisterAll(recipient);

// We just need to verify we got here with no errors, this
// recipient has no declared handlers so there's nothing to do
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_IRecipient_SomeMessages_NoToken(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
RecipientWithSomeMessages?recipient=new();

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));
}

// See https://github.com/CommunityToolkit/dotnet/issues/198
[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_IRecipient_SomeMessages_WithGenericTypeParameters(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
GenericRecipient<string>recipient=new();

messenger.RegisterAll(recipient);

Assert.IsTrue(messenger.IsRegistered<GenericRecipient<string>.Message>(recipient));
Assert.IsTrue(messenger.IsRegistered<ValueChangedMessage<string>>(recipient));
Assert.IsTrue(messenger.IsRegistered<MessageA>(recipient));

Assert.IsNull(recipient.ReceivedMessage1);
Assert.IsNull(recipient.ReceivedMessage2);
Assert.IsNull(recipient.ReceivedMessage3);

GenericRecipient<string>.Messagemessage1=messenger.Send(newGenericRecipient<string>.Message(newList<string>{"Hello world!"}));
ValueChangedMessage<string>message2=messenger.Send(newValueChangedMessage<string>("Hello"));
MessageAmessage3=messenger.Send<MessageA>();

Assert.AreSame(recipient.ReceivedMessage1,message1);
Assert.AreSame(recipient.ReceivedMessage2,message2);
Assert.AreSame(recipient.ReceivedMessage3,message3);

messenger.UnregisterAll(recipient);

Assert.IsFalse(messenger.IsRegistered<GenericRecipient<string>.Message>(recipient));
Assert.IsFalse(messenger.IsRegistered<ValueChangedMessage<string>>(recipient));
Assert.IsFalse(messenger.IsRegistered<MessageA>(recipient));
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_IRecipient_SomeMessages_WithToken(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
RecipientWithSomeMessages?recipient=new();
string?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));
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_RegisterWithTypeParameter(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
RecipientWithNoMessages?recipient=new(){Number=42};

intnumber=0;

messenger.Register<RecipientWithNoMessages,MessageA>(recipient,(r,m)=>number=r.Number);

_=messenger.Send<MessageA>();

Assert.AreEqual(number,42);
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger),false)]
[DataRow(typeof(WeakReferenceMessenger),true)]
publicvoidTest_Messenger_Collect_Test(Typetype,boolisWeak)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;

WeakReferenceweakRecipient;

voidTest()
{
RecipientWithNoMessages?recipient=new(){Number=42};
weakRecipient=newWeakReference(recipient);

messenger.Register<MessageA>(recipient,(r,m)=>{});

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

GC.KeepAlive(recipient);
}

Test();

GC.Collect();

Assert.AreEqual(!isWeak,weakRecipient.IsAlive);

GC.KeepAlive(messenger);
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_Reset(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
RecipientWithSomeMessages?recipient=new();

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));
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_Default(Typetype)
{
PropertyInfodefaultInfo=type.GetProperty("Default")!;

object?default1=defaultInfo!.GetValue(null);
object?default2=defaultInfo!.GetValue(null);

Assert.IsNotNull(default1);
Assert.IsNotNull(default2);
Assert.AreSame(default1,default2);
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_Cleanup(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;
RecipientWithSomeMessages?recipient=new();

messenger.Register<MessageA>(recipient);

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

voidTest()
{
RecipientWithSomeMessages?recipient2=new();

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));
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_ManyRecipients(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;

voidTest()
{
RecipientWithSomeMessages?[]recipients=Enumerable.Range(0,512).Select(_ =>newRecipientWithSomeMessages()).ToArray();

foreach(RecipientWithSomeMessages?recipientinrecipients)
{
messenger.RegisterAll(recipient!);
}

foreach(RecipientWithSomeMessages?recipientinrecipients)
{
Assert.IsTrue(messenger.IsRegistered<MessageA>(recipient!));
Assert.IsTrue(messenger.IsRegistered<MessageB>(recipient!));
}

_=messenger.Send<MessageA>();
_=messenger.Send<MessageB>();
_=messenger.Send<MessageB>();

foreach(RecipientWithSomeMessages?recipientinrecipients)
{
Assert.AreEqual(recipient!.As,1);
Assert.AreEqual(recipient!.Bs,2);
}

foreach(refRecipientWithSomeMessages?recipientinrecipients.AsSpan())
{
recipient=null;
}
}

Test();

GC.Collect();

// Just invoke a final cleanup to improve coverage, this is unrelated to this test in particular
messenger.Cleanup();
}

// See https://github.com/CommunityToolkit/WindowsCommunityToolkit/issues/4081
[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_RegisterMultiple_UnregisterSingle(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;

object?recipient1=new();
object?recipient2=new();

inthandler1CalledCount=0;
inthandler2CalledCount=0;

messenger.Register<object,MessageA>(recipient1,(r,m)=>{handler1CalledCount++;});
messenger.Register<object,MessageA>(recipient2,(r,m)=>{handler2CalledCount++;});

messenger.UnregisterAll(recipient2);

_=messenger.Send(newMessageA());

Assert.AreEqual(1,handler1CalledCount);
Assert.AreEqual(0,handler2CalledCount);
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_ConcurrentOperations_DefaultChannel_SeparateRecipients(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;

RecipientWithConcurrency[]recipients=Enumerable.Range(0,1024).Select(static _ =>newRecipientWithConcurrency()).ToArray();
DateTimeend=DateTime.Now.AddSeconds(5);

_=Parallel.For(0,recipients.Length, i =>
{
RecipientWithConcurrencyr=recipients[i];
Randomrandom=new(i);

while(DateTime.Now<end)
{
Assert.IsFalse(messenger.IsRegistered<MessageA>(r));
Assert.IsFalse(messenger.IsRegistered<MessageB>(r));

// Here we randomize the way messages are subscribed. This ensures that we're testing both the normal
// registration with a delegate, as well as the fast path within WeakReferenceMessenger that is enabled
// when IRecipient<TMessage> is used. Since broadcasts are done in parallel here, it will happen that
// some messages are broadcast when multiple recipients are active through both types of registration.
// This test verifies that the messengers work fine when this is the case (and not just when only one
// of the two method is used, as mixing them up as necessary is a perfectly supported scenario as well).
switch(random.Next(0,3))
{
case0:
messenger.Register<RecipientWithConcurrency,MessageA>(r,static(r,m)=>r.Receive(m));
messenger.Register<RecipientWithConcurrency,MessageB>(r,static(r,m)=>r.Receive(m));
break;
case1:
messenger.Register<MessageA>(r);
messenger.Register<MessageB>(r);
break;
default:
messenger.RegisterAll(r);
break;
}

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

inta=r.As;
intb=r.Bs;

_=messenger.Send<MessageA>();

// We can't just check that the count has been increased by 1, as there may be other concurrent broadcasts
Assert.IsTrue(r.As>a);

_=messenger.Send<MessageB>();

Assert.IsTrue(r.Bs>b);

switch(random.Next(0,2))
{
case0:
messenger.Unregister<MessageA>(r);
messenger.Unregister<MessageB>(r);
break;
default:
messenger.UnregisterAll(r);
break;
}
}
});
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_ConcurrentOperations_DefaultChannel_SharedRecipients(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;

RecipientWithConcurrency[]recipients=Enumerable.Range(0,512).Select(static _ =>newRecipientWithConcurrency()).ToArray();
DateTimeend=DateTime.Now.AddSeconds(5);

_=Parallel.For(0,recipients.Length*2, i =>
{
RecipientWithConcurrencyr=recipients[i/2];
Randomrandom=new(i);

while(DateTime.Now<end)
{
if(i%2==0)
{
Assert.IsFalse(messenger.IsRegistered<MessageA>(r));

switch(random.Next(0,2))
{
case0:
messenger.Register<RecipientWithConcurrency,MessageA>(r,static(r,m)=>r.Receive(m));
break;
default:
messenger.Register<MessageA>(r);
break;
}

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

inta=r.As;

_=messenger.Send<MessageA>();

Assert.IsTrue(r.As>a);

messenger.Unregister<MessageA>(r);
}
else
{
Assert.IsFalse(messenger.IsRegistered<MessageB>(r));

switch(random.Next(0,2))
{
case0:
messenger.Register<RecipientWithConcurrency,MessageB>(r,static(r,m)=>r.Receive(m));
break;
default:
messenger.Register<MessageB>(r);
break;
}

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

intb=r.Bs;

_=messenger.Send<MessageB>();

Assert.IsTrue(r.Bs>b);

messenger.Unregister<MessageB>(r);
}
}
});
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_ConcurrentOperations_WithToken_SeparateRecipients(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;

RecipientWithConcurrency[]recipients=Enumerable.Range(0,1024).Select(static _ =>newRecipientWithConcurrency()).ToArray();
string[]tokens=Enumerable.Range(0,16).Select(static i =>i.ToString()).ToArray();
DateTimeend=DateTime.Now.AddSeconds(5);

_=Parallel.For(0,recipients.Length, i =>
{
RecipientWithConcurrencyr=recipients[i];
stringtoken=tokens[i%tokens.Length];
Randomrandom=new(i);

while(DateTime.Now<end)
{
Assert.IsFalse(messenger.IsRegistered<MessageA,string>(r,token));
Assert.IsFalse(messenger.IsRegistered<MessageB,string>(r,token));

switch(random.Next(0,3))
{
case0:
messenger.Register<RecipientWithConcurrency,MessageA,string>(r,token,static(r,m)=>r.Receive(m));
messenger.Register<RecipientWithConcurrency,MessageB,string>(r,token,static(r,m)=>r.Receive(m));
break;
case1:
messenger.Register<MessageA,string>(r,token);
messenger.Register<MessageB,string>(r,token);
break;
default:
messenger.RegisterAll(r,token);
break;
}

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

inta=r.As;
intb=r.Bs;

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

Assert.IsTrue(r.As>a);

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

Assert.IsTrue(r.Bs>b);

switch(random.Next(0,3))
{
case0:
messenger.Unregister<MessageA,string>(r,token);
messenger.Unregister<MessageB,string>(r,token);
break;
case1:
messenger.UnregisterAll(r,token);
break;
default:
messenger.UnregisterAll(r);
break;
}
}
});
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_ConcurrentOperations_WithToken_SharedRecipients(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;

RecipientWithConcurrency[]recipients=Enumerable.Range(0,512).Select(static _ =>newRecipientWithConcurrency()).ToArray();
string[]tokens=Enumerable.Range(0,16).Select(static i =>i.ToString()).ToArray();
DateTimeend=DateTime.Now.AddSeconds(5);

_=Parallel.For(0,recipients.Length*2, i =>
{
RecipientWithConcurrencyr=recipients[i/2];
stringtoken=tokens[i%tokens.Length];
Randomrandom=new(i);

while(DateTime.Now<end)
{
if(i%2==0)
{
Assert.IsFalse(messenger.IsRegistered<MessageA,string>(r,token));

switch(random.Next(0,2))
{
case0:
messenger.Register<RecipientWithConcurrency,MessageA,string>(r,token,static(r,m)=>r.Receive(m));
break;
default:
messenger.Register<MessageA,string>(r,token);
break;
}

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

inta=r.As;

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

Assert.IsTrue(r.As>a);

messenger.Unregister<MessageA,string>(r,token);
}
else
{
Assert.IsFalse(messenger.IsRegistered<MessageB,string>(r,token));

switch(random.Next(0,2))
{
case0:
messenger.Register<RecipientWithConcurrency,MessageB,string>(r,token,static(r,m)=>r.Receive(m));
break;
default:
messenger.Register<MessageB,string>(r,token);
break;
}

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

intb=r.Bs;

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

Assert.IsTrue(r.Bs>b);

messenger.Unregister<MessageB,string>(r,token);
}
}
});
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_Messenger_ConcurrentOperations_Combined_SeparateRecipients(Typetype)
{
IMessenger?messenger=(IMessenger)Activator.CreateInstance(type)!;

RecipientWithConcurrency[]recipients=Enumerable.Range(0,1024).Select(static _ =>newRecipientWithConcurrency()).ToArray();
string[]wordTokens=Enumerable.Range(0,16).Select(static i =>i.ToString()).ToArray();
int[]numberTokens=Enumerable.Range(0,16).ToArray();
DateTimeend=DateTime.Now.AddSeconds(5);

_=Parallel.For(0,recipients.Length, i =>
{
RecipientWithConcurrencyr=recipients[i];
stringwordToken=wordTokens[i%wordTokens.Length];
intnumberToken=numberTokens[i%numberTokens.Length];
Randomrandom=new(i);

while(DateTime.Now<end)
{
Assert.IsFalse(messenger.IsRegistered<MessageA,string>(r,wordToken));
Assert.IsFalse(messenger.IsRegistered<MessageB,string>(r,wordToken));
Assert.IsFalse(messenger.IsRegistered<MessageA,int>(r,numberToken));
Assert.IsFalse(messenger.IsRegistered<MessageB,int>(r,numberToken));
Assert.IsFalse(messenger.IsRegistered<MessageA>(r));
Assert.IsFalse(messenger.IsRegistered<MessageB>(r));

intchoice=random.Next(0,9);

switch(choice)
{
case0:
messenger.Register<RecipientWithConcurrency,MessageA,string>(r,wordToken,static(r,m)=>r.Receive(m));
messenger.Register<RecipientWithConcurrency,MessageB,string>(r,wordToken,static(r,m)=>r.Receive(m));

Assert.IsTrue(messenger.IsRegistered<MessageA,string>(r,wordToken));
Assert.IsTrue(messenger.IsRegistered<MessageB,string>(r,wordToken));
break;
case1:
messenger.Register<RecipientWithConcurrency,MessageA,int>(r,numberToken,static(r,m)=>r.Receive(m));
messenger.Register<RecipientWithConcurrency,MessageB,int>(r,numberToken,static(r,m)=>r.Receive(m));

Assert.IsTrue(messenger.IsRegistered<MessageA,int>(r,numberToken));
Assert.IsTrue(messenger.IsRegistered<MessageB,int>(r,numberToken));
break;
case2:
messenger.Register<RecipientWithConcurrency,MessageA>(r,static(r,m)=>r.Receive(m));
messenger.Register<RecipientWithConcurrency,MessageB>(r,static(r,m)=>r.Receive(m));

Assert.IsTrue(messenger.IsRegistered<MessageA>(r));
Assert.IsTrue(messenger.IsRegistered<MessageB>(r));
break;
case3:
messenger.Register<MessageA,string>(r,wordToken);
messenger.Register<MessageB,string>(r,wordToken);

Assert.IsTrue(messenger.IsRegistered<MessageA,string>(r,wordToken));
Assert.IsTrue(messenger.IsRegistered<MessageB,string>(r,wordToken));
break;
case4:
messenger.Register<MessageA,int>(r,numberToken);
messenger.Register<MessageB,int>(r,numberToken);

Assert.IsTrue(messenger.IsRegistered<MessageA,int>(r,numberToken));
Assert.IsTrue(messenger.IsRegistered<MessageB,int>(r,numberToken));
break;
case5:
messenger.Register<MessageA>(r);
messenger.Register<MessageB>(r);

Assert.IsTrue(messenger.IsRegistered<MessageA>(r));
Assert.IsTrue(messenger.IsRegistered<MessageB>(r));
break;
case6:
messenger.RegisterAll(r,wordToken);

Assert.IsTrue(messenger.IsRegistered<MessageA,string>(r,wordToken));
Assert.IsTrue(messenger.IsRegistered<MessageB,string>(r,wordToken));
break;
case7:
messenger.RegisterAll(r,numberToken);

Assert.IsTrue(messenger.IsRegistered<MessageA,int>(r,numberToken));
Assert.IsTrue(messenger.IsRegistered<MessageB,int>(r,numberToken));
break;
default:
messenger.RegisterAll(r);