Test_ArgumentNullException.Messaging.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.Threading;
usingSystem.Threading.Tasks;
usingCommunityToolkit.Mvvm.Messaging;
usingCommunityToolkit.Mvvm.Messaging.Messages;
usingMicrosoft.VisualStudio.TestTools.UnitTesting;

namespaceCommunityToolkit.Mvvm.UnitTests;

publicpartialclassTest_ArgumentNullException
{
[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_ArgumentNullException_Messenger(Typetype)
{
IMessengermessenger=(IMessenger)Activator.CreateInstance(type)!;

Assert(()=>messenger.IsRegistered<DummyMessage,int>(recipient:null!,42),"recipient");
Assert(()=>messenger.IsRegistered<DummyMessage,string>(newobject(),null!),"token");

Assert(()=>messenger.Register<object,DummyMessage,string>(recipient:null!,"",(r,m)=>{}),"recipient");
Assert(()=>messenger.Register<object,DummyMessage,string>(newobject(),null!,(r,m)=>{}),"token");
Assert(()=>messenger.Register<object,DummyMessage,string>(newobject(),"",handler:null!),"handler");

Assert(()=>messenger.UnregisterAll(recipient:null!),"recipient");

Assert(()=>messenger.UnregisterAll(recipient:null!,""),"recipient");
Assert(()=>messenger.UnregisterAll<string>(newobject(),token:null!),"token");

Assert(()=>messenger.Unregister<DummyMessage,string>(recipient:null!,""),"recipient");
Assert(()=>messenger.Unregister<DummyMessage,string>(newobject(),token:null!),"token");

Assert(()=>messenger.Send<DummyMessage,string>(message:null!,""),"message");
Assert(()=>messenger.Send<DummyMessage,string>(newDummyMessage(),token:null!),"token");
}

[TestMethod]
[DataRow(typeof(StrongReferenceMessenger))]
[DataRow(typeof(WeakReferenceMessenger))]
publicvoidTest_ArgumentNullException_MessengerExtensions(Typetype)
{
IMessengermessenger=(IMessenger)Activator.CreateInstance(type)!;

Assert(()=>((IMessenger)null!).IsRegistered<DummyMessage>(newobject()),"messenger");
Assert(()=>messenger.IsRegistered<DummyMessage>(recipient:null!),"recipient");

Assert(()=>((IMessenger)null!).RegisterAll(newobject()),"messenger");
Assert(()=>messenger.RegisterAll(recipient:null!),"recipient");

Assert(()=>((IMessenger)null!).RegisterAll(newobject(),""),"messenger");
Assert(()=>messenger.RegisterAll(recipient:null!,""),"recipient");
Assert(()=>messenger.RegisterAll<string>(newobject(),token:null!),"token");

Assert(()=>((IMessenger)null!).Register(newRecipient()),"messenger");
Assert(()=>messenger.Register<DummyMessage>(recipient:null!),"recipient");

Assert(()=>((IMessenger)null!).Register(newRecipient(),""),"messenger");
Assert(()=>messenger.Register<DummyMessage,string>(recipient:null!,""),"recipient");
Assert(()=>messenger.Register<DummyMessage,string>(newRecipient(),token:null!),"token");

Assert(()=>((IMessenger)null!).Register<DummyMessage>(newobject(),(r,m)=>{}),"messenger");
Assert(()=>messenger.Register<DummyMessage>(recipient:null!,(r,m)=>{}),"recipient");
Assert(()=>messenger.Register<DummyMessage>(newobject(),handler:null!),"handler");

Assert(()=>((IMessenger)null!).Register<Recipient,DummyMessage>(newRecipient(),(r,m)=>{}),"messenger");
Assert(()=>messenger.Register<Recipient,DummyMessage>(recipient:null!,(r,m)=>{}),"recipient");
Assert(()=>messenger.Register<Recipient,DummyMessage>(newRecipient(),handler:null!),"handler");

Assert(()=>((IMessenger)null!).Register<DummyMessage,string>(newRecipient(),"",(r,m)=>{}),"messenger");
Assert(()=>messenger.Register<DummyMessage,string>(recipient:null!,"",(r,m)=>{}),"recipient");
Assert(()=>messenger.Register<DummyMessage,string>(newRecipient(),token:null!,handler:null!),"token");
Assert(()=>messenger.Register<DummyMessage,string>(newRecipient(),"",handler:null!),"handler");

Assert(()=>((IMessenger)null!).Unregister<DummyMessage>(newRecipient()),"messenger");
Assert(()=>messenger.Unregister<DummyMessage>(recipient:null!),"recipient");

Assert(()=>((IMessenger)null!).Send<DummyMessage>(),"messenger");

Assert(()=>((IMessenger)null!).Send(newDummyMessage()),"messenger");
Assert(()=>messenger.Send<DummyMessage>(message:null!),"message");

Assert(()=>((IMessenger)null!).Send<DummyMessage,string>(""),"messenger");
Assert(()=>messenger.Send<DummyMessage,string>(token:null!),"token");
}

[TestMethod]
publicvoidTest_ArgumentNullException_AsyncCollectionRequestMessage()
{
AsyncCollectionRequestMessage<int>message=new();

Assert(()=>message.Reply(response:(Task<int>)null!),"response");
Assert(()=>message.Reply(response:(Func<CancellationToken,Task<int>>)null!),"response");
}

[TestMethod]
publicvoidTest_ArgumentNullException_AsyncRequestMessage()
{
AsyncRequestMessage<int>message=new();

Assert(()=>message.Reply(response:null!),"response");
}

[TestMethod]
publicvoidTest_ArgumentNullException_PropertyChangedMessage()
{
Assert(()=>newPropertyChangedMessage<int>(sender:null!,"",0,1),"sender");
}

[TestMethod]
publicvoidTest_ArgumentNullException_RequestMessage()
{
Assert(()=>_=(int)(RequestMessage<int>)null!,"message");
}

internalclassDummyMessage
{
}

internalclassRecipient:IRecipient<DummyMessage>
{
publicvoidReceive(DummyMessagemessage)
{
thrownewNotImplementedException();
}
}
}